cclaw-cli 0.7.0 → 0.7.1

package/dist/content/contracts.js

@@ -34,7 +34,7 @@ ${schema.hardGate}
 2. Resolve active artifact root: \`.cclaw/artifacts/\`.
 3. Load required upstream artifacts for this stage:
 ${hydrationLines}
-4. Load \`.cclaw/knowledge.md\` and apply relevant entries.
+4. Stream \`.cclaw/knowledge.jsonl\` and apply relevant JSON-line entries (strict schema: type, trigger, action, confidence, domain, stage, created, project).
 5. Write stage output to ${writeStepPaths}.
 6. Do NOT copy artifacts into \`.cclaw/runs/\`; archival is handled only by \`cclaw archive\`.
 

package/dist/content/hooks.js

@@ -51,7 +51,7 @@ SUGGESTION_MEMORY_FILE="$ROOT/${RUNTIME_ROOT}/state/suggestion-memory.json"
 CONTEXT_WARNINGS_FILE="$ROOT/${RUNTIME_ROOT}/state/context-warnings.jsonl"
 CONTEXT_MODE_FILE="$ROOT/${RUNTIME_ROOT}/state/context-mode.json"
 CONTEXTS_DIR="$ROOT/${RUNTIME_ROOT}/contexts"
-KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.md"
+KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.jsonl"
 META_SKILL="$ROOT/${RUNTIME_ROOT}/skills/${META_SKILL_NAME}/SKILL.md"
 
 # --- Read flow state ---
@@ -309,7 +309,7 @@ if [ -f "$META_SKILL" ]; then
   META_CONTENT=$(cat "$META_SKILL" 2>/dev/null || echo "")
 fi
 
-# --- Load knowledge snapshot (append-only markdown) ---
+# --- Load knowledge snapshot (canonical JSONL tail) ---
 KNOWLEDGE_SUMMARY=""
 if [ -f "$KNOWLEDGE_FILE" ] && [ -s "$KNOWLEDGE_FILE" ]; then
   KNOWLEDGE_SUMMARY=$(tail -n 30 "$KNOWLEDGE_FILE" 2>/dev/null || echo "")
@@ -593,7 +593,7 @@ RUN_SYNC_NOTE="Run metadata sync removed; active artifacts stay in ${RUNTIME_ROO
 
 # --- Escape for JSON ---
 ${ESCAPE_FN}
-MSG=$(escape_json "Cclaw: session ending (stage=$STAGE, run=$ACTIVE_RUN). $CHECKPOINT_NOTE $RUN_SYNC_NOTE Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match current feature intent, (3) if you discovered a non-obvious rule/pattern, append it to ${RUNTIME_ROOT}/knowledge.md, (4) commit or revert pending changes.")
+MSG=$(escape_json "Cclaw: session ending (stage=$STAGE, run=$ACTIVE_RUN). $CHECKPOINT_NOTE $RUN_SYNC_NOTE Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match current feature intent, (3) if you discovered a non-obvious rule/pattern, append one strict-schema JSON line to ${RUNTIME_ROOT}/knowledge.jsonl, (4) commit or revert pending changes.")
 
 # --- Output harness-specific JSON ---
 case "$HARNESS" in
@@ -631,7 +631,7 @@ INPUT=$(cat 2>/dev/null || echo '{}')
 STATE_DIR="$ROOT/${RUNTIME_ROOT}/state"
 STATE_FILE="$STATE_DIR/flow-state.json"
 DELEGATION_FILE="$STATE_DIR/delegation-log.json"
-KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.md"
+KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.jsonl"
 DIGEST_FILE="$STATE_DIR/session-digest.md"
 DIGEST_TMP="$STATE_DIR/session-digest.md.tmp.$$"
 
@@ -786,7 +786,7 @@ export default function cclawPlugin(ctx) {
   const contextModePath = join(stateDir, "context-mode.json");
   const contextsDir = join(runtimeDir, "contexts");
   const sessionDigestPath = join(stateDir, "session-digest.md");
-  const knowledgePath = join(runtimeDir, "knowledge.md");
+  const knowledgePath = join(runtimeDir, "knowledge.jsonl");
   const metaSkillPath = join(runtimeDir, "skills/${META_SKILL_NAME}/SKILL.md");
 
   function ensureRuntimeDirs() {
@@ -923,7 +923,7 @@ export default function cclawPlugin(ctx) {
     if (knowledge.length > 0) parts.push("Knowledge snapshot (latest entries):", ...knowledge);
 
     parts.push(
-      "If you discover a non-obvious rule or pattern, append it to .cclaw/knowledge.md using type: rule, pattern, or lesson."
+      "If you discover a non-obvious rule or pattern, append one strict-schema JSON line to .cclaw/knowledge.jsonl using type: rule, pattern, lesson, or compound."
     );
 
     const meta = readFileText(metaSkillPath).trim();

package/dist/content/learnings.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Canonical JSONL field order (matches the reference spec).
+ * Exported for tests and any programmatic writer that wants the exact shape.
+ */
+export declare const KNOWLEDGE_JSONL_FIELDS: readonly ["type", "trigger", "action", "confidence", "domain", "stage", "created", "project"];
 export declare function learnSkillMarkdown(): string;
 export declare function learnCommandContract(): string;
 export declare function selfImprovementBlock(stageName: string): string;

package/dist/content/learnings.js

@@ -1,10 +1,28 @@
 // ---------------------------------------------------------------------------
 // Knowledge store content for /cc-learn and stage self-improvement prompts.
+//
+// The knowledge store is a single canonical JSONL file. Each line is one
+// self-contained JSON object matching the strict schema in this module.
+// There is no markdown mirror — cclaw is JSONL-native.
 // ---------------------------------------------------------------------------
-const KNOWLEDGE_PATH = ".cclaw/knowledge.md";
-const KNOWLEDGE_JSONL_PATH = ".cclaw/knowledge.jsonl";
+const KNOWLEDGE_PATH = ".cclaw/knowledge.jsonl";
+const KNOWLEDGE_ARCHIVE_PATH = ".cclaw/knowledge.archive.jsonl";
 const LEARN_SKILL_NAME = "learnings";
-const LEARN_SKILL_DESCRIPTION = "Project-scoped knowledge store: review and append rule/pattern/lesson/compound entries. Maintains a human-readable markdown mirror at .cclaw/knowledge.md and a canonical JSONL store at .cclaw/knowledge.jsonl.";
+const LEARN_SKILL_DESCRIPTION = "Project-scoped knowledge store: append and query rule/pattern/lesson/compound entries in the canonical JSONL file at .cclaw/knowledge.jsonl. Strict schema, append-only, machine-queryable.";
+/**
+ * Canonical JSONL field order (matches the reference spec).
+ * Exported for tests and any programmatic writer that wants the exact shape.
+ */
+export const KNOWLEDGE_JSONL_FIELDS = [
+    "type",
+    "trigger",
+    "action",
+    "confidence",
+    "domain",
+    "stage",
+    "created",
+    "project"
+];
 export function learnSkillMarkdown() {
     return `---
 name: ${LEARN_SKILL_NAME}
