cclaw-cli 0.6.0 → 0.7.1

package/dist/content/utility-skills.js

@@ -751,23 +751,22 @@ candidates exist).
 export function knowledgeCurationSkill() {
     return `---
 name: knowledge-curation
-description: "Read-only curation pass over .cclaw/knowledge.md. 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\`. 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\` from this skill except via an explicit
-  user-approved archive plan that **moves** entries to
-  \`.cclaw/knowledge.archive.md\` (never deletes them).
-- Do not silently rewrite or summarize entries — preserve original wording.
+- 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
 
@@ -777,28 +776,28 @@ description: "Read-only curation pass over .cclaw/knowledge.md. Surfaces stale,
 
 ## 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
@@ -808,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 | … | … | … | … | … | … |
 \`\`\`
@@ -821,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.
 \`\`\`
@@ -1069,6 +1069,317 @@ Escalate to the main review-army under the matching severity (Critical / Importa
 - Only playing the hostile-user role and skipping operator + maintainer.
 `;
 }
+export function retrospectiveSkill() {
+    return `---
+name: retrospective
+description: "Post-ship retrospective lens. Use after a ship to extract durable lessons (rules, patterns, accelerators) before context fades. Distinct from the inline ship Compound Step — this is a deeper, optional sweep across the whole run."
+---
+
+# Retrospective
+
+## 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.jsonl\`.
+> 3. Stop when you have at least one durable entry **or** an explicit "no new lesson this run".
+
+## HARD-GATE
+
+Do **not** run retrospective before ship gates pass. The goal is to learn from
+a *closed* loop, not to evaluate work-in-progress.
+Do **not** invent generic platitudes ("write more tests"). Every entry must cite
+a concrete moment in *this* run (file, decision, blocker, surprise).
+
+## When to use
+
+- Right after \`/cc-next\` reports the ship stage complete.
+- Before starting the next \`/cc <idea>\` — fresh context, lessons captured.
+- After an incident or surprise during ship (rollback, hotfix, regression).
+
+## When NOT to use
+
+- Mid-flow (use the per-stage Operational Self-Improvement block instead).
+- For trivial changes (typo fix, config bump) — the Compound Step in the
+  ship template is enough.
+
+## Four Lenses
+
+For each lens, write either a knowledge entry **or** the explicit string
+"no new lesson". Skipping a lens silently is forbidden.
+
+### 1. What surprised us?
+
+- A bug that hid in a place no one suspected → \`[lesson]\`.
+- A test that passed but missed a real failure mode → \`[lesson]\`.
+- A library/API behavior that contradicted our mental model → \`[rule]\`.
+
+### 2. What slowed us down?
+
+- Repeated context loss between waves → \`[compound]\` accelerator.
+- Re-derivation of a fact already in upstream artifacts → \`[pattern]\` "re-read X first".
+- Tooling friction (slow test loop, flaky CI) → \`[compound]\` follow-up.
+
+### 3. What worked unreasonably well?
+
+- A refactor that unlocked the next 3 tasks → \`[pattern]\`.
+- A skill/agent invocation that nailed it on first try → \`[pattern]\` (record the prompt shape).
+- Adopting an existing solution instead of building → \`[rule]\` reinforcement.
+
+### 4. What would we do differently next time?
+
+- Architectural decision that aged poorly within the same run → \`[lesson]\`.
+- Scope mode chosen incorrectly → \`[rule]\` heuristic update.
+- Order-of-operations mistake (e.g. spec drift before tdd) → \`[pattern]\` ordering.
+
+## Output protocol
+
+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.
+
+Then write a one-paragraph **Run Summary** at the top of the next
+\`/cc <idea>\` brainstorm context citing the lessons in scope.
+
+## Anti-patterns
+
+- Retrospective as performance review — frame is *system improvement*, not blame.
+- Harvesting only positive ("what worked") and skipping uncomfortable lessons.
+- Writing entries so generic they could apply to any project.
+- Letting the retrospective drift into a re-design of the shipped feature.
+`;
+}
+export function languageTypescriptSkill() {
+    return `---
+name: language-typescript
+description: "TypeScript rule pack. Opt-in language lens. Use when reviewing or writing TypeScript/JavaScript diffs during tdd or review — enforces type-safety, runtime-boundary validation, and idiomatic patterns."
+---
+
+# TypeScript Rule Pack
+
+## Quick Start
+
+> 1. Activate during tdd or review whenever the diff touches \`.ts\`, \`.tsx\`, \`.mts\`, \`.cts\`, or \`.js\` files.
+> 2. Walk the rule tiers in order. Tier-1 violations block merge. Tier-2 need a named follow-up.
+> 3. Cite each finding as \`file:line — <rule id> — <one-line remediation>\`.
+
+## HARD-GATE
+
+Do not approve a TypeScript change that ships \`any\`, \`@ts-ignore\`, or
+\`@ts-expect-error\` *without* (a) a comment explaining why, (b) a linked issue,
+and (c) an assertion that the blast radius is bounded to the current file.
+No exceptions in production code paths.
+
+## Tier 1 — blocking rules
+
+1. **No silent \`any\`.** Unknown inputs must be typed as \`unknown\` first, then narrowed.
+2. **Runtime validate trust boundaries.** HTTP bodies, env vars, file contents, and
+   IPC payloads must be parsed through a schema validator (zod, valibot, io-ts) before
+   being treated as typed data.
+3. **No \`as\` without a narrowing reason.** \`value as Foo\` is only acceptable when
+   preceded by a runtime check that proves the shape (e.g. \`if ("id" in value)\`).
+4. **Exhaustive switches on discriminated unions.** Every \`switch\` on a tagged
+   union must end with a \`default\` branch that assigns to \`never\` to surface
+   missing cases at compile time.
+5. **Promise hygiene.** No unawaited promises in \`async\` functions; no
+   \`void promise\` unless documented. Use \`@typescript-eslint/no-floating-promises\`.
+6. **Null-safety at the boundary.** Optional chaining (\`?.\`) and nullish
+   coalescing (\`??\`) must only be used when the null path is handled, not as a
+   silent default.
+
+## Tier 2 — follow-up rules
+
+7. Prefer \`readonly\` for arrays/object fields that are not mutated.
+8. Prefer \`type\` aliases for unions, \`interface\` for extendable object shapes.
+9. Name generic parameters descriptively once they carry semantic meaning (\`TEvent\`, \`TPayload\`).
+10. Avoid re-exporting entire namespaces; named re-exports keep bundle analysis tractable.
+11. Co-locate test fixtures with their types to keep drift visible.
+
+## Anti-patterns
+
+- "It compiles, ship it" — compilation is necessary, not sufficient. Runtime boundary validation is the gate.
+- Casting library return types to tighten them without reading the library's actual contract.
+- Wrapping every function in \`try/catch\` and swallowing the error — errors must either be rethrown typed or mapped to a Result/Either shape.
+- Using enums where a string-literal union would do (enums carry runtime cost and erase at tree-shaking time only when \`const\`).
+
+## Review output shape
+
+\`\`\`
+- **Rule:** T1-2 (runtime validate trust boundaries)
+- **File:line:** src/api/users.ts:42
+- **Finding:** POST body cast directly to \`UserCreateInput\`; no schema parse.
+- **Remediation:** Parse through \`userCreateSchema\` (zod) before passing to the service layer.
+\`\`\`
+`;
+}
+export function languagePythonSkill() {
+    return `---
+name: language-python
+description: "Python rule pack. Opt-in language lens. Use when reviewing or writing Python diffs during tdd or review — enforces typing, exception hygiene, and idiomatic patterns."
+---
+
+# Python Rule Pack
+
+## Quick Start
+
+> 1. Activate during tdd or review whenever the diff touches \`.py\` / \`.pyi\` files.
+> 2. Walk the rule tiers in order. Tier-1 violations block merge. Tier-2 need a named follow-up.
+> 3. Cite each finding as \`file:line — <rule id> — <one-line remediation>\`.
+
+## HARD-GATE
+
+Do not approve a Python change that catches bare \`except:\` or \`except Exception:\`
+in production code *without* (a) re-raising, (b) logging with \`logger.exception\`, or
+(c) a comment explaining the intentional swallow. Silent broad catches are the
+single biggest source of "works on my machine" bugs in Python services.
+
+## Tier 1 — blocking rules
+
+1. **Type hints on public APIs.** Every exported function, method, and dataclass
+   must have full type hints. Use \`from __future__ import annotations\` or PEP 604 union syntax.
+2. **No mutable default arguments.** \`def f(x=[])\` is a bug. Use \`None\` + inline default.
+3. **Exception specificity.** Catch the narrowest exception class you actually handle.
+4. **Context managers for resources.** Files, sockets, DB sessions, locks — always \`with\`.
+5. **No bare \`assert\` in production code.** \`assert\` is stripped under \`python -O\`.
+   For invariants, raise \`ValueError\`/\`RuntimeError\` explicitly.
+6. **Deterministic imports.** No conditional imports at module top level except for
+   platform branches; no import-time side effects.
+
+## Tier 2 — follow-up rules
+
+7. Prefer \`@dataclass(slots=True, frozen=True)\` for value objects.
+8. Prefer \`pathlib.Path\` over \`os.path\` for new code.
+9. Use f-strings for interpolation; reserve \`%\` and \`.format\` for logger messages (lazy eval).
+10. Use \`logging.getLogger(__name__)\` per module; never the root logger.
+11. Pin dependency ranges in \`pyproject.toml\`; lock with \`uv lock\` / \`pip-compile\`.
+
+## Async-specific
+
+- Do not mix \`requests\`/sync I/O inside \`async def\`. Use \`httpx.AsyncClient\` / \`aiofiles\`.
+- \`asyncio.gather\` with \`return_exceptions=False\` cancels siblings on first failure — be explicit.
+- Every task created with \`asyncio.create_task\` must have its reference kept and awaited.
+
+## Anti-patterns
+
+- Using \`**kwargs\` to avoid writing a real signature.
+- Monkey-patching modules from tests without a \`contextlib.contextmanager\` cleanup.
+- Treating \`__init__.py\` as a place to run logic (imports only).
+- Re-inventing \`itertools\`/\`functools\` instead of using stdlib.
+
+## Review output shape
+
+\`\`\`
+- **Rule:** P1-3 (exception specificity)
+- **File:line:** users/service.py:88
+- **Finding:** \`except Exception\` around DB call silently drops integrity errors.
+- **Remediation:** Catch \`IntegrityError\` explicitly; re-raise everything else.
+\`\`\`
+`;
+}
+export function languageGoSkill() {
+    return `---
+name: language-go
+description: "Go rule pack. Opt-in language lens. Use when reviewing or writing Go diffs during tdd or review — enforces error handling discipline, concurrency safety, and idiomatic patterns."
+---
+
+# Go Rule Pack
+
+## Quick Start
+
+> 1. Activate during tdd or review whenever the diff touches \`.go\` files.
+> 2. Walk the rule tiers in order. Tier-1 violations block merge. Tier-2 need a named follow-up.
+> 3. Cite each finding as \`file:line — <rule id> — <one-line remediation>\`.
+
+## HARD-GATE
+
+Do not approve a Go change that discards an \`error\` return value with \`_ = ...\`
+in production code *without* a comment explaining why the error is provably
+irrelevant. Discarded errors are Go's #1 source of silent data loss.
+
+## Tier 1 — blocking rules
+
+1. **Every \`error\` is checked or explicitly wrapped with \`fmt.Errorf("%w", err)\`.**
+2. **No goroutine leaks.** Every \`go func()\` must have a stop condition visible in
+   the diff: a \`context.Context\` cancellation, a \`done\` channel, or a bounded
+   input channel that will close.
+3. **Context propagation.** Any function that does I/O, RPC, or long work must take
+   \`ctx context.Context\` as the first parameter.
+4. **No mutex by value.** Fields of type \`sync.Mutex\` / \`sync.RWMutex\` must be
+   pointers *or* the containing struct must be used only via pointer receivers.
+5. **Defer placement.** \`defer file.Close()\` must immediately follow a successful
+   open, before any code path that can return early.
+6. **\`for range\` capture hygiene** (pre-Go 1.22): copy loop variables before
+   capturing in goroutines or deferred functions. From Go 1.22+ the language fixes
+   this, but confirm the repo's \`go\` directive in \`go.mod\`.
+
+## Tier 2 — follow-up rules
+
+7. Prefer small interfaces defined at the consumer site, not upstream.
+8. Prefer \`errors.Is\` / \`errors.As\` over string matching.
+9. Avoid \`init()\` except for registering with a framework.
+10. Use \`t.Helper()\` inside test helpers so failure lines point at the caller.
+11. Use \`//go:build\` tags for OS-specific code, not runtime \`runtime.GOOS\` checks.
+
+## Concurrency-specific
+
+- Buffered channels are a performance hint, not a correctness fix. Unbuffered first.
+- \`sync.WaitGroup\` \`Add\` must happen **before** \`go\`, not inside the goroutine.
+- \`atomic\` operations must be paired on the same variable — do not mix \`atomic.Load\`
+  with plain reads of the same field.
+- Shared maps require a mutex or \`sync.Map\`; Go's race detector in CI is non-negotiable.
+
+## Anti-patterns
+
+- Returning \`interface{}\` / \`any\` to "keep options open" — narrow it now.
+- Building "smart" error types that lose the wrapped chain.
+- Using \`panic\` for control flow in library code (allowed only for unrecoverable invariants).
+- Ignoring \`go vet\` warnings because "the code works".
+
+## Review output shape
+
+\`\`\`
+- **Rule:** G1-2 (no goroutine leaks)
+- **File:line:** internal/worker/pool.go:57
+- **Finding:** \`go w.loop()\` has no stop condition; context is not threaded through.
+- **Remediation:** Accept \`ctx\` in \`Start\` and select on \`ctx.Done()\` inside \`loop\`.
+\`\`\`
+`;
+}
+/**
+ * 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 = {
+    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",
@@ -1082,7 +1393,8 @@ export const UTILITY_SKILL_FOLDERS = [
     "landscape-check",
     "adversarial-review",
     "security-audit",
-    "knowledge-curation"
+    "knowledge-curation",
+    "retrospective"
 ];
 export const UTILITY_SKILL_MAP = {
     security: securityReviewSkill,
@@ -1097,5 +1409,6 @@ export const UTILITY_SKILL_MAP = {
     "landscape-check": landscapeCheckSkill,
     "adversarial-review": adversarialReviewSkill,
     "security-audit": securityAuditSkill,
-    "knowledge-curation": knowledgeCurationSkill
+    "knowledge-curation": knowledgeCurationSkill,
+    retrospective: retrospectiveSkill
 };

package/dist/delegation.d.ts

@@ -2,7 +2,7 @@ import type { FlowStage } from "./types.js";
 export type DelegationEntry = {
     stage: string;
     agent: string;
-    mode: "mandatory" | "proactive";
+    mode: "mandatory" | "proactive" | "conditional";
     status: "scheduled" | "completed" | "failed" | "waived";
     taskId?: string;
     waiverReason?: string;
@@ -12,6 +12,11 @@ export type DelegationEntry = {
      * consumers treat missing runId as unscoped (conservatively excluded from current-run checks).
      */
     runId?: string;
