akm-cli 0.9.0-rc.5 → 0.9.0-rc.6

package/dist/assets/hints/cli-hints-full.md

@@ -1,6 +1,6 @@
 # akm CLI — Full Reference
 
-You have access to a searchable library of scripts, skills, commands, agents, knowledge documents, workflows, wikis, and memories via `akm`. Search your sources first before writing something from scratch.
+You have access to a searchable library of scripts, skills, commands, agents, knowledge documents, workflows, and memories via `akm`. Search your sources first before writing something from scratch.
 
 ## Search
 
@@ -18,7 +18,7 @@ akm search "knowledge:"                       # List every asset of a type
 
 | Flag | Values | Default |
 | --- | --- | --- |
-| `--type` | `skill`, `command`, `agent`, `knowledge`, `workflow`, `script`, `memory`, `env`, `secret`, `wiki`, `any` | `any` |
+| `--type` | `skill`, `command`, `agent`, `knowledge`, `workflow`, `script`, `memory`, `env`, `secret`, `any` | `any` |
 | `--source` | `stash`, `registry`, `both` | `stash` |
 | `--limit` | number | `20` |
 | `--format` | `json`, `jsonl`, `text`, `yaml` | `json` |
@@ -26,10 +26,10 @@ akm search "knowledge:"                       # List every asset of a type
 | `--shape` | `human`, `agent`, `summary` (`summary` only on `show`) | `human` |
 
 Ref-prefix queries (`"<type>:<prefix>/"` or a bare `"<type>:"`) return a
-deterministic listing, not a relevance ranking. A full ref without the
-trailing slash (`memory:projectA/auth-tip`) stays an ordinary keyword search —
-resolving a single ref is `akm show`'s job — and an explicit `--type` flag
-wins over the type parsed from the query.
+deterministic listing, not a relevance ranking. Drop the trailing slash and the
+same text becomes an ordinary keyword search — resolving a single asset by its
+`<subdir>/<name>` id is `akm show`'s job — and an explicit `--type` flag wins
+over the type parsed from the query.
 
 ## Curate
 
@@ -46,15 +46,15 @@ akm curate "review architecture" --type workflow # Restrict to one asset type
 Display an asset by ref. Knowledge assets support view modes as positional arguments.
 
 ```sh
-akm show script:deploy.sh                     # Show script (returns run command)
-akm show skill:code-review                    # Show skill (returns full content)
-akm show command:release                      # Show command (returns template)
-akm show agent:architect                      # Show agent (returns system prompt)
-akm show workflow:ship-release                # Show parsed workflow steps
-akm show knowledge:guide toc                  # Table of contents
-akm show knowledge:guide section "Auth"       # Specific section
-akm show knowledge:guide lines 10 30          # Line range
-akm show knowledge:my-doc                    # Show content (local or remote)
+akm show scripts/deploy.sh                    # Show script (returns run command)
+akm show skills/code-review                   # Show skill (returns full content)
+akm show commands/release                     # Show command (returns template)
+akm show agents/architect                     # Show agent (returns system prompt)
+akm show workflows/ship-release               # Show parsed workflow steps
+akm show knowledge/guide toc                  # Table of contents
+akm show knowledge/guide section "Auth"       # Specific section
+akm show knowledge/guide lines 10 30          # Line range
+akm show knowledge/my-doc                     # Show content (local or remote)
 ```
 
 | Type | Key fields returned |
@@ -68,7 +68,6 @@ akm show knowledge:my-doc                    # Show content (local or remote)
 | memory | `content` (recalled context) |
 | env | `keys` (key names only — values and comment text never returned) |
 | secret | `name` only (the whole file is the value — never returned) |
-| wiki | `content` (same view modes as knowledge). For any wiki task, run `akm wiki list`. To ingest sources, `akm wiki ingest <name>` dispatches the configured agent (`defaults.engine` or `--engine`) to execute the ingest workflow. |
 
 ## Capture Knowledge While You Work
 
@@ -76,65 +75,53 @@ akm show knowledge:my-doc                    # Show content (local or remote)
 akm remember "Deployment needs VPN access"     # Record a memory in your stash
 akm remember --name release-retro < notes.md   # Save multiline memory from stdin
 akm remember "note" --target my-other-stash    # Route write to a named writable stash source
-akm remember "note" --xref knowledge:auth-flow # Cite provenance in frontmatter xrefs (repeatable; ref must resolve)
-akm remember "fix" --supersedes memory:old-note # Write a correction AND demote the old asset (beliefState: superseded)
+akm remember "note" --xref knowledge/auth-flow # Cite provenance in frontmatter xrefs (repeatable; ref must resolve)
+akm remember "fix" --supersedes memories/old-note # Write a correction AND demote the old asset (beliefState: superseded)
 akm import ./docs/auth-flow.md                 # Import a file as knowledge