@@ -15,113 +33,81 @@ description: "${LEARN_SKILL_DESCRIPTION}"
 
 ## Overview
 
-This skill manages the project knowledge store. The store has **two mirrored formats**:
-
-- \`${KNOWLEDGE_PATH}\` — human-readable, append-only markdown (the reading view).
-- \`${KNOWLEDGE_JSONL_PATH}\` — canonical, machine-queryable JSONL (one JSON object per line). Used by the curator, /cc-status, and future analytics.
-
-Every \`/cc-learn add\` appends to **both** files. \`/cc-learn search\` prefers the JSONL store if it exists; otherwise it falls back to the markdown file.
+The project knowledge store is **one canonical JSONL file**: \`${KNOWLEDGE_PATH}\`.
+Each line is one self-contained JSON object. Append-only. Machine-queryable.
 
 Use the store to keep durable knowledge that should survive sessions:
-- **rule**: hard constraint to follow every time
-- **pattern**: repeatable way that works well in this project
-- **lesson**: non-obvious outcome from a failure or trade-off
-- **compound**: post-ship insight about how to make the *next* feature faster (process accelerator, not domain rule)
+- **rule**: hard constraint to follow every time.
+- **pattern**: repeatable way that works well in this project.
+- **lesson**: non-obvious outcome from a failure or trade-off.
+- **compound**: post-ship insight about how to make the *next* feature faster (process accelerator, not domain rule).
 
 ## HARD-GATE
 
-Under \`/cc-learn\`, only modify the knowledge store files (\`${KNOWLEDGE_PATH}\` and \`${KNOWLEDGE_JSONL_PATH}\`) or an explicitly user-approved summary file. Do not modify application code here.
-
-## Entry format — markdown mirror (append-only)
+Under \`/cc-learn\`, only modify \`${KNOWLEDGE_PATH}\`, \`${KNOWLEDGE_ARCHIVE_PATH}\`,
+or an explicitly user-approved summary file. Do not modify application code here.
+Do not invent alternate stores (no markdown mirror, no SQLite, no per-stage files).
 
-\`\`\`markdown
-### 2026-04-14T12:00:00Z [pattern] short-title
-- Stage: design
-- Context: one short line
-- Insight: one short line
-- Reuse: one short line
-- Confidence: high | medium | low      (optional)
-- Domain: api | infra | ui | testing | …  (optional)
-- Project: <repo or scope name>        (optional)
-\`\`\`
+## Entry format — strict JSONL schema
 
-## Entry format — canonical JSONL (one entry per line)
+Exactly one JSON object per line. Fields must appear in the order:
+\`type, trigger, action, confidence, domain, stage, created, project\`.
 
 \`\`\`json
-{"type":"pattern","title":"short-title","stage":"design","context":"one short line","insight":"one short line","reuse":"one short line","created":"2026-04-14T12:00:00Z","confidence":"high","domain":"api","project":"cclaw","supersedes":null,"superseded":false,"archived":false}
+{"type":"pattern","trigger":"when reviewing external payloads","action":"parse through zod before touching service layer","confidence":"high","domain":"api","stage":"review","created":"2026-04-14T12:00:00Z","project":"cclaw"}
 \`\`\`
 
-Schema:
-
 | field | type | required | notes |
 |---|---|---|---|
 | \`type\` | \`"rule" \\| "pattern" \\| "lesson" \\| "compound"\` | yes | Lowercase. |
-| \`title\` | string | yes | Short title, used as a human-readable identifier. |
-| \`stage\` | \`FlowStage\` | yes | One of brainstorm / scope / design / spec / plan / tdd / review / ship. |
-| \`context\` | string | yes | What situation triggered this. |
-| \`insight\` | string | yes | What must be remembered. |
-| \`reuse\` | string | yes | How to apply this next time — concrete trigger/action. |
-| \`created\` | ISO 8601 UTC string | yes | When the entry was written. |
-| \`confidence\` | \`"high" \\| "medium" \\| "low"\` | optional | Default \`medium\` if omitted. |
-| \`domain\` | string | optional | Free-form taxonomy (\`api\`, \`infra\`, \`ui\`, …). |
-| \`project\` | string | optional | Repo or scope name when the entry crosses features. |
-| \`supersedes\` | string \\| null | optional | Title of the entry this one replaces. |
-| \`superseded\` | boolean | optional | \`true\` when a newer entry replaces this one. |
-| \`archived\` | boolean | optional | \`true\` once the curator soft-archives the entry. |
+| \`trigger\` | string | yes | The concrete situation that must be recognized. Start with a verb or \`when …\`. |
+| \`action\` | string | yes | The concrete move to take when the trigger fires. One sentence. |
+| \`confidence\` | \`"high" \\| "medium" \\| "low"\` | yes | Write \`medium\` when unsure; do not omit. |
+| \`domain\` | string \\| null | yes | Free-form taxonomy (\`api\`, \`infra\`, \`ui\`, \`security\`, \`testing\`, …). Use \`null\` when cross-cutting. |
+| \`stage\` | \`FlowStage\` \\| null | yes | One of brainstorm / scope / design / spec / plan / tdd / review / ship, or \`null\` when cross-stage. |
+| \`created\` | ISO 8601 UTC string | yes | \`date -u +%Y-%m-%dT%H:%M:%SZ\`. |
+| \`project\` | string \\| null | yes | Repo or scope name. Use \`null\` when the entry crosses projects. |
 
 Rules:
-- Type must be exactly one of \`rule\`, \`pattern\`, \`lesson\`, \`compound\` (lowercase).
-- Never rewrite history silently; append a newer correction entry instead. To replace, set \`supersedes\` to the old title in the new JSONL entry and in the new markdown entry prefix with \`Supersedes: <old-title>\`. Flip \`superseded: true\` on the old JSONL entry via a new JSONL line (the file is append-only; use a \`replace\` line by convention — see Curation policy).
-- Keep entries concise and actionable.
-- Optional fields (\`Confidence\`, \`Domain\`, \`Project\`) are forward-compatible and used by the **knowledge-curation** skill — fill them when known.
-
-## Backward-compat migration (markdown → JSONL)
-
-Run \`/cc-learn migrate\` once per repo when \`${KNOWLEDGE_JSONL_PATH}\` is missing:
-
-1. Parse \`${KNOWLEDGE_PATH}\`. Each entry starts with \`### <ISO8601> [<type>] <title>\` and is followed by \`- <Field>: <value>\` lines until the next \`###\` or EOF.
-2. Map fields to JSONL schema:
-   - Heading timestamp → \`created\`; heading \`[type]\` → \`type\`; heading title → \`title\`.
-   - Bullet \`Stage:\`, \`Context:\`, \`Insight:\`, \`Reuse:\`, \`Confidence:\`, \`Domain:\`, \`Project:\` → matching fields.
-   - A \`Supersedes:\` prefix line becomes \`"supersedes": "<old-title>"\`.
-3. Emit one JSON object per line to \`${KNOWLEDGE_JSONL_PATH}\` preserving the original order. Set defaults: \`confidence = "medium"\`, \`superseded = false\`, \`archived = false\`, missing optional fields = \`null\`.
-4. Do **not** rewrite \`${KNOWLEDGE_PATH}\`. The markdown stays as the human-readable mirror; new additions continue to write both files.
-5. After migration, \`/cc-learn search\` reads the JSONL store first; if absent, it continues to parse the markdown file (so users who never migrate still work).
+- No other fields. Extra keys are forbidden and MUST be rejected by any writer.
+- Every required-null field must be emitted explicitly as \`null\` (not omitted). This keeps the file grep-friendly.
+- Append-only: never rewrite or delete a historical line. Corrections are new
+  entries whose \`trigger\` clearly supersedes the earlier one.
+- Keep each entry one line. No pretty-printing. No trailing commas.
 
 ## Curation policy (target: ≤ 50 active entries)
 
-The knowledge file is append-only, but entries can be **superseded** rather than deleted:
-
-- When you discover a more correct rule, append a new entry with \`Supersedes: <old-title>\`.
-- During \`/cc-learn curate\`, the assistant surfaces candidates for soft-archive (move to \`.cclaw/knowledge.archive.md\`) when the active file exceeds 50 entries or contains stale/duplicate entries.
-
-See the **knowledge-curation** utility skill for the full curation protocol.
+- The file is append-only — entries are never physically deleted.
+- When the canonical file exceeds 50 lines, \`/cc-learn curate\` proposes
+  soft-archiving: the approved lines are **moved** to \`${KNOWLEDGE_ARCHIVE_PATH}\`
+  verbatim (same JSONL shape). The working file stays lean.
+- See the **knowledge-curation** utility skill for the full curation protocol.
 
 ## Subcommands
 
 ### \`/cc-learn\` (default)
-- Show the last 30 lines from \`${KNOWLEDGE_PATH}\`.
-- If file is missing or empty, report that clearly.
+- Read \`${KNOWLEDGE_PATH}\`. Stream the last 30 lines; pretty-print each
+  line's \`type\` / \`trigger\` / \`action\` for human review.
+- If file is missing or empty, report that clearly and suggest \`/cc-learn add\`.
 
 ### \`/cc-learn search <query>\`
-- If \`${KNOWLEDGE_JSONL_PATH}\` exists: stream it, JSON.parse each line, filter where any of \`title\`, \`context\`, \`insight\`, \`reuse\`, \`domain\` contains \`<query>\` (case-insensitive). Skip \`archived: true\` unless \`--include-archived\` is passed.
-- Otherwise: case-insensitive text search in \`${KNOWLEDGE_PATH}\`.
-- Return matched headings and nearby lines.
+- Stream \`${KNOWLEDGE_PATH}\`, JSON.parse each line, filter where any of
+  \`trigger\`, \`action\`, \`domain\`, \`project\` contains \`<query>\` (case-insensitive).
+- Return the matched lines pretty-printed (do not mutate the file).
 
 ### \`/cc-learn add\`
-- Ask for: \`type\`, \`short title\`, \`context\`, \`insight\`, \`reuse\`.
-- Optionally ask for: \`confidence\`, \`domain\`, \`project\`, \`supersedes\`.
-- Append one markdown entry to \`${KNOWLEDGE_PATH}\` (human mirror).
-- Append one JSON line to \`${KNOWLEDGE_JSONL_PATH}\` (canonical store) using the same UTC timestamp as the markdown entry's heading.
-- Re-read both tails to confirm both writes.
-
-### \`/cc-learn migrate\`
-- Parse \`${KNOWLEDGE_PATH}\` and emit \`${KNOWLEDGE_JSONL_PATH}\` per the Backward-compat migration protocol above.
-- Safe to re-run: if JSONL already exists, report the current entry count and exit (no destructive rewrite).
+- Ask for required fields in order: \`type\`, \`trigger\`, \`action\`, \`confidence\`, \`domain\`, \`stage\`, \`project\`.
+- \`confidence\` must be one of \`high\`, \`medium\`, \`low\`. Default to \`medium\` if the user declines to set it.
+- \`domain\`, \`stage\`, and \`project\` may be explicitly \`null\`.
+- \`created\` is set automatically to the current UTC ISO timestamp.
+- Append exactly one JSON line to \`${KNOWLEDGE_PATH}\` with the field order from the schema table above.
+- Re-read the file tail to confirm the new line is valid JSON and parses back to the same object.
 
 ### \`/cc-learn curate\`
 - Hand off to the **knowledge-curation** skill (read-only audit + soft-archive plan).
-- Never deletes from \`${KNOWLEDGE_PATH}\` or \`${KNOWLEDGE_JSONL_PATH}\` without an explicit user-approved archive plan. Soft-archive in JSONL means appending a new line with the same \`title\` and \`archived: true\` (entries are never physically removed).
+- Never deletes. Soft-archive means **moving** full JSON lines from
+  \`${KNOWLEDGE_PATH}\` to \`${KNOWLEDGE_ARCHIVE_PATH}\` as part of a
+  user-approved curation pass.
 `;
 }
 export function learnCommandContract() {
@@ -129,23 +115,23 @@ export function learnCommandContract() {
 
 ## Purpose
 
-Manage the project knowledge store. Two mirrored formats:
-- \`${KNOWLEDGE_PATH}\` — human-readable markdown (append-only, tail view).
-- \`${KNOWLEDGE_JSONL_PATH}\` — canonical JSONL (one entry per line) used by the curator and machine consumers.
+Manage the project knowledge store. One canonical file, strict JSONL:
+- \`${KNOWLEDGE_PATH}\` — append-only JSONL, one entry per line.
+- \`${KNOWLEDGE_ARCHIVE_PATH}\` — soft-archive target written only by curate.
 
 ## HARD-GATE
 
-Do not edit source code from this command. Only operate on \`${KNOWLEDGE_PATH}\`, \`${KNOWLEDGE_JSONL_PATH}\`, or user-approved summary output.
+Do not edit source code from this command. Only operate on \`${KNOWLEDGE_PATH}\`,
+\`${KNOWLEDGE_ARCHIVE_PATH}\`, or user-approved summary output.
 
 ## Subcommands
 
 | subcommand | args | description |
 |---|---|---|
-| (default) | — | Show recent knowledge entries (tail view from markdown mirror). |
-| \`search\` | \`<query>\` | Search knowledge for relevant prior rules/patterns/lessons. Prefers JSONL when present. |
-| \`add\` | — | Append a new entry (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) to **both** markdown and JSONL. |
-| \`migrate\` | — | Emit the canonical JSONL mirror from the markdown file (idempotent). |
-| \`curate\` | — | Hand off to the **knowledge-curation** skill: read-only audit + soft-archive plan when the active file exceeds the curation threshold. |
+| (default) | — | Show recent knowledge entries (tail of JSONL, pretty-printed). |
+| \`search\` | \`<query>\` | Stream-filter the JSONL for matching \`trigger\`, \`action\`, \`domain\`, \`project\`. |
+| \`add\` | — | Append one JSON line (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) with the strict 8-field schema. |
+| \`curate\` | — | Hand off to the **knowledge-curation** skill: read-only audit + soft-archive plan when the file exceeds the curation threshold. |
 `;
 }
 export function selfImprovementBlock(stageName) {
@@ -155,36 +141,34 @@ After this stage, ask:
 - Did I discover a non-obvious reusable **rule** or **pattern**?
 - Did a failure reveal a reusable **lesson**?
 
-If yes, append one concise entry to **both** the markdown mirror (\`${KNOWLEDGE_PATH}\`) and the canonical JSONL store (\`${KNOWLEDGE_JSONL_PATH}\`) with the same timestamp:
+If yes, append one concise JSON line to the canonical knowledge store
+(\`${KNOWLEDGE_PATH}\`) using the strict 8-field schema:
 
 \`\`\`bash
 TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-cat >> ${KNOWLEDGE_PATH} <<EOF
-### $TS [pattern] short-title
-- Stage: ${stageName}
-- Context: what situation triggered this
-- Insight: what should be remembered
-- Reuse: how to apply this next time
-EOF
-printf '%s\\n' '{"type":"pattern","title":"short-title","stage":"${stageName}","context":"what situation triggered this","insight":"what should be remembered","reuse":"how to apply this next time","created":"'"$TS"'","confidence":"medium","domain":null,"project":null,"supersedes":null,"superseded":false,"archived":false}' >> ${KNOWLEDGE_JSONL_PATH}
+printf '%s\\n' '{"type":"pattern","trigger":"when <situation>","action":"<concrete move>","confidence":"medium","domain":null,"stage":"${stageName}","created":"'"$TS"'","project":null}' >> ${KNOWLEDGE_PATH}
 \`\`\`
 
 Type must be exactly one of: \`rule\`, \`pattern\`, \`lesson\`, \`compound\`.
+Fields must appear in the order: \`type, trigger, action, confidence, domain, stage, created, project\`.
+Missing optional values must be emitted as \`null\`, never omitted.
 `;
 }
 export function learningsSearchPreamble(stage) {
     return `## Prior Knowledge (load at stage start)
 
-Before stage work, search \`${KNOWLEDGE_PATH}\` for relevant entries (for example: \`${stage}\`, affected systems, key constraints) and apply them explicitly.
-
-If the file is empty, continue normally.
+Before stage work, stream \`${KNOWLEDGE_PATH}\` and filter for entries relevant to
+this stage (\`${stage}\`), affected domains, and key constraints. Apply matching
+entries explicitly. If the file is empty, continue normally.
 `;
 }
 export function learningsAgentsMdBlock() {
     return `### Knowledge Store
 
-\`${KNOWLEDGE_PATH}\` — append-only markdown memory with entry types \`rule\`, \`pattern\`, \`lesson\`, \`compound\`.
-At session start and stage transitions, load recent entries and apply relevant ones.
-If a non-obvious reusable rule/pattern/lesson is discovered, append a new entry.
+\`${KNOWLEDGE_PATH}\` — append-only JSONL memory with entry types \`rule\`, \`pattern\`, \`lesson\`, \`compound\`.
+Strict 8-field schema: \`type, trigger, action, confidence, domain, stage, created, project\`.
+At session start and stage transitions, tail the file and apply relevant entries.
+If a non-obvious reusable rule/pattern/lesson is discovered, append a new line
+through \`/cc-learn add\` (never hand-edit).
 `;
 }

package/dist/content/meta-skill.js

@@ -96,15 +96,22 @@ review lenses can enable opt-in rule packs in \`.cclaw/config.yaml\`:
 
 \`\`\`yaml
 languageRulePacks:
-  - typescript   # → skills/language-typescript/SKILL.md
-  - python       # → skills/language-python/SKILL.md
-  - go           # → skills/language-go/SKILL.md
+  - typescript   # → .cclaw/rules/lang/typescript.md
+  - python       # → .cclaw/rules/lang/python.md
+  - go           # → .cclaw/rules/lang/go.md
 \`\`\`
 
-After editing the list, run \`cclaw sync\` to materialize the enabled pack SKILL.md
-files. Packs activate during \`tdd\` and \`review\` when the diff touches files in
-their language. They are additive lenses — Tier-1 rules block merge, Tier-2 rules
-require a named follow-up. Never silently override them.
+After editing the list, run \`cclaw sync\` to materialize the enabled packs
+under \`.cclaw/rules/lang/\` (one \`<language>.md\` file per pack, each with
+YAML frontmatter declaring \`stages\` and \`triggers\`). Packs activate during
+\`tdd\` and \`review\` when the diff touches files in their language. They are
+additive lenses — Tier-1 rules block merge, Tier-2 rules require a named
+follow-up. Never silently override them.
+
+\`cclaw sync\` and \`cclaw doctor\` also refuse the legacy v0.7.0 location
+\`.cclaw/skills/language-*/\` — if a project still has those folders,
+\`sync\` removes them on the next run and \`doctor\` surfaces the drift until
+they are gone.
 
 ## Custom Skills (project-owned, sync-safe)
 
@@ -189,10 +196,12 @@ Watch for these anti-patterns:
 
 ## Knowledge Integration
 
-At session start and stage transitions, check \`.cclaw/knowledge.md\` for project-specific knowledge:
-- Review recent entries and apply relevant rules/patterns to the current task
-- If you discover a non-obvious reusable rule or pattern, append a new entry with type \`rule\`, \`pattern\`, or \`lesson\`
+At session start and stage transitions, stream \`.cclaw/knowledge.jsonl\` (the canonical strict-JSONL knowledge store) and apply relevant entries:
+- Each line is one JSON object with fields \`type, trigger, action, confidence, domain, stage, created, project\`.
+- Review recent entries and apply relevant rules/patterns to the current task.
+- If you discover a non-obvious reusable rule or pattern, append one new JSON line via \`/cc-learn add\` with type \`rule\`, \`pattern\`, \`lesson\`, or \`compound\`.
 
-Knowledge capture is append-only and should preserve historical context rather than rewriting prior entries.
+Knowledge capture is append-only and strict-schema. Never rewrite or delete
+historical entries; corrections are new lines whose \`trigger\` supersedes the earlier one.
 `;
 }

package/dist/content/session-hooks.js

@@ -26,7 +26,7 @@ These are prompt-discipline guidelines that complement the real hooks cclaw gene
 When a new session begins in any harness:
 
 1. **Read flow state:** Load \`.cclaw/state/flow-state.json\` to find the current stage and completed stages.
-2. **Load knowledge:** Review recent entries from \`.cclaw/knowledge.md\` and surface the most relevant rules/patterns.
+2. **Load knowledge:** Stream the tail of \`.cclaw/knowledge.jsonl\` (strict JSONL store) and surface the most relevant rules/patterns.
 3. **Check for in-progress work:** If the last stage is incomplete, remind the user and offer to resume.
 4. **Load suggestion memory:** Read \`.cclaw/state/suggestion-memory.json\` and honor \`enabled=false\` opt-out.
 5. **Read AGENTS.md:** The cclaw block contains routing and rules — follow them.
@@ -45,7 +45,7 @@ Before ending a session or when context is full:
 
 1. **Verify no pending changes:** All modified files must be either committed or explicitly reverted.
 2. **Update flow state:** Mark the current stage as its actual status (DONE / DONE_WITH_CONCERNS / BLOCKED).
-3. **Write knowledge:** If any non-obvious reusable insight appears, append to \`.cclaw/knowledge.md\` with type \`rule\`, \`pattern\`, or \`lesson\`.
+3. **Write knowledge:** If any non-obvious reusable insight appears, append one strict-schema JSON line to \`.cclaw/knowledge.jsonl\` with type \`rule\`, \`pattern\`, \`lesson\`, or \`compound\`.
 4. **Create checkpoint:** Write a brief status note to the current artifact or as a comment in flow-state.json.
 
 ### Stop conditions (agent must halt and report)

package/dist/content/skills.js

@@ -81,7 +81,7 @@ Before starting stage execution:
 2. Resolve active artifact root: \`.cclaw/artifacts/\`.
 3. Load upstream artifacts required by this stage:
 ${readLines}
-4. Read \`.cclaw/knowledge.md\` and apply relevant entries before making decisions.
+4. Stream \`.cclaw/knowledge.jsonl\` (strict-JSONL knowledge store) and apply relevant entries before making decisions.
 `;
 }
 function whenNotToUseBlock(stage) {
@@ -236,7 +236,7 @@ function progressiveDisclosureBlock(stage) {
 - Primary stage procedure (this file): \`.cclaw/skills/${schema.skillFolder}/SKILL.md\`
 - Orchestrator contract (gate language and handoff): \`.cclaw/commands/${stage}.md\`
 - Artifact structure baseline: \`.cclaw/templates/${schema.artifactFile}\`
-- Runtime state truth source: \`.cclaw/state/flow-state.json\` + \`.cclaw/artifacts/\` + \`.cclaw/knowledge.md\`
+- Runtime state truth source: \`.cclaw/state/flow-state.json\` + \`.cclaw/artifacts/\` + \`.cclaw/knowledge.jsonl\`
 
 ### See also
 - Meta routing and activation rules: \`.cclaw/skills/using-cclaw/SKILL.md\`

package/dist/content/stage-schema.js

@@ -1455,7 +1455,7 @@ const SHIP = {
         { section: "Monitoring", required: false, validationRule: "If applicable: what metrics/logs to watch post-deploy. Risk note if no monitoring." },
         { section: "Finalization", required: true, validationRule: "Exactly one finalization enum token selected. Execution result documented. Worktree cleaned if applicable." },
         { section: "Completion Status", required: false, validationRule: "If present: exactly one of SHIPPED, SHIPPED_WITH_EXCEPTIONS, BLOCKED. Exceptions documented when applicable." },
-        { section: "Compound Step", required: false, validationRule: "Optional retrospective: at least one bullet of the form 'Insight: ... | Action: append [compound] entry to .cclaw/knowledge.md', or an explicit 'No compound insight this run.' line." }
+        { section: "Compound Step", required: false, validationRule: "Optional retrospective: at least one bullet of the form 'Insight: ... | Action: append [compound] entry to .cclaw/knowledge.jsonl', or an explicit 'No compound insight this run.' line." }
     ],
     namedAntiPattern: {
         title: "Green CI Means Safe to Merge",

package/dist/content/status-command.js

@@ -8,7 +8,7 @@ function delegationLogPath() {
     return `${RUNTIME_ROOT}/state/delegation-log.json`;
 }
 function knowledgePath() {
-    return `${RUNTIME_ROOT}/knowledge.md`;
+    return `${RUNTIME_ROOT}/knowledge.jsonl`;
 }
 function contextModePath() {
     return `${RUNTIME_ROOT}/state/context-mode.json`;
@@ -131,7 +131,7 @@ a read-only command.
    - Prefer \`${checkpointPath()}\` when \`stage === currentStage\` and \`timestamp\` parses as ISO 8601.
    - Else scan \`${stageActivityPath()}\` from tail for the most recent entry whose \`stage === currentStage\`; use its \`ts\`.
    - Render \`<X>d<Y>h\`, \`<X>h<Y>m\`, \`<X>m\`, or \`(unknown)\`.
-5. Read \`${RUNTIME_ROOT}/knowledge.md\`. If missing or empty → knowledge highlights are \`(none recorded)\`.
+5. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
 6. For each gate in \`stageGateCatalog[currentStage].required\`:
    - Satisfied if present in \`passed\` and absent from \`blocked\`.
 7. Build and print the status block (see command contract for layout).

package/dist/content/templates.js

@@ -446,7 +446,7 @@ Execution rule: complete and verify each wave before starting the next wave.
 _Optional retrospective. The goal is to make the **next** feature faster, not to evaluate this one._
 _If you have nothing to add, write the explicit line: \`No compound insight this run.\`_
 - Insight: <one short line about what should accelerate the next run>
-- Action: append \`[compound]\` entry to \`.cclaw/knowledge.md\` capturing the insight
+- Action: append one strict-schema JSON line with \`"type":"compound"\` to \`.cclaw/knowledge.jsonl\` capturing the insight (fields: type, trigger, action, confidence, domain, stage, created, project)
 `
 };
 export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook

package/dist/content/utility-skills.d.ts

@@ -20,11 +20,28 @@ export declare function retrospectiveSkill(): string;
 export declare function languageTypescriptSkill(): string;
 export declare function languagePythonSkill(): string;
 export declare function languageGoSkill(): string;
-export declare const LANGUAGE_RULE_PACK_FOLDERS: {
-    readonly typescript: "language-typescript";
-    readonly python: "language-python";
-    readonly go: "language-go";
+/**
+ * Language rule packs live under `.cclaw/rules/lang/<pack>.md`. They are NOT
+ * skills (no folder, no `SKILL.md`) — they are opt-in **rule files** that the
+ * meta-skill router and stage hooks consult when the corresponding language
+ * appears in a diff. The pack id doubles as the on-disk filename stem.
+ */
+export declare const LANGUAGE_RULE_PACK_FILES: {
+    readonly typescript: "typescript.md";
+    readonly python: "python.md";
+    readonly go: "go.md";
 };
+/**
+ * Folder (relative to runtime root) that holds every enabled language rule
+ * pack. A single folder keeps discovery trivial for hooks and for `doctor`.
+ */
+export declare const LANGUAGE_RULE_PACK_DIR: readonly ["rules", "lang"];
 export declare const LANGUAGE_RULE_PACK_GENERATORS: Record<string, () => string>;
+/**
+ * Legacy per-language folders under `.cclaw/skills/` used in v0.7.0. Listed
+ * here so `cclaw sync` and `doctor` can surface drift and the installer can
+ * clean them up after the move to `.cclaw/rules/lang/`.
+ */
+export declare const LEGACY_LANGUAGE_RULE_PACK_FOLDERS: readonly ["language-typescript", "language-python", "language-go"];
 export declare const UTILITY_SKILL_FOLDERS: readonly ["security", "debugging", "performance", "ci-cd", "docs", "executing-plans", "context-engineering", "source-driven-development", "frontend-accessibility", "landscape-check", "adversarial-review", "security-audit", "knowledge-curation", "retrospective"];
 export declare const UTILITY_SKILL_MAP: Record<string, () => string>;

package/dist/content/utility-skills.js

@@ -751,22 +751,22 @@ candidates exist).
 export function knowledgeCurationSkill() {
     return `---
 name: knowledge-curation
-description: "Read-only curation pass over .cclaw/knowledge.md and .cclaw/knowledge.jsonl. Surfaces stale, duplicate, or low-confidence entries and proposes a soft-archive plan; never deletes without explicit user approval."
+description: "Read-only curation pass over the canonical strict-JSONL knowledge store at .cclaw/knowledge.jsonl. Surfaces stale, duplicate, or low-confidence entries and proposes a soft-archive plan that moves approved lines to .cclaw/knowledge.archive.jsonl. Never deletes without explicit user approval."
 ---
 
 # Knowledge Curation
 
 ## Quick Start
 
-> 1. This is a **read-only audit** of \`.cclaw/knowledge.md\` and, when present, \`.cclaw/knowledge.jsonl\`. Never delete or rewrite entries here.
+> 1. This is a **read-only audit** of \`.cclaw/knowledge.jsonl\`. Never delete or rewrite entries here.
 > 2. Surface candidates for soft-archive when the active file > 50 entries OR contains stale/duplicate/superseded entries.
 > 3. Propose a single archive plan and require explicit user approval before any move.
 
 ## HARD-GATE
 
-- Do not modify \`.cclaw/knowledge.md\` or \`.cclaw/knowledge.jsonl\` from this skill except via an explicit user-approved archive plan that **moves** markdown entries to \`.cclaw/knowledge.archive.md\` and appends soft-archive lines (same title, \`archived: true\`) to the JSONL. Never physically removes entries.
-- Do not silently rewrite or summarize entries — preserve original wording.
-- Prefer the JSONL store for queries when present (faster, structured); use the markdown mirror as the human-readable source of truth for final user approval.
+- Do not modify \`.cclaw/knowledge.jsonl\` from this skill except via an explicit user-approved archive plan that **moves** full JSON lines verbatim to \`.cclaw/knowledge.archive.jsonl\`. Never physically delete history that is already archived — the archive file is append-only too.
+- Do not silently rewrite or summarize entries — preserve the original JSON line byte-for-byte.
+- Operate only on the canonical JSONL store. If you see a stray \`.cclaw/knowledge.md\`, report it as a drift signal; do **not** read or rewrite it.
 
 ## When to run
 
@@ -776,28 +776,28 @@ description: "Read-only curation pass over .cclaw/knowledge.md and .cclaw/knowle
 
 ## Audit dimensions
 
-For each entry in \`.cclaw/knowledge.md\` produce a row with:
+For each JSON line in \`.cclaw/knowledge.jsonl\` produce a row with:
 
 | Field | Source |
 |---|---|
-| Title | \`### <ts> [type] <title>\` heading |
-| Type | \`rule\` / \`pattern\` / \`lesson\` / \`compound\` |
-| Stage | \`Stage:\` field (or \`unknown\`) |
-| Age | days since timestamp |
-| Confidence | \`Confidence:\` field if present, else \`unstated\` |
-| Domain | \`Domain:\` field if present |
-| Supersedes | \`Supersedes:\` field if present |
+| # | 1-based line number in the JSONL file |
+| Type | \`type\` field (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) |
+| Stage | \`stage\` field (or \`null\`) |
+| Age | days since \`created\` |
+| Confidence | \`confidence\` field |
+| Domain | \`domain\` field (or \`null\`) |
+| Trigger | \`trigger\` field, truncated to 60 chars |
 | Status hint | one of: keep / supersede-candidate / archive-candidate / duplicate |
 
 ### Status rules
 
-- **supersede-candidate**: another entry has \`Supersedes: <this-title>\`.
-- **duplicate**: title or insight ≈ another entry's (caller's judgment, not regex).
+- **supersede-candidate**: a newer line shares the same \`trigger\` (case-insensitive) and a different \`action\`.
+- **duplicate**: \`trigger\` ≈ another line's AND \`action\` ≈ the same (caller's judgment).
 - **archive-candidate**:
-  - Type \`lesson\` AND age > 180 days AND no \`Supersedes\` chain points to it; OR
-  - Stage = \`brainstorm\` AND age > 90 days; OR
-  - Confidence = \`low\` AND age > 60 days; OR
-  - Total active entries > 50 and entry has lowest reuse signal.
+  - \`type=lesson\` AND age > 180 days AND no newer line references the same \`trigger\`; OR
+  - \`stage=brainstorm\` AND age > 90 days; OR
+  - \`confidence=low\` AND age > 60 days; OR
+  - Total active entries > 50 and entry has the lowest estimated reuse signal.
 - **keep**: everything else.
 
 ## Output format
@@ -807,7 +807,7 @@ Produce two artifacts as **chat output only** (do not write files):
 ### 1. Audit table
 
 \`\`\`markdown
-| # | Title | Type | Stage | Age | Confidence | Status hint |
+| # | Type | Stage | Age | Confidence | Trigger | Status hint |
 |---|---|---|---|---|---|---|
 | 1 | … | … | … | … | … | … |
 \`\`\`
@@ -820,14 +820,15 @@ Produce two artifacts as **chat output only** (do not write files):
 Threshold reasoning: <why entries below were selected>
 
 Entries to archive:
-1. <title> — reason
-2. <title> — reason
+1. line #<N> — <trigger> — reason
+2. line #<N> — <trigger> — reason
 
 Action plan if approved:
-1. Append a header to \`.cclaw/knowledge.archive.md\` with today's UTC date.
-2. Move (cut/paste) selected entries verbatim from \`.cclaw/knowledge.md\` into the archive file.
-3. Append a single supersession line to \`.cclaw/knowledge.md\`:
-   \\\`### <ts> [pattern] knowledge-curation-<date> — archived <N> entries, see knowledge.archive.md\\\`
+1. Ensure \`.cclaw/knowledge.archive.jsonl\` exists (create empty if missing).
+2. Move (cut/paste) the selected JSON lines verbatim from
+   \`.cclaw/knowledge.jsonl\` into \`.cclaw/knowledge.archive.jsonl\`,
+   preserving byte order within each file.
+3. Do not rewrite, re-order, or pretty-print any remaining line in the active file.
 
 After approval: ask the user to run the move themselves, or — if they explicitly grant write access — perform the move atomically and report the new active count.
 \`\`\`
@@ -1079,7 +1080,7 @@ description: "Post-ship retrospective lens. Use after a ship to extract durable
 ## Quick Start
 
 > 1. Run **after** the ship stage closes (PR merged or release tagged), while the run is still loaded in memory.
-> 2. Walk the four lenses below; harvest concrete entries for \`.cclaw/knowledge.md\`.
+> 2. Walk the four lenses below; harvest concrete entries for \`.cclaw/knowledge.jsonl\`.
 > 3. Stop when you have at least one durable entry **or** an explicit "no new lesson this run".
 
 ## HARD-GATE
@@ -1132,13 +1133,14 @@ For each lens, write either a knowledge entry **or** the explicit string
 
 ## Output protocol
 
-For every harvested insight, append one entry to \`.cclaw/knowledge.md\` using
-the standard format (see \`learnings\` skill). Prefer:
+For every harvested insight, append one strict-schema JSON line to
+\`.cclaw/knowledge.jsonl\` (fields: \`type, trigger, action, confidence, domain, stage, created, project\`).
+See the \`learnings\` skill for the canonical shape. Choose \`type\`:
 
-- \`[compound]\` for process/speed accelerators.
-- \`[lesson]\` for "we learned this the hard way".
-- \`[pattern]\` for repeatable shapes that worked.
-- \`[rule]\` only for hard constraints that must always hold.
+- \`compound\` for process/speed accelerators.
+- \`lesson\` for "we learned this the hard way".
+- \`pattern\` for repeatable shapes that worked.
+- \`rule\` only for hard constraints that must always hold.
 
 Then write a one-paragraph **Run Summary** at the top of the next
 \`/cc <idea>\` brainstorm context citing the lessons in scope.
@@ -1347,16 +1349,37 @@ irrelevant. Discarded errors are Go's #1 source of silent data loss.
 \`\`\`
 `;
 }
-export const LANGUAGE_RULE_PACK_FOLDERS = {
-    typescript: "language-typescript",
-    python: "language-python",
-    go: "language-go"
+/**
+ * Language rule packs live under `.cclaw/rules/lang/<pack>.md`. They are NOT
+ * skills (no folder, no `SKILL.md`) — they are opt-in **rule files** that the
+ * meta-skill router and stage hooks consult when the corresponding language
+ * appears in a diff. The pack id doubles as the on-disk filename stem.
+ */
+export const LANGUAGE_RULE_PACK_FILES = {
+    typescript: "typescript.md",
+    python: "python.md",
+    go: "go.md"
 };
+/**
+ * Folder (relative to runtime root) that holds every enabled language rule
+ * pack. A single folder keeps discovery trivial for hooks and for `doctor`.
+ */
+export const LANGUAGE_RULE_PACK_DIR = ["rules", "lang"];
 export const LANGUAGE_RULE_PACK_GENERATORS = {
-    "language-typescript": languageTypescriptSkill,
-    "language-python": languagePythonSkill,
-    "language-go": languageGoSkill
+    typescript: languageTypescriptSkill,
+    python: languagePythonSkill,
+    go: languageGoSkill
 };
+/**
+ * Legacy per-language folders under `.cclaw/skills/` used in v0.7.0. Listed
+ * here so `cclaw sync` and `doctor` can surface drift and the installer can
+ * clean them up after the move to `.cclaw/rules/lang/`.
+ */
+export const LEGACY_LANGUAGE_RULE_PACK_FOLDERS = [
+    "language-typescript",
+    "language-python",
+    "language-go"
+];
 export const UTILITY_SKILL_FOLDERS = [
     "security",
     "debugging",

package/dist/doctor.js

@@ -17,7 +17,7 @@ import { checkMandatoryDelegations } from "./delegation.js";
 import { buildTraceMatrix } from "./trace-matrix.js";
 import { reconcileAndWriteCurrentStageGateCatalog, verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence } from "./gate-evidence.js";
 import { stageSkillFolder } from "./content/skills.js";
-import { LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
+import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS } from "./content/utility-skills.js";
 import { CONTEXT_MODES, DEFAULT_CONTEXT_MODE } from "./content/contexts.js";
 import { validateHookDocument } from "./hook-schema.js";
 const execFileAsync = promisify(execFile);
@@ -409,15 +409,29 @@ export async function doctorChecks(projectRoot, options = {}) {
         });
     }
     // Opt-in language rule packs: only check presence for packs the user enabled.
+    // Canonical location is .cclaw/rules/lang/<pack>.md.
     for (const pack of parsedConfig?.languageRulePacks ?? []) {
-        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
-        if (!folder)
+        const fileName = LANGUAGE_RULE_PACK_FILES[pack];
+        if (!fileName)
             continue;
-        const skillPath = path.join(projectRoot, RUNTIME_ROOT, "skills", folder, "SKILL.md");
+        const packPath = path.join(projectRoot, RUNTIME_ROOT, ...LANGUAGE_RULE_PACK_DIR, fileName);
         checks.push({
             name: `language_rule_pack:${pack}`,
-            ok: await exists(skillPath),
-            details: skillPath
+            ok: await exists(packPath),
+            details: packPath
+        });
+    }
+    // Drift: legacy per-language skill folders from v0.7.0 must not coexist with
+    // the new rules/lang/ layout. `cclaw sync` removes them on the next run.
+    for (const legacyFolder of LEGACY_LANGUAGE_RULE_PACK_FOLDERS) {
+        const legacyPath = path.join(projectRoot, RUNTIME_ROOT, "skills", legacyFolder);
+        const legacyPresent = await exists(legacyPath);
+        checks.push({
+            name: `language_rule_pack:no_legacy:${legacyFolder}`,
+            ok: !legacyPresent,
+            details: legacyPresent
+                ? `legacy ${legacyPath} must be removed — language packs moved to ${RUNTIME_ROOT}/${LANGUAGE_RULE_PACK_DIR.join("/")}/. Run \`cclaw sync\`.`
+                : `no legacy ${legacyFolder} skill folder`
         });
     }
     // Agent definition files
@@ -680,11 +694,21 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: true,
         details: hasPython ? "python3 available" : "warning: python3 not found, jq/node paths must stay healthy"
     });
