cclaw-cli 0.5.17 → 0.7.0

package/dist/content/status-command.js

@@ -0,0 +1,154 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const STATUS_SKILL_FOLDER = "flow-status";
+const STATUS_SKILL_NAME = "flow-status";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function delegationLogPath() {
+    return `${RUNTIME_ROOT}/state/delegation-log.json`;
+}
+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.
+ */
+export function statusCommandContract() {
+    const flowPath = flowStatePath();
+    const delegationPath = delegationLogPath();
+    return `# /cc-status
+
+## Purpose
+
+**Read-only snapshot of the cclaw run.** Shows track, current stage, completed stages,
+gate coverage, mandatory delegations, and the top 3 knowledge highlights.
+
+This command **never mutates state**. Use it at session start to orient, or at any
+time to answer "where are we?" without advancing the flow.
+
+## HARD-GATE
+
+- **Do not** use \`/cc-status\` output to infer gate completion for decisions — cite
+  artifact evidence via \`/cc-next\` when advancing.
+- **Do not** mutate \`${flowPath}\` or delegation log from this command.
+
+## Algorithm
+
+1. Read **\`${flowPath}\`** — capture \`track\`, \`currentStage\`, \`completedStages\`,
+   \`skippedStages\`, and per-stage gate catalog.
+2. Read **\`${delegationPath}\`** — count delegated / completed / waived / pending entries
+   for the current stage's \`mandatoryDelegations\`.
+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).
+6. Emit the status block described below. Do **not** load any stage skill.
+
+## Status Block Format
+
+\`\`\`
+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">
+
+  gates:
+    passed:   <count> of <required>
+    blocked:  <count>
+    unmet:    <list of gate ids>
+
+  delegations (current stage):
+    required:  <list>
+    completed: <list>
+    pending:   <list>
+
+  knowledge highlights:
+    - <latest entry summary line>
+    - <second entry summary line>
+    - <third entry summary line>
+
+  next action:
+    /cc-next  (advance or resume current stage)
+\`\`\`
+
+## Anti-patterns
+
+- Inventing gate status without reading \`${flowPath}\`.
+- Reporting delegations as satisfied when the log says \`pending\`.
+- Advancing the stage from \`/cc-status\` — progression belongs to \`/cc-next\`.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${STATUS_SKILL_FOLDER}/SKILL.md**
+`;
+}
+/**
+ * Skill body for /cc-status — read-only status snapshot.
+ */
+export function statusCommandSkillMarkdown() {
+    const flowPath = flowStatePath();
+    const delegationPath = delegationLogPath();
+    return `---
+name: ${STATUS_SKILL_NAME}
+description: "Read-only snapshot of the cclaw flow: track, stage, gate coverage, delegations, knowledge highlights. Never mutates state."
+---
+
+# /cc-status — Flow Status Snapshot
+
+## Overview
+
+\`/cc-status\` is the quickest way to answer "where are we in the flow?" without
+advancing or mutating anything. Safe to run at any point.
+
+## HARD-GATE
+
+Do **not** mutate \`${flowPath}\` or \`${delegationPath}\` from this skill. This is
+a read-only command.
+
+## Algorithm
+
+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 \`${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\`.
+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).
+
+## Output Guidelines
+
+- Keep output compact (≤ 25 lines) — status, not narrative.
+- Report counts, not full artifact contents.
+- If any data source is missing or corrupt, say so explicitly rather than guessing.
+
+## Anti-patterns
+
+- Rebuilding trace-matrix or running doctor from \`/cc-status\` — those belong to dedicated tools.
+- Treating absence of delegation log as "all delegations complete".
+- Mutating state to "clean up" during a status check.
+`;
+}

package/dist/content/templates.js

@@ -345,11 +345,41 @@ 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:
-- 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>%)
+- Task coverage (tasks backed by ≥1 test slice): <N>/<M>
+- Slice coverage (slices linked to ≥1 AC): <N>/<M>
+- Adversarial review pass: true | false
+- Overall score: <0-100>
 
 ## Severity Summary
 - Critical:
@@ -411,6 +441,12 @@ Execution rule: complete and verify each wave before starting the next wave.
 ## Completion Status
 - SHIPPED | SHIPPED_WITH_EXCEPTIONS | BLOCKED
 - Exceptions (if any):
+
+## Compound Step
+_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
 `
 };
 export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook

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

@@ -1,5 +1,5 @@
 /**
- * Utility skills that complement the 9 flow stages.
+ * Utility skills that complement the 8 flow stages.
  * These are contextual lenses, not flow stages.
  * Each skill: ~120-180 lines, under the 500-line progressive disclosure guideline.
  */
@@ -12,5 +12,19 @@ export declare function executingPlansSkill(): string;
 export declare function contextEngineeringSkill(): string;
 export declare function sourceDrivenDevelopmentSkill(): string;
 export declare function frontendAccessibilitySkill(): string;
-export declare const UTILITY_SKILL_FOLDERS: readonly ["security", "debugging", "performance", "ci-cd", "docs", "executing-plans", "context-engineering", "source-driven-development", "frontend-accessibility"];
+export declare function landscapeCheckSkill(): string;
+export declare function knowledgeCurationSkill(): string;
+export declare function securityAuditSkill(): string;
+export declare function adversarialReviewSkill(): string;
+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>;