-akm import ./doc.md --xref knowledge:auth-flow # Merge provenance xrefs into the imported doc's frontmatter
-akm import ./new.md --supersedes knowledge:old # Import a correction AND demote the doc it replaces
+akm import ./doc.md --xref knowledge/auth-flow # Merge provenance xrefs into the imported doc's frontmatter
+akm import ./new.md --supersedes knowledge/old # Import a correction AND demote the doc it replaces
 akm import - --name scratch-notes < notes.md   # Import stdin as a knowledge doc
 akm import https://example.com/docs/auth       # Fetch one URL and import it as knowledge
 akm import ./doc.md --target my-other-stash    # Route import to a named writable stash source
 akm workflow create ship-release               # Create a workflow asset in the stash
 akm workflow validate workflows/foo.yaml       # Validate a YAML v2/markdown workflow or ref; lists every error
-akm workflow next workflow:ship-release        # Start or resume the next workflow step
-akm feedback skill:code-review --positive      # Record that an asset helped
-akm feedback agent:reviewer --negative         # Record that an asset missed the mark
-akm feedback memory:deployment-notes --positive # Works for memories too
-akm feedback env:prod --positive               # Records env feedback without surfacing values
+akm workflow next workflows/ship-release       # Start or resume the next workflow step
+akm feedback skills/code-review --positive     # Record that an asset helped
+akm feedback agents/reviewer --negative        # Record that an asset missed the mark
+akm feedback memories/deployment-notes --positive # Works for memories too
+akm feedback env/prod --positive               # Records env feedback without surfacing values
 ```
 
 Use `akm feedback` whenever an asset materially helps or fails so future search
 ranking can learn from actual usage.
 
-## Wikis
+## LLM Wiki bundles
 
-Multi-wiki knowledge bases (Karpathy-style). A stash-owned wiki lives at
-`<stashDir>/wikis/<name>/`; external directories or repos can also be registered
-as first-class wikis. akm owns lifecycle + raw-slug + lint + index regeneration
-for stash-owned wikis; page edits use your native Read/Write/Edit tools.
+An LLM Wiki (Karpathy-style knowledge base) is a **bundle format**, not an akm
+asset type — there is no `akm wiki` command family. akm's LLM Wiki adapter
+recognizes one deterministically at install time: a bundle component whose root
+holds a `schema.md` plus a `pages/` directory is mounted as an `llm-wiki`
+component. Its pages are then indexed like any other content and resolve to
+`bundle//conceptId` refs (e.g. `team-catalog//pages/attention`).
+
+Install one as a source, then search and read its pages with the ordinary
+commands — no wiki-specific verbs:
 
 ```sh
-akm wiki list                                  # List wikis (name, pages, raws, last-modified)
-akm wiki create research                       # Scaffold a new wiki
-akm wiki register ics-docs ~/code/ics-documentation # Register an external wiki
-akm wiki show research                         # Path, description, counts, last 3 log entries
-akm wiki pages research                        # Page refs + descriptions (excludes schema/index/log; includes raw/)
-akm wiki search research "attention"           # Scoped search (equivalent to --type wiki --wiki research)
-akm wiki stash research ./paper.md             # Copy source into raw/<slug>.md (never overwrites)
-akm wiki stash research https://example.com/paper # Fetch one URL into raw/<slug>.md
-akm wiki stash research ./paper.md --target my-stash # Route write to a named writable stash source
-echo "..." | akm wiki stash research -         # stdin form
-akm wiki lint research                         # Structural checks: orphans, broken xrefs, uncited raws, stale index
-akm wiki ingest research                       # Dispatch defaults.engine to run the ingest workflow on this wiki
-akm wiki ingest research --engine claude --model sonnet  # Override engine and model
-akm wiki ingest research --timeout-ms 600000   # Override the invocation timeout
-akm wiki remove research -y                    # Delete pages/schema/index/log; preserves raw/ (--force is a deprecated alias for -y)
-akm wiki remove research -y --with-sources     # Full nuke, including raw/
+akm add owner/llm-wiki-repo                    # Install an LLM Wiki bundle as a source (npm, GitHub, git, or local dir)
+akm search "attention"                         # Wiki pages surface in ordinary search results
+akm show team-catalog//pages/attention          # Read a page by its bundle//conceptId ref (copy the ref from search)
+akm list                                       # Confirm the bundle is installed
 ```
 
-**For any wiki task, start with `akm wiki list`. Then `akm wiki ingest <name>`
-dispatches the configured agent (`defaults.engine` or `--engine`) to execute
-the wiki's ingest workflow end-to-end — schema read, source dedup, search,
-page create/update, log entry, lint, reindex.** Wiki pages are also addressable as
-`wiki:<name>/<page-path>` and show up in stash-wide `akm search` as
-`type: wiki`. Files under `raw/` and the wiki root infrastructure files
+Files under the bundle's `raw/` directory and the wiki infrastructure files
 `schema.md`, `index.md`, and `log.md` are not indexed and do not appear in
 search results. No `--llm` anywhere — akm never reasons about page content.
 
 ## Env files
 
 A group of related CONFIGURATION for an app/service in one `.env` file at