-    // Knowledge store exists
+    // Knowledge store exists (canonical JSONL, no markdown mirror)
     checks.push({
         name: "knowledge:store_exists",
-        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "knowledge.md")),
-        details: `${RUNTIME_ROOT}/knowledge.md must exist`
+        ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl")),
+        details: `${RUNTIME_ROOT}/knowledge.jsonl must exist`
+    });
+    // There must be NO legacy markdown knowledge store — JSONL is the only store.
+    const legacyKnowledgeMdPath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.md");
+    const legacyExists = await exists(legacyKnowledgeMdPath);
+    checks.push({
+        name: "knowledge:no_legacy_markdown",
+        ok: !legacyExists,
+        details: legacyExists
+            ? `legacy ${RUNTIME_ROOT}/knowledge.md must be removed — cclaw is JSONL-native`
+            : `no legacy markdown store present`
     });
     checks.push({
         name: "state:checkpoint_exists",

package/dist/install.js

@@ -17,7 +17,7 @@ import { contextMonitorScript, promptGuardScript, workflowGuardScript } from "./
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
 import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
-import { LANGUAGE_RULE_PACK_FOLDERS, LANGUAGE_RULE_PACK_GENERATORS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
+import { LANGUAGE_RULE_PACK_DIR, LANGUAGE_RULE_PACK_FILES, LANGUAGE_RULE_PACK_GENERATORS, LEGACY_LANGUAGE_RULE_PACK_FOLDERS, UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
@@ -183,13 +183,23 @@ async function writeSkills(projectRoot, config) {
         const generator = UTILITY_SKILL_MAP[folder];
         await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
     }
+    // Language rule packs live under .cclaw/rules/lang/<pack>.md. They are opt-in:
+    // only the packs listed in config.languageRulePacks are materialised. Any
+    // legacy per-language skill folders from v0.7.0 (.cclaw/skills/language-*)
+    // are cleaned up below so the new rules/lang layout is the only truth.
     const enabledPacks = config?.languageRulePacks ?? [];
     for (const pack of enabledPacks) {
-        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
-        const generator = LANGUAGE_RULE_PACK_GENERATORS[folder];
-        if (!folder || !generator)
+        const fileName = LANGUAGE_RULE_PACK_FILES[pack];
+        const generator = LANGUAGE_RULE_PACK_GENERATORS[pack];
+        if (!fileName || !generator)
             continue;
-        await writeFileSafe(runtimePath(projectRoot, "skills", folder, "SKILL.md"), generator());
+        await writeFileSafe(runtimePath(projectRoot, ...LANGUAGE_RULE_PACK_DIR, fileName), generator());
+    }
+    for (const legacyFolder of LEGACY_LANGUAGE_RULE_PACK_FOLDERS) {
+        const legacyPath = runtimePath(projectRoot, "skills", legacyFolder);
+        if (await exists(legacyPath)) {
+            await fs.rm(legacyPath, { recursive: true, force: true });
+        }
     }
 }
 async function writeUtilityCommands(projectRoot) {
@@ -550,9 +560,13 @@ async function writeHooks(projectRoot, config) {
     }
 }
 async function ensureKnowledgeStore(projectRoot) {
-    const storePath = runtimePath(projectRoot, "knowledge.md");
+    const storePath = runtimePath(projectRoot, "knowledge.jsonl");
     if (!(await exists(storePath))) {
-        await writeFileSafe(storePath, "# Project Knowledge\n\n");
+        await writeFileSafe(storePath, "");
+    }
+    const legacyMdPath = runtimePath(projectRoot, "knowledge.md");
+    if (await exists(legacyMdPath)) {
+        await fs.rm(legacyMdPath, { force: true });
     }
 }
 async function ensureCustomSkillsScaffold(projectRoot) {

package/dist/policy.js

@@ -85,8 +85,9 @@ export async function policyChecks(projectRoot, options = {}) {
     // --- utility skill checks ---
     const runtimeFile = (relativePath) => `${RUNTIME_ROOT}/${relativePath}`;
     const utilitySkillChecks = [
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Entry format", name: "utility_skill:learnings:entry_format" },
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_mirror" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "strict JSONL schema", name: "utility_skill:learnings:jsonl_schema" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_store" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, domain, stage, created, project", name: "utility_skill:learnings:field_order" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },

package/dist/runs.d.ts

@@ -56,11 +56,10 @@ export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRu
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
 export declare function archiveRun(projectRoot: string, featureName?: string): Promise<ArchiveRunResult>;
 /**
- * Counts active (non-superseded) knowledge entries.
- * An entry is a markdown H3 heading with the canonical timestamped format produced by
- * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
- * this helper does not currently follow supersession chains beyond raw count, which is
- * deliberate — the curator reads the file directly to make the soft-archive plan.
+ * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
+ * non-empty line that parses as JSON with the required `type` field belonging to the
+ * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
+ * hand-edited file cannot break doctor/archive flows.
  */
 export declare function countActiveKnowledgeEntries(text: string): number;
 export {};

package/dist/runs.js

@@ -407,7 +407,7 @@ export async function archiveRun(projectRoot, featureName) {
 }
 const KNOWLEDGE_SOFT_THRESHOLD = 50;
 async function readKnowledgeStats(projectRoot) {
-    const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.md");
+    const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
     let activeEntryCount = 0;
     if (await exists(knowledgePath)) {
         const text = await fs.readFile(knowledgePath, "utf8");
@@ -417,22 +417,30 @@ async function readKnowledgeStats(projectRoot) {
         activeEntryCount,
         softThreshold: KNOWLEDGE_SOFT_THRESHOLD,
         overThreshold: activeEntryCount > KNOWLEDGE_SOFT_THRESHOLD,
-        knowledgePath: `${RUNTIME_ROOT}/knowledge.md`
+        knowledgePath: `${RUNTIME_ROOT}/knowledge.jsonl`
     };
 }
 /**
- * Counts active (non-superseded) knowledge entries.
- * An entry is a markdown H3 heading with the canonical timestamped format produced by
- * `learn add` / `learn curate`. Entries marked `Supersedes:` themselves are still active;
- * this helper does not currently follow supersession chains beyond raw count, which is
- * deliberate — the curator reads the file directly to make the soft-archive plan.
+ * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
+ * non-empty line that parses as JSON with the required `type` field belonging to the
+ * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
+ * hand-edited file cannot break doctor/archive flows.
  */
 export function countActiveKnowledgeEntries(text) {
-    const lines = text.split(/\r?\n/);
+    const allowed = new Set(["rule", "pattern", "lesson", "compound"]);
     let count = 0;
-    for (const line of lines) {
-        if (/^###\s+\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\s+\[(rule|pattern|lesson|compound)\]/u.test(line)) {
-            count += 1;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (typeof parsed.type === "string" && allowed.has(parsed.type)) {
+                count += 1;
+            }
+        }
+        catch {
+            // Skip malformed lines silently; curation surfaces them separately.
         }
     }
     return count;

package/dist/types.d.ts

@@ -48,10 +48,10 @@ export interface VibyConfig {
     /** Default flow track for new runs (quick = shortened path, standard = full pipeline). */
     defaultTrack?: FlowTrack;
     /**
-     * Opt-in language rule packs. Each enabled pack materializes a matching utility
-     * skill under `.cclaw/skills/language-<id>/SKILL.md` on next `cclaw sync`. The
-     * meta-skill router loads the pack during review/tdd when the diff touches the
-     * language in question.
+     * Opt-in language rule packs. Each enabled pack materializes a matching rule
+     * file under `.cclaw/rules/lang/<id>.md` on the next `cclaw sync`. The
+     * meta-skill router loads the pack during review/tdd when the diff touches
+     * the language in question. Disabled packs have no on-disk footprint.
      */
     languageRulePacks?: LanguageRulePack[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {