CLI: capture and curation

These commands write or modify memory state. Use --dry-run where available, keep project slugs explicit in automation, and inspect proposals before approving replacement decisions.

Command	Writes	Purpose
`codifix remember`	Yes	Capture and curate completed work into memory.
`codifix capture`	Yes	Store structured raw task context from a file.
`codifix scan`	Yes	Scan a repo for candidate durable memories.
`codifix ingest`	Yes	Import documents from a directory, with or without a Git repository.
`codifix curate`	Yes	Convert raw captures into canonical memories.
`codifix proposals`	Yes	Review, approve, or reject memory replacement proposals.
`codifix consolidate`	Mixed	Find related memories and prepare higher-level insight proposals.
`codifix structure`	No	Inspect the insight tree and discovered consolidation groups.
`codifix review`	Mixed	Review validation corrections proposed for existing memories.
`codifix archive`	Yes	Archive low-signal memories by confidence and importance.
`codifix prune-history`	Yes	Prune old versions and tombstoned canonicals.
`codifix checkpoint`	Yes	Save, inspect, and verify execution checkpoints.

`codifix remember`

Use this after meaningful completed work.

codifix remember --project memory \
  --title "Expanded docs-site CLI reference" \
  --type documentation \
  --summary "Grouped the CLI docs into setup, service, query, capture, repository, and integration pages." \
  --note "Updated docs-site/content/docs/reference/cli and verified the Next.js docs build." \
  --file-changed docs-site/content/docs/reference/cli/index.mdx

Remember should store durable, human-readable text with evidence. It is not a substitute for committing code or writing user docs.

`codifix capture` and `codifix curate`

Capture stores raw context; curate turns raw captures into canonical memories.

codifix capture --file task-context.json
codifix curate --project memory
codifix curate --project memory --batch-size 10 --dry-run

Use this split when another tool produces structured capture payloads or when curation needs to be retried separately.

`codifix scan`

Scan asks the repository what durable memories can be inferred from code, docs, and history.

codifix scan --project memory --dry-run
codifix scan --project memory --rebuild-index
codifix scan --project memory --dry-run --json

Scan is useful for onboarding an existing repository, but it is not a replacement for human review. Prefer smaller scans when investigating a subsystem.

`codifix ingest`

Ingest is the document-first counterpart to repository scanning. It works when the source is a folder of notes, exported documents, or other material that does not need Git metadata.

codifix ingest ./research --project memory --dry-run
codifix ingest ./research --project memory

`codifix proposals`

Not to be confused with codifix review, which handles corrections proposed by memory validation. codifix proposals reviews curation replacement decisions for newly captured memories.

Proposals protect existing canonical memories from automatic replacement.

codifix proposals list --project memory --json
codifix proposals show --project memory --id <uuid>
codifix proposals approve --project memory --id <uuid> --json
codifix proposals reject  --project memory --id <uuid> --json

Approve only when the replacement is better supported and more current. Reject when the old memory remains correct or the proposal lacks enough evidence.

`codifix consolidate` and `codifix structure`

Consolidation discovers clusters of related memories and synthesizes each accepted cluster into a higher-level insight memory — always as a human-gated proposal, never a direct write.

codifix consolidate --project memory --dry-run   # deterministic scan, no LLM
codifix consolidate --project memory             # scan + synthesize proposals
codifix loops memory-proposals --project memory --status pending
codifix structure --project memory               # insight tree + discovered groups

codifix structure is the read-only view of the result: the committed insight tree (summarizes relations, recursive across tiers) plus the clusters a scan would currently propose. Requires the memory_consolidation loop to be enabled for non-dry runs.

`codifix archive` and `codifix prune-history`

Archive hides low-signal memories without deleting their audit trail. Prune removes old versions and tombstones according to retention rules.

codifix archive --project memory --dry-run
codifix archive --project memory --max-confidence 0.2 --dry-run
codifix prune-history --project memory --tombstone-after 90d --superseded-after 180d --dry-run

Run dry-runs first and keep backups before aggressive cleanup.

`codifix checkpoint`

Checkpoint tracks plan execution and interruption recovery.

codifix checkpoint start-execution --project memory --plan-file approved-plan.md
codifix checkpoint show --project memory
codifix checkpoint finish-execution --project memory
codifix checkpoint finish-execution --project memory --plan-file approved-plan.md --json

Use it for plan-backed work so future agents can see what started, what remains, and whether the implementation was verified.

On this page