-`<stashDir>/env/<name>.env`, sourced/injected wholesale. Key names are
+`<stash>/env/<name>.env`, sourced/injected wholesale. Key names are
 discoverable; values and comment text stay on disk and never reach stdout or
 the index (comments can contain commented-out credentials). akm does not edit
 entries — you edit the file with your own editor and akm loads it.
@@ -143,31 +130,31 @@ entries — you edit the file with your own editor and akm loads it.
 akm env create prod                           # Create an empty env file
 akm env create prod --from-file ./.env        # Ingest an existing .env
 akm env list                                  # List all env files across stashes with key names
-akm show env:prod                             # Inspect key names (never values or comments)
-akm env run env:prod -- ./deploy.sh           # Run a command with the whole .env injected (the safe path)
-akm env run env:prod -- $SHELL                # Open an interactive shell with values injected
-akm env export env:prod --out ./env.sh        # Write a sourceable script to a file (mode 0600)
-akm env path env:prod --quiet                 # Print the raw file path (for Docker `_FILE` / `--env-file`)
-akm env remove env:prod                       # Delete the env file
+akm show env/prod                             # Inspect key names (never values or comments)
+akm env run env/prod -- ./deploy.sh           # Run a command with the whole .env injected (the safe path)
+akm env run env/prod -- $SHELL                # Open an interactive shell with values injected
+akm env export env/prod --out ./env.sh        # Write a sourceable script to a file (mode 0600)
+akm env path env/prod --quiet                 # Print the raw file path (for Docker `_FILE` / `--env-file`)
+akm env remove env/prod                       # Delete the env file
 ```
 
 ## Secrets
 
 A single sensitive value used on its own for authentication (a token, key, or
-cert) — one file = one value at `<stashDir>/secrets/<name>`. The ENTIRE file is
+cert) — one file = one value at `<stash>/secrets/<name>`. The ENTIRE file is
 the value; only the name is ever surfaced.
 
 ```sh
-printf '%s' "$TOKEN" | akm secret set secret:deploy-token   # Store a single value
+printf '%s' "$TOKEN" | akm secret set secrets/deploy-token  # Store a single value
 akm secret list                                             # List secrets (names only)
-akm secret path secret:deploy-token                         # Print the file path (Docker `_FILE`)
-akm secret run secret:deploy-token GITHUB_TOKEN -- gh release create v1.0.0  # Inject into one env var
-akm secret remove secret:deploy-token                       # Delete the secret
+akm secret path secrets/deploy-token                        # Print the file path (Docker `_FILE`)
+akm secret run secrets/deploy-token GITHUB_TOKEN -- gh release create v1.0.0  # Inject into one env var
+akm secret remove secrets/deploy-token                      # Delete the secret
 ```
 
 ## Workflows
 
-Workflows live under `<stashDir>/workflows/` as markdown or YAML v2 (`.yaml`/`.yml`).
+Workflows live under `<stash>/workflows/` as markdown or YAML v2 (`.yaml`/`.yml`).
 
 Ref-based workflow commands are scoped to the current project/worktree/directory,
 so one active run does not block unrelated directories from starting the same
@@ -176,8 +163,8 @@ workflow. Direct run-id commands still target the exact run.
 ```sh
 akm workflow template                         # Print a starter workflow template
 akm workflow create ship-release             # Scaffold a new workflow asset
-akm workflow start workflow:ship-release     # Start a new run in the current scope
-akm workflow next workflow:ship-release      # Advance to the next step (or auto-start) in the current scope
+akm workflow start workflows/ship-release    # Start a new run in the current scope
+akm workflow next workflows/ship-release     # Advance to the next step (or auto-start) in the current scope
 akm workflow complete <run-id>               # Mark a step complete and advance
 akm workflow status <run-id>                 # Show the exact run by id
 akm workflow resume <run-id>                 # Resume a blocked or failed run
@@ -193,7 +180,7 @@ akm clone <ref>                               # Clone to working stash
 akm clone <ref> --name new-name               # Rename on clone
 akm clone <ref> --dest ./project/.claude       # Clone to custom location
 akm clone <ref> --force                       # Overwrite existing
-akm clone "npm:@scope/pkg//script:deploy.sh"  # Clone from remote package
+akm clone "npm:@scope/pkg//scripts/deploy.sh" # Clone from remote package
 ```
 
 When `--dest` is provided, `akm init` is not required first.
@@ -209,11 +196,11 @@ and re-keys the index row in place so the asset's learned ranking history
 survives.
 
 ```sh