+    /**
+     * For `conditional` rows: the trigger predicate that fired (e.g. `diff_lines_gt:100`).
+     * Recorded for audit so reviewers can see why the second pass was required.
+     */
+    conditionTrigger?: string;
 };
 export type DelegationLedger = {
     runId: string;

package/dist/delegation.js

@@ -14,7 +14,7 @@ function isDelegationEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const o = value;
-    const modeOk = o.mode === "mandatory" || o.mode === "proactive";
+    const modeOk = o.mode === "mandatory" || o.mode === "proactive" || o.mode === "conditional";
     const statusOk = o.status === "scheduled" ||
         o.status === "completed" ||
         o.status === "failed" ||
@@ -26,7 +26,8 @@ function isDelegationEntry(value) {
         typeof o.ts === "string" &&
         (o.taskId === undefined || typeof o.taskId === "string") &&
         (o.waiverReason === undefined || typeof o.waiverReason === "string") &&
-        (o.runId === undefined || typeof o.runId === "string"));
+        (o.runId === undefined || typeof o.runId === "string") &&
+        (o.conditionTrigger === undefined || typeof o.conditionTrigger === "string"));
 }
 function parseLedger(raw, runId) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {

package/dist/doctor.js

@@ -11,11 +11,13 @@ import { gitignoreHasRequiredPatterns } from "./gitignore.js";
 import { HARNESS_ADAPTERS, CCLAW_MARKER_START, CCLAW_MARKER_END } from "./harness-adapters.js";
 import { policyChecks } from "./policy.js";
 import { readFlowState } from "./runs.js";
+import { skippedStagesForTrack } from "./flow-state.js";
+import { TRACK_STAGES } from "./types.js";
 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 { 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);
@@ -406,6 +408,32 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: skillPath
         });
     }
