cclaw-cli 0.6.0 → 0.7.0

package/dist/content/start-command.js

@@ -33,10 +33,22 @@ This is the **recommended way to start** working with cclaw. Use \`/cc-next\` fo
 
 1. Read \`${flowPath}\`.
 2. If flow already has completed stages beyond brainstorm, warn the user that starting a new brainstorm will reset progress. Ask for confirmation before proceeding.
-3. Write the prompt to \`.cclaw/artifacts/00-idea.md\` as the raw idea capture.
-4. Set \`currentStage: "brainstorm"\` in flow state (reset if needed).
-5. Load \`.cclaw/skills/brainstorming/SKILL.md\` and \`.cclaw/commands/brainstorm.md\`.
-6. Execute brainstorm with the prompt as initial context.
+3. **Track heuristic** — classify the idea text and **recommend** a track (the user can override before any state mutation):
+   - **quick** (\`spec → tdd → review → ship\`) — single-purpose work where the spec is essentially already known.
+     Triggers (case-insensitive substring or close variant): \`bug\`, \`bugfix\`, \`fix\`, \`hotfix\`, \`patch\`, \`typo\`, \`regression\`, \`copy change\`, \`rename\`, \`bump\`, \`upgrade dep\`, \`config tweak\`, \`docs only\`, \`comment\`, \`lint\`, \`format\`, \`small\`, \`tiny\`, \`one-liner\`, \`revert\`.
+   - **standard** (full 8 stages — default) — anything that introduces a new capability, touches multiple modules, or has unclear scope.
+     Triggers: \`new feature\`, \`add\`, \`build\`, \`design\`, \`refactor\`, \`migration\`, \`platform\`, \`architecture\`, \`endpoint\`, \`schema\`, \`api\`, \`integrate\`, \`workflow\`, \`onboarding\`, or any prompt that does not match quick triggers.
+   - When triggers conflict (e.g. "small refactor that touches 5 modules") prefer **standard** — quick is opt-in and only safe when scope is genuinely tiny.
+4. Present the recommendation as a single decision with explicit options:
+   > \`Recommended track: <quick|standard>\` because \`<one-line reason citing matched triggers>\`.
+   > Override? (A) keep \`<recommended>\`  (B) switch to \`<other>\`  (C) cancel.
+   If \`AskQuestion\`/\`AskUserQuestion\` is available, send exactly ONE question; on schema error, fall back to plain text.
+5. Persist the chosen track to \`${flowPath}\` (\`track\` field). Compute \`skippedStages\` from the track and write that too. Use the **first stage of the chosen track** as \`currentStage\` (quick → \`spec\`, standard → \`brainstorm\`).
+6. Write the prompt to \`.cclaw/artifacts/00-idea.md\` as the raw idea capture, and append a \`Track:\` line referencing the chosen track and the matched heuristic.
+7. Load the **first-stage skill for the chosen track** and its command file:
+   - quick → \`.cclaw/skills/specification-authoring/SKILL.md\` + \`.cclaw/commands/spec.md\`
+   - standard → \`.cclaw/skills/brainstorming/SKILL.md\` + \`.cclaw/commands/brainstorm.md\`
+8. Execute that stage with the prompt as initial context.
 
 ### Without prompt (\`/cc\`)
 
@@ -81,9 +93,20 @@ Do **not** silently discard an existing flow when the user provides a prompt. If
    - Inform: "You have an active flow at stage **{currentStage}** with {N} completed stages. Starting a new brainstorm will reset progress."
    - Ask: "Continue with reset? (A) Yes, start fresh (B) No, resume current flow"
    - If (B) → switch to Path B behavior.
-3. Write \`${RUNTIME_ROOT}/artifacts/00-idea.md\` with the user's prompt.
-4. Update \`${flowPath}\`: set \`currentStage: "brainstorm"\`, clear \`completedStages\`, reset gate catalog.
-5. Load and execute: \`${RUNTIME_ROOT}/skills/brainstorming/SKILL.md\` + \`${RUNTIME_ROOT}/commands/brainstorm.md\`.
+3. **Classify the idea** using the heuristic below and present a single track recommendation. Wait for explicit confirmation or override before mutating any state.
+
+   **Track heuristic** (lowercase substring match against the user prompt):
+
+   | Track | Triggers | Use when |
+   |---|---|---|
+   | \`quick\` | \`bug\`, \`bugfix\`, \`fix\`, \`hotfix\`, \`patch\`, \`typo\`, \`regression\`, \`rename\`, \`bump\`, \`upgrade dep\`, \`docs only\`, \`comment\`, \`lint\`, \`format\`, \`small\`, \`tiny\`, \`one-liner\`, \`revert\`, \`copy change\` | Single-purpose, spec is essentially known, low blast radius |
+   | \`standard\` | \`new feature\`, \`add\`, \`build\`, \`design\`, \`refactor\`, \`migration\`, \`platform\`, \`architecture\`, \`endpoint\`, \`schema\`, \`api\`, \`integrate\`, \`workflow\`, \`onboarding\` (or no quick trigger matched) | Anything new, multi-module, or unclear scope |
+
+   - On conflict, prefer \`standard\` (quick is opt-in for genuinely tiny work).
+   - Always state the recommendation as a one-line reason citing the matched trigger.
+4. Persist the chosen track in \`${flowPath}\` (\`track\` + \`skippedStages\`). Set \`currentStage\` to the first stage of the chosen track (\`quick\` → \`spec\`, \`standard\` → \`brainstorm\`). Reset gate catalog.
+5. Write \`${RUNTIME_ROOT}/artifacts/00-idea.md\` with the user's prompt and an explicit \`Track:\` line capturing the heuristic decision.
+6. Load and execute the **first stage skill of the chosen track** (\`brainstorming\` for standard, \`specification-authoring\` for quick) plus its matching command file.
 
 ### Path B: \`/cc\` (no arguments)
 

package/dist/content/status-command.js

@@ -10,6 +10,15 @@ function delegationLogPath() {
 function knowledgePath() {
     return `${RUNTIME_ROOT}/knowledge.md`;
 }
+function contextModePath() {
+    return `${RUNTIME_ROOT}/state/context-mode.json`;
+}
+function checkpointPath() {
+    return `${RUNTIME_ROOT}/state/checkpoint.json`;
+}
+function stageActivityPath() {
+    return `${RUNTIME_ROOT}/state/stage-activity.jsonl`;
+}
 /**
  * Command contract for /cc-status — a read-only snapshot command.
  * Does not mutate state. Always safe to run.
@@ -39,9 +48,15 @@ time to answer "where are we?" without advancing the flow.
    \`skippedStages\`, and per-stage gate catalog.
 2. Read **\`${delegationPath}\`** — count delegated / completed / waived / pending entries
    for the current stage's \`mandatoryDelegations\`.
-3. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
+3. Read **\`${contextModePath()}\`** — surface \`activeMode\` (default if missing).
+4. Compute **time in current stage** from the most recent stage-entry signal:
+   - Prefer \`${checkpointPath()}\`'s \`timestamp\` when its \`stage\` matches \`currentStage\`.
+   - Otherwise scan \`${stageActivityPath()}\` from the end for the first entry whose \`stage\` matches \`currentStage\` and use its \`ts\`.
+   - Compute the duration as \`now - signalTimestamp\` and render compactly: \`<X>m\`, \`<X>h<Y>m\`, or \`<X>d<Y>h\`.
+   - If no signal exists, render \`(unknown)\`.
+5. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
    (by trailing timestamp or source marker).
-4. Emit the status block described below. Do **not** load any stage skill.
+6. Emit the status block described below. Do **not** load any stage skill.
 
 ## Status Block Format
 
@@ -49,6 +64,8 @@ time to answer "where are we?" without advancing the flow.
 cclaw status
   track:            <quick|standard>
   current stage:    <stage>     (<N>/<total> in track)
+  time in stage:    <Xd Yh | Yh Zm | Zm | unknown>
+  context mode:     <activeMode>     (default | execution | review | incident | …)
   completed stages: <list or "none">
   skipped stages:   <list or "none">
 
@@ -109,11 +126,16 @@ a read-only command.
 
 1. Read \`${flowPath}\`. If missing → report **BLOCKED: flow state absent** and suggest \`cclaw init\`.
 2. Read \`${delegationPath}\`. Missing → treat all mandatory delegations as pending.
-3. Read \`${RUNTIME_ROOT}/knowledge.md\`. If missing or empty → knowledge highlights are \`(none recorded)\`.
-4. For each gate in \`stageGateCatalog[currentStage].required\`:
+3. Read \`${contextModePath()}\` for \`activeMode\`. Missing → render \`activeMode = default\`.
+4. Compute **time in stage**:
+   - 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)\`.
+6. For each gate in \`stageGateCatalog[currentStage].required\`:
    - Satisfied if present in \`passed\` and absent from \`blocked\`.
-5. Build and print the status block (see command contract for layout).
-6. Suggest the next action:
+7. Build and print the status block (see command contract for layout).
+8. Suggest the next action:
    - If current stage has unmet gates → \`/cc-next\` to resume.
    - If current stage is complete → \`/cc-next\` to advance (or report "Flow complete" if terminal).
 

package/dist/content/templates.js

@@ -345,12 +345,34 @@ Execution rule: complete and verify each wave before starting the next wave.
 - Reconciliation summary:
 
 ## Review Readiness Dashboard
-- Layer 1 complete:
-- Layer 2 complete:
-- Review army schema valid:
-- Open critical blockers:
-- Adversarial review pass:
-- Ship recommendation:
+
+| Pass | Status | Completed at (UTC) | Reviewer / source | Commit at review | Drift vs HEAD |
+|---|---|---|---|---|---|
+| Layer 1 — spec compliance | pass / fail / pending | <ISO 8601> | spec-reviewer | <short sha> | <files changed since> |
+| Layer 2 — correctness | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
+| Layer 2 — security | pass / fail / pending | <ISO 8601> | security-reviewer | <short sha> | <files changed since> |
+| Layer 2 — performance | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
+| Layer 2 — architecture | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
+| Adversarial review | pass / fail / n/a | <ISO 8601 or —> | adversarial-review skill | <short sha or —> | <drift or —> |
+| Review army schema valid | pass / fail | <ISO 8601> | jsonschema | <short sha> | n/a |
+
+### Delegation log snapshot (current run, current stage)
+- Path: \`.cclaw/state/delegation-log.json\`
+- Required: <list of mandatory specialists>
+- Completed: <list with timestamps>
+- Waived (with reason): <list or "none">
+- Pending: <list or "none">
+
+### Staleness signal
+- Worktree commit at last review pass: \`<short sha>\`
+- Worktree commit now: \`<short sha>\`
+- Files changed since last review pass: \`<count>\` (run \`git diff --stat <sha>..HEAD\` to inspect)
+- If drift > 0 lines, mark Layer 1 / Layer 2 results as **STALE — re-run before ship**.
+
+### Headline
+- Open critical blockers: <count>
+- Adversarial review pass: pass / fail / n/a
+- Ship recommendation: APPROVED | APPROVED_WITH_CONCERNS | BLOCKED
 
 ## Completeness Score
 - AC coverage: <N>/<M> (<percent>%)

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

@@ -16,5 +16,15 @@ export declare function landscapeCheckSkill(): string;
 export declare function knowledgeCurationSkill(): string;
 export declare function securityAuditSkill(): string;
 export declare function adversarialReviewSkill(): string;
-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"];
+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";
+};
+export declare const LANGUAGE_RULE_PACK_GENERATORS: Record<string, () => string>;
+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,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 .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."
 ---
 
 # 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.md\` and, when present, \`.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 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.
 
 ## When to run
 
@@ -1069,6 +1068,295 @@ 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.md\`.
+> 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 entry to \`.cclaw/knowledge.md\` using
+the standard format (see \`learnings\` skill). Prefer:
+
+- \`[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\`.
+\`\`\`
+`;
+}
+export const LANGUAGE_RULE_PACK_FOLDERS = {
+    typescript: "language-typescript",
+    python: "language-python",
+    go: "language-go"
+};
+export const LANGUAGE_RULE_PACK_GENERATORS = {
+    "language-typescript": languageTypescriptSkill,
+    "language-python": languagePythonSkill,
+    "language-go": languageGoSkill
+};
 export const UTILITY_SKILL_FOLDERS = [
     "security",
     "debugging",
@@ -1082,7 +1370,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 +1386,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_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,18 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: skillPath
         });
     }
+    // Opt-in language rule packs: only check presence for packs the user enabled.
+    for (const pack of parsedConfig?.languageRulePacks ?? []) {
+        const folder = LANGUAGE_RULE_PACK_FOLDERS[pack];
+        if (!folder)
+            continue;
+        const skillPath = path.join(projectRoot, RUNTIME_ROOT, "skills", folder, "SKILL.md");
+        checks.push({
+            name: `language_rule_pack:${pack}`,
+            ok: await exists(skillPath),
+            details: skillPath
+        });
+    }
     // Agent definition files
     for (const agent of CCLAW_AGENTS) {
         const agentPath = path.join(projectRoot, RUNTIME_ROOT, "agents", `${agent.name}.md`);
@@ -743,6 +757,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>;