-akm mv memory:projectA/old-note projectA/new-note  # Rename; subdirectories allowed in the new name
-akm mv memory:solo memory:renamed-solo             # Same-type ref-shaped target also accepted
+akm mv memories/projectA/old-note projectA/new-note  # Rename; subdirectories allowed in the new name
+akm mv memories/solo memories/renamed-solo           # Same-type ref-shaped target also accepted
 ```
 
-Wiki refs, cross-type targets, existing targets, `../` escapes, non-canonical
+Cross-type targets, existing targets, `../` escapes, non-canonical
 source spellings (the error names the canonical ref), `.derived` twin sources
 (rename the base — the twin follows), and `.derived`-suffixed target names are
 rejected (exit 2, nothing moved). Read-only sources are scanned but never
@@ -321,10 +308,10 @@ akm improve <ref>                                       # Propose improvement fo
 akm proposal list                                       # List pending proposals
 akm proposal show <id>                                  # Render the proposal body
 akm proposal diff <ref-or-id>                           # Diff by ref, UUID, or 8-char prefix
-akm proposal diff skill:akm-dream                       # Diff by asset ref
+akm proposal diff skills/akm-dream                      # Diff by asset ref
 akm proposal accept 7c115132                            # Accept by UUID prefix
 akm proposal accept <id> --target team-stash            # Accept to a named writable stash source
-akm proposal reject skill:my-skill --reason "not ready" # Reject by asset ref
+akm proposal reject skills/my-skill --reason "not ready" # Reject by asset ref
 akm proposal reject <id> --reason "..."                 # Archive with a reason
 akm proposal revert <id>                                # Restore the pre-promotion content
 ```

package/dist/assets/hints/cli-hints-short.md

@@ -1,6 +1,6 @@
 # akm CLI
 
-You have access to a searchable library of scripts, skills, commands, agents, knowledge documents, workflows, wikis, and memories via `akm`. Search your sources first before writing something from scratch.
+You have access to a searchable library of scripts, skills, commands, agents, knowledge documents, workflows, and memories via `akm`. Search your sources first before writing something from scratch.
 
 ## Agent Task Loop
 
@@ -11,12 +11,12 @@ For any task, follow this loop:
 4. `akm feedback <ref> --positive` — record success
 
 For workflow tasks:
-1. `akm workflow next workflow:<name>` — get current step instructions
+1. `akm workflow next workflows/<name>` — get current step instructions
 2. Do the step work in your workspace
 3. `akm workflow complete <run-id> --step <step-id>` — mark done, get next step
 
 Workflow runs are scoped to your current project/worktree/directory. Ref-based
-commands like `workflow next workflow:<name>`, `workflow status workflow:<name>`,
+commands like `workflow next workflows/<name>`, `workflow status workflows/<name>`,
 and `workflow list` operate within the current scope only.
 
 ## Quick Reference
@@ -31,20 +31,17 @@ akm show <ref>                                # View asset details
 akm workflow next <ref>                       # Start or resume a workflow
 akm remember "Deployment needs VPN access"    # Record a memory in your stash
 akm remember "note" --target my-stash         # Route write to a named writable stash source
-akm remember "note" --xref knowledge:auth-flow # Cite provenance in frontmatter xrefs (repeatable)
-akm remember "fix" --supersedes memory:old-note # Write a correction AND demote the superseded asset
+akm remember "note" --xref knowledge/auth-flow # Cite provenance in frontmatter xrefs (repeatable)
+akm remember "fix" --supersedes memories/old-note # Write a correction AND demote the superseded asset
 akm import ./notes/release-checklist.md       # Import a knowledge doc into your stash
 akm import ./doc.md --target my-stash         # Route import to a named writable stash source
-akm wiki list                                 # List available wikis
-akm wiki ingest <name>                        # Dispatch an agent to run the ingest workflow (uses defaults.engine or --engine)
-akm wiki stash <name> ./paper.md --target my-stash # Route wiki stash write to a named source
-akm proposal diff skill:akm-dream             # Diff proposal by ref, UUID, or 8-char prefix
+akm proposal diff skills/akm-dream            # Diff proposal by ref, UUID, or 8-char prefix
 akm proposal accept 7c115132                  # Accept by UUID prefix
-akm proposal reject skill:my-skill --reason "..."  # Reject by ref
+akm proposal reject skills/my-skill --reason "..."  # Reject by ref
 akm feedback <ref> --positive|--negative      # Record whether an asset helped
 akm add <ref>                                 # Add a source (npm, GitHub, git, local dir)
 akm clone <ref>                               # Copy an asset to the working stash (optional --dest arg to clone to specific location)
-akm mv memory:old-note new-note               # Rename an asset: inbound refs rewritten, ranking history preserved
+akm mv memories/old-note new-note             # Rename an asset: inbound refs rewritten, ranking history preserved
 akm sync                                      # Commit (and push if writable remote) changes in the primary stash (--no-push to commit only)
 akm improve --no-sync                         # Run improve without the end-of-run auto-commit
 akm improve --no-push                         # Auto-commit but skip push for this run