+    // 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 fileName = LANGUAGE_RULE_PACK_FILES[pack];
+        if (!fileName)
+            continue;
+        const packPath = path.join(projectRoot, RUNTIME_ROOT, ...LANGUAGE_RULE_PACK_DIR, fileName);
+        checks.push({
+            name: `language_rule_pack:${pack}`,
+            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
     for (const agent of CCLAW_AGENTS) {
         const agentPath = path.join(projectRoot, RUNTIME_ROOT, "agents", `${agent.name}.md`);
@@ -666,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",
@@ -743,6 +781,29 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: activeRunId.length > 0,
         details: `${RUNTIME_ROOT}/state/flow-state.json must include activeRunId`
     });
+    const activeTrack = flowState.track ?? "standard";
+    const trackStageList = TRACK_STAGES[activeTrack];
+    const skippedFromState = Array.isArray(flowState.skippedStages) ? flowState.skippedStages : [];
+    const expectedSkipped = skippedStagesForTrack(activeTrack);
+    const skippedConsistent = expectedSkipped.length === skippedFromState.length &&
+        expectedSkipped.every((stage) => skippedFromState.includes(stage));
+    checks.push({
+        name: "flow_state:track",
+        ok: skippedConsistent,
+        details: skippedConsistent
+            ? `active track "${activeTrack}" (${trackStageList.length}/${COMMAND_FILE_ORDER.length} stages: ${trackStageList.join(" → ")})${expectedSkipped.length > 0 ? `; skippedStages=${expectedSkipped.join(", ")}` : ""}`
+            : `track "${activeTrack}" expects skippedStages=[${expectedSkipped.join(", ")}] but flow-state has [${skippedFromState.join(", ")}] — run \`cclaw sync\` to repair`
+    });
+    checks.push({
+        name: "flow_state:track_completed_in_track",
+        ok: flowState.completedStages.every((stage) => trackStageList.includes(stage) || expectedSkipped.includes(stage)),
+        details: (() => {
+            const offTrack = flowState.completedStages.filter((stage) => !trackStageList.includes(stage) && !expectedSkipped.includes(stage));
+            return offTrack.length === 0
+                ? `every completed stage belongs to track "${activeTrack}" or its skipped set`
+                : `completed stages contain entries outside track "${activeTrack}" and not in skipped set: ${offTrack.join(", ")}`;
+        })()
+    });
     checks.push({
         name: "artifacts:active_root",
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "artifacts")),

package/dist/install.d.ts

@@ -1,8 +1,10 @@
-import type { FlowTrack, HarnessId } from "./types.js";
+import type { FlowTrack, HarnessId, InitProfile } from "./types.js";
 export interface InitOptions {
     projectRoot: string;
     harnesses?: HarnessId[];
     track?: FlowTrack;
+    /** When set, pre-fills config defaults from the named profile before applying flag overrides. */
+    profile?: InitProfile;
 }
 export declare function initCclaw(options: InitOptions): Promise<void>;
 export declare function syncCclaw(projectRoot: string): Promise<void>;