@@ -64,7 +61,6 @@ akm registry search "<query>"                 # Search all registries
 | memory | Recalled context (read the content for background information) |
 | env | A `.env` file of related CONFIGURATION (many vars; sensitive or not — all protected); key names only. Inject with `akm env run <ref> -- <cmd>` (the agent-safe path — values stay on disk). |
 | secret | A single sensitive value for AUTHENTICATION (token, key, cert); name only. Use `akm secret path` / `akm secret run`. |
-| wiki | A page in a multi-wiki knowledge base. For any wiki task, start with `akm wiki list`. To ingest sources, run `akm wiki ingest <name>` — it dispatches the configured agent engine to execute the ingest workflow against the wiki's `raw/` directory. Run `akm wiki -h` for the full surface. |
 
 When an asset meaningfully helps or fails, record that with `akm feedback` so
 future search ranking can learn from real usage.

package/dist/assets/improve-strategies/default.json

@@ -1,21 +1,19 @@
 {
-  "description": "Standard improve pass — all sub-processes + sustaining proactive lane.",
+  "description": "Standard improve pass — reflect, distill, consolidate, memory inference, graph extraction, and validation; improve-stage extract and proactive maintenance off.",
   "processes": {
     "reflect": {
       "enabled": true,
       "limit": 25,
-      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
     "distill": { "enabled": true, "allowedTypes": ["memory"], "requirePlannedRefs": true },
     "consolidate": { "enabled": true, "allowedTypes": ["memory"], "minPoolSize": 500 },
     "memoryInference": { "enabled": true },
     "graphExtraction": { "enabled": true },
-    "extract": { "enabled": true, "triage": { "enabled": true, "minScore": 2 } },
+    "extract": { "enabled": false, "triage": { "enabled": true, "minScore": 2 } },
     "validation": { "enabled": true },
-    "proactiveMaintenance": { "enabled": true, "dueDays": 30, "maxPerRun": 15 },
-    "triage": { "enabled": false, "applyMode": "queue", "policy": "personal-stash" },
-    "recombine": { "enabled": false },
-    "procedural": { "enabled": false }
+    "proactiveMaintenance": { "enabled": false, "dueDays": 30, "maxPerRun": 15 },
+    "triage": { "enabled": false, "applyMode": "queue", "policy": "personal-stash" }
   },
   "sync": { "enabled": true, "push": true }
 }

package/dist/assets/improve-strategies/frequent.json

@@ -1,12 +1,12 @@
 {
-  "description": "Frequent extract + inference pass — sessions, memory inference, graph, reflect.",
+  "description": "Frequent inference pass — memory inference, graph extraction, and reflect; improve-stage extract off.",
   "processes": {
     "reflect": { "enabled": true },
     "distill": { "enabled": false },
     "consolidate": { "enabled": false },
     "memoryInference": { "enabled": true },
     "graphExtraction": { "enabled": true },
-    "extract": { "enabled": true, "minNewSessions": 3, "triage": { "enabled": true, "minScore": 2 } },
+    "extract": { "enabled": false, "minNewSessions": 3, "triage": { "enabled": true, "minScore": 2 } },
     "triage": { "enabled": false },
     "validation": { "enabled": false },
     "proactiveMaintenance": { "enabled": false }

package/dist/assets/improve-strategies/proactive-maintenance.json

@@ -1,9 +1,9 @@
 {
-  "description": "Proactive-maintenance pass — reflect, distill, proposal triage (promote, high budget), and the proactive-maintenance lane (maxPerRun 100); consolidate/memoryInference/graphExtraction/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
+  "description": "Opt-in proactive-maintenance pass — reflect, distill, proposal triage (promote, high budget), and the proactive-maintenance lane (maxPerRun 100); consolidate/memoryInference/graphExtraction/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
   "processes": {
     "reflect": {
       "enabled": true,
-      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
     "distill": { "enabled": true, "allowedTypes": ["memory"] },
     "consolidate": { "enabled": false },

package/dist/assets/improve-strategies/quick.json

@@ -3,7 +3,7 @@
   "processes": {
     "reflect": {
       "enabled": true,
-      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
     "extract": { "enabled": false },
     "distill": { "enabled": false },

package/dist/assets/improve-strategies/reflect-distill.json

@@ -1,9 +1,9 @@
 {
-  "description": "Reflect + distill sustaining pass — reflect, distill, memoryInference, proposal triage (promote), and the proactive-maintenance lane; consolidate/graphExtraction/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
+  "description": "Reflect + distill pass — reflect, distill, memoryInference, and proposal triage (promote); proactiveMaintenance/consolidate/graphExtraction/extract off. Sync disabled: an interrupted run would otherwise leave an uncommitted backlog.",
   "processes": {
     "reflect": {
       "enabled": true,
-      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
     "distill": { "enabled": true, "allowedTypes": ["memory"] },
     "consolidate": { "enabled": false },
@@ -24,7 +24,7 @@
       "maxDiffLines": 200,
       "judgment": {}
     },
-    "proactiveMaintenance": { "enabled": true, "dueDays": 30, "maxPerRun": 15 }
+    "proactiveMaintenance": { "enabled": false, "dueDays": 30, "maxPerRun": 15 }
   },
   "sync": { "enabled": false }
 }

package/dist/assets/improve-strategies/thorough.json

@@ -3,7 +3,7 @@
   "processes": {
     "reflect": {
       "enabled": true,
-      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "wiki", "workflow"]
+      "allowedTypes": ["agent", "command", "knowledge", "lesson", "memory", "skill", "workflow"]
     },
     "distill": { "enabled": true, "allowedTypes": ["memory"] },
     "consolidate": { "enabled": true, "allowedTypes": ["memory"] },

package/dist/assets/prompts/consolidate-system.md

@@ -3,17 +3,17 @@ You are the akm consolidate assistant analyzing memory assets.
 Rules:
 1. MERGE: Two or more memories are substantially duplicated or closely related → propose merging. Return the primary ref to keep and secondary refs to delete. Do NOT include mergedContent — the merge will be executed in a separate step.
 2. DELETE: Memory is clearly outdated, contradicted, or redundant → propose deletion. NEVER propose delete for memories annotated `(captureMode: hot)` — they are user-explicit and only the user can retire them. The downstream guard will refuse these regardless, so proposing them just wastes tokens.
-3. PROMOTE: Memory expresses a stable, reusable fact suitable as a `knowledge:` asset → propose promotion. Do NOT delete the source memory. NEVER propose promote / merge / contradict for memories annotated `(already queued)` — they have a pending proposal whose body matches; a duplicate will be deterministically dropped, so proposing them just wastes tokens.
+3. PROMOTE: Memory expresses a stable, reusable fact suitable as a `knowledge/` asset → propose promotion. Do NOT delete the source memory. NEVER propose promote / merge / contradict for memories annotated `(already queued)` — they have a pending proposal whose body matches; a duplicate will be deterministically dropped, so proposing them just wastes tokens.
 4. CONTRADICT: Two memories assert logically exclusive facts such that following BOTH simultaneously is impossible — not merely related or overlapping. You MUST cite the exact sentence from Memory A and the exact sentence from Memory B that are in direct conflict. If you cannot cite specific opposing sentences, use KEEP instead. Sharing a topic, tool, domain, or workflow stage is NOT sufficient. Only direct factual opposites qualify: opposing recommended commands, opposing boolean flags, opposing version numbers, or mutually exclusive instructions. Use confidence ≥ 0.92 only; omit the op entirely if below that threshold.
 5. KEEP: Memory is unique and current → omit from output.
 
 Return ONLY JSON (no prose, no code fences):
 {
   "operations": [
-    { "op": "merge", "primary": "memory:<name>", "secondaries": ["memory:<name>", ...], "mergeStrategy": "synthesize", "confidence": 0.95 },
-    { "op": "delete", "ref": "memory:<name>", "reason": "<brief reason>", "confidence": 0.90 },
-    { "op": "promote", "ref": "memory:<name>", "knowledgeRef": "knowledge:<suggested-slug>", "reason": "<brief reason>", "description": "<one sentence describing the new knowledge asset>", "confidence": 0.92 },
-    { "op": "contradict", "ref": "memory:<name>", "contradictedByRef": "memory:<name>", "reason": "<brief reason>", "confidence": 0.88 }
+    { "op": "merge", "primary": "memories/<name>", "secondaries": ["memories/<name>", ...], "mergeStrategy": "synthesize", "confidence": 0.95 },
+    { "op": "delete", "ref": "memories/<name>", "reason": "<brief reason>", "confidence": 0.90 },
+    { "op": "promote", "ref": "memories/<name>", "knowledgeRef": "knowledge/<suggested-slug>", "reason": "<brief reason>", "description": "<one sentence describing the new knowledge asset>", "confidence": 0.92 },
+    { "op": "contradict", "ref": "memories/<name>", "contradictedByRef": "memories/<name>", "reason": "<brief reason>", "confidence": 0.88 }
   ],
   "warnings": ["<optional concerns>"]
 }

package/dist/assets/prompts/extract-session.md

@@ -46,22 +46,18 @@ Respond with EXACTLY one JSON object matching this shape:
   "candidates": [
     {
       "type": "memory" | "lesson" | "knowledge",
-      "name": "<kebab-case-slug>",
+      "name": "<kebab-case name, e.g. jwt-token; optionally under one kebab-case scope, e.g. auth/jwt-token>",
       "description": "<one sentence 20-400 chars>",
       "when_to_use": "<one sentence 15-400 chars; REQUIRED only when type=lesson>",
       "body": "<markdown body, 200-3000 chars typical>",
       "confidence": <number 0.0-1.0>,
-      "evidence": "<one-line pointer to the moment in the session>",
-      "orderedActions": ["<action-1>", "<action-2>", ...],
-      "outcomeData": "<one sentence describing the outcome of the action sequence>"
+      "evidence": "<one-line pointer to the moment in the session>"
     }
   ],
   "rationale_if_empty": "<one sentence; REQUIRED when candidates is empty>"
 }
 ```
 
-`orderedActions` and `outcomeData` are **optional**. Include them only when the candidate represents a recurring action sequence (e.g. a recovery procedure, a build-fix recipe, a deployment checklist) where preserving the ordered steps adds future value. When present, `outcomeData` is required and must describe what happened when the sequence completed (success or failure). Omit both fields entirely for standalone facts, observations, or lessons that are not action-sequence-shaped.
-
 ## Rules
 
 1. **Zero candidates is a valid and frequent answer.** Most sessions yield no new durable insight. When that's the case, return `{"candidates": [], "rationale_if_empty": "..."}` explaining what you saw and why it didn't rise to durable-knowledge level. Do not fabricate.

package/dist/assets/prompts/reflect-llm-framed-contract.md

@@ -0,0 +1,11 @@
+Respond with exactly this plain-text frame, with no prose or code fence around it:
+
+{{REF_LINE}}AKM_REFLECT_CONFIDENCE: <number from 0 to 1>
+AKM_REFLECT_FRONTMATTER_PATCH: {"description": null, "when_to_use": null}
+AKM_REFLECT_CONTENT_BEGIN
+<complete improved markdown body>
+AKM_REFLECT_CONTENT_END
+
+The first begin marker and final end marker delimit the body; marker lines between them are literal content. Put the complete markdown body between those outer markers. Quotes, Markdown fences, and backslashes inside the body are literal content; do not JSON-escape them. Emit the body only, without YAML frontmatter, because AKM preserves and merges the source frontmatter itself.
+
+The frontmatter patch must be a one-line JSON object with exactly `description` and `when_to_use`. Keep a field `null` when it should not change. Supply a non-empty string only when adding or correcting that field; AKM merges those values through its existing sanitizer.

package/dist/assets/prompts/reflect-llm-schema-contract.md

@@ -0,0 +1,3 @@
+Respond only through the provider's native JSON schema. {{FIELD_RULE}}
+
+`content` must contain the complete improved markdown body only, without YAML frontmatter. `frontmatterPatch` must contain exactly `description` and `when_to_use`; set either field to `null` when it should not change, or to a non-empty string when adding or correcting it. AKM merges that narrow patch with the source frontmatter and preserves target identity itself. `confidence` is your honest self-rated quality confidence from 0 to 1. Do not add prose or Markdown fences around the JSON response.

package/dist/assets/prompts/reflect-output-repair.md

@@ -0,0 +1,3 @@
+Your previous response could not be extracted using the required output contract. Reformat that response exactly once using the contract below. Preserve its proposed markdown verbatim: do not revise, summarize, or add content. Return only the repaired envelope.
+
+{{OUTPUT_CONTRACT}}

package/dist/assets/stash-skeleton/README.md

@@ -18,7 +18,6 @@ consistency and reducing repeated context-setting.
 | `tasks/` | Tasks | Scheduled or on-demand automation tasks |
 | `lessons/` | Lessons | Durable lessons extracted from past sessions |
 | `facts/` | Facts | Durable stash-level context; the house conventions in `facts/conventions/` are auto-surfaced to authoring agents |
-| `wikis/` | Wikis | Agent-maintained knowledge bases (see `akm wiki`) |
 | `scripts/` | Scripts | Executable helpers agents and humans can run |
 | `env/`, `secrets/` | Env & Secrets | Configuration groups and single credentials; values are never content-indexed |
 
@@ -28,22 +27,22 @@ on the next `akm index` run (or when the background improve pipeline picks them
 ## How to organize assets
 
 A file's path under its type directory becomes part of its ref
-(`knowledge/auth/oauth-refresh-races.md` → `knowledge:auth/oauth-refresh-races`),
+(`knowledge/auth/oauth-refresh-races.md` → `knowledge/auth/oauth-refresh-races`),
 and its segments are search terms: `akm search "auth" --type knowledge` narrows
 to that subtree. Retrieval is search, not folder-browse, so pick subdirectories
 deliberately. The house rules live in three convention facts under
 `facts/conventions/` and are surfaced to agents automatically when they author
 assets:
 
-- **`fact:conventions/organization`** — the single path axis, chosen by asset
+- **`facts/conventions/organization`** — the single path axis, chosen by asset
   type. **Scope-born** types (`memory`, `lesson`, `task`, `env`, `secret`) go
   under the current **project/client** slug; **reuse-born** types (`knowledge`,
-  `skill`, `wiki`, `fact`, `script`) go under a stable **domain**; global types
+  `skill`, `fact`, `script`) go under a stable **domain**; global types
   stay at the type root.
-- **`fact:conventions/backlinks`** — how to cross-link: a provenance xref
+- **`facts/conventions/backlinks`** — how to cross-link: a provenance xref
   whenever an asset derives from another, sparse real associative links,
   corrections as new assets, canonical entity naming.
-- **`fact:conventions/domains`** — the (editable) domain vocabulary for
+- **`facts/conventions/domains`** — the (editable) domain vocabulary for
   reuse-born assets, plus canonical entity spellings.
 
 Per-type nuances live in `facts/conventions/assets/<type>.md`. All of these are
@@ -63,11 +62,11 @@ akm search "<query>"
 akm search "<query>" --type skill
 akm search "<query>" --type knowledge
 
-# Show a specific asset by ref
-akm show skill:<name>
-akm show knowledge:<name>
-akm show memory:<name>
-akm show command:<name>
+# Show a specific asset by ref ([bundle//]conceptId)
+akm show skills/<name>
+akm show knowledge/<name>
+akm show memories/<name>
+akm show commands/<name>
 
 # List available assets by type
 akm list --type skill

package/dist/assets/stash-skeleton/facts/conventions/assets/agent.md

@@ -40,5 +40,5 @@ Use an agent when a recurring task benefits from a specialized role, bounded res
 ## Placement & linking
 
 - Agent definitions are usually **global**: keep them at the type root or under a
-  role/domain slug (`agent:reviewer`). Point the agent at the standards and type
+  role/domain slug (`agents/reviewer`). Point the agent at the standards and type
   conventions it must read first via xrefs.

package/dist/assets/stash-skeleton/facts/conventions/assets/fact.md

@@ -42,7 +42,7 @@ Use a fact for stable information that future agents should treat as true or nor
 ## Placement & linking
 
 - Facts are **reuse-born**: give a policy/standard fact a domain-like prefix
-  (`fact:policies/pii-handling`) or the type root for personal/meta facts.
+  (`facts/policies/pii-handling`) or the type root for personal/meta facts.
 - Facts are also the **delivery layer** for stash-wide conventions:
   `category: convention` or `category: meta` facts are surfaced to every non-wiki
   author, so this is where naming, placement, and linking house-rules live. Keep

package/dist/assets/stash-skeleton/facts/conventions/assets/knowledge.md

@@ -42,7 +42,7 @@ Use a knowledge asset for durable reference material, synthesized explanations,
 ## Placement & linking
 
 - Knowledge is **reuse-born**: file it under a stable **domain** prefix from
-  `fact:conventions/domains` (`knowledge:auth/oauth-refresh-races`), not under a
+  `facts/conventions/domains` (`knowledge/auth/oauth-refresh-races`), not under a
   project — that domain slug is what any project searches to reuse it.
 - Knowledge pages are the rewritable synthesized layer — update them in place.
   Ingested source material stays immutable; corrections to it are new assets

package/dist/assets/stash-skeleton/facts/conventions/assets/lesson.md

@@ -40,10 +40,10 @@ Use a lesson to record:
 - Update an existing lesson when new feedback sharpens the same judgment.
 - Create a new lesson only when the trigger or failure mode is meaningfully different.
 - Deprecate or revise stale lessons instead of allowing contradictory guidance to accumulate.
-- When a lesson becomes broadly normative, consider promoting the stable rule into a `fact:conventions/...` asset.
+- When a lesson becomes broadly normative, consider promoting the stable rule into a `facts/conventions/...` asset.
 
 ## Placement & linking
 
 - Lessons are **scope-born**: file them under the **project/client** they were
-  learned in (`lesson:projectA/token-refresh-gotcha`) and xref the asset the
+  learned in (`lessons/projectA/token-refresh-gotcha`) and xref the asset the
   lesson corrects or refines.

package/dist/assets/stash-skeleton/facts/conventions/assets/memory.md

@@ -40,8 +40,8 @@ Use a memory when a future agent would make a better decision by knowing a speci
 ## Placement & linking
 
 - Memories are **scope-born**: file them under the **current project/client**
-  slug (`memory:projectA/auth-token-refresh`) — the working context is the
+  slug (`memories/projectA/auth-token-refresh`) — the working context is the
   answer, so no per-asset judgment is needed. Add the subject as a tag
   (`tags: [auth, projectA]`) for cross-cutting recall.
 - When a memory turns out to be domain-general, **append** a new
-  `knowledge:<domain>/…` asset that xrefs it — never rename the memory up a rung.
+  `knowledge/<domain>/…` asset that xrefs it — never rename the memory up a rung.

package/dist/assets/stash-skeleton/facts/conventions/assets/script.md

@@ -45,6 +45,6 @@ Use a script when a task is mechanical, repeatable, and better handled by a dete
 ## Placement & linking
 
 - Scripts are **reuse-born**: file a general helper under a tool/domain slug
-  from `fact:conventions/domains` (`script:build/release`). Use the project slug
+  from `facts/conventions/domains` (`scripts/build/release`). Use the project slug
   only when the script hard-codes project-specific paths, endpoints, or
   credentials.