cclaw-cli 6.14.4 → 7.0.0

package/dist/flow-state.d.ts

@@ -74,8 +74,10 @@ export interface CloseoutState {
 }
 export declare function createInitialCloseoutState(): CloseoutState;
 export interface FlowState {
-    /** Backward-compatible schema marker for future migrations. */
+    /** Schema marker for forward compatibility. */
     schemaVersion: typeof FLOW_STATE_SCHEMA_VERSION;
+    /** Workspace marker stamped during sync/upgrade (semver string). */
+    packageVersion?: string;
     activeRunId: string;
     currentStage: FlowStage;
     completedStages: FlowStage[];
@@ -86,17 +88,14 @@ export interface FlowState {
     /** Run-level upstream shaping mode chosen once at start (`lean` / `guided` / `deep`). */
     discoveryMode: DiscoveryMode;
     /**
-     * Wave 25 (v6.1.0) — optional task class for the active run.
+     * Optional task class for the active run.
      *
-     * Mirrors the `MandatoryDelegationTaskClass` union used by Wave 24's
-     * `mandatoryAgentsFor` helper. When set to `"software-bugfix"`, the
+     * Mirrors the `MandatoryDelegationTaskClass` union used by
+     * `mandatoryAgentsFor`. When set to `"software-bugfix"`, the
      * artifact-validation escape (`shouldDemoteArtifactValidationByTrack`)
      * collapses lite-tier-only checks (Architecture Diagram async/failure
      * edges, Interaction Edge Case mandatory rows, Stale Diagram Drift,
      * Expansion Strategist) from required → advisory.
-     *
-     * Persistence is best-effort: existing flow-state.json files written
-     * before Wave 25 simply omit the field (treated as `null`).
      */
     taskClass?: "software-standard" | "software-trivial" | "software-bugfix" | null;
     /** Stages explicitly skipped for this track (empty for standard; populated for quick). */
@@ -115,137 +114,33 @@ export interface FlowState {
     repoSignals?: RepoSignals;
     /**
      * Best-effort stage completion timestamps (ISO strings) captured as stages
-     * enter `completedStages`. Missing keys behave like legacy flows with no audit
-     * clock for post-closure mutation hints.
+     * enter `completedStages`. Missing keys behave like older flows with no
+     * audit clock for post-closure mutation hints.
      */
     completedStageMeta?: Partial<Record<FlowStage, {
         completedAt: string;
     }>>;
     /**
-     * v6.12.0 — TDD migration cutover marker. When `cclaw-cli sync` detects an
-     * existing `06-tdd.md` with legacy per-slice tables but no auto-render
-     * markers, it inserts the markers and records the highest legacy slice id
-     * here (e.g. `"S-10"`). The TDD linter uses this value to:
-     *   - exempt slices `<= cutoverSliceId` from new mandatory rules (legacy
-     *     slices keep their markdown tables);
-     *   - emit `tdd_legacy_section_writes_after_cutover` advisory when a slice
-     *     id `> cutoverSliceId` appears in legacy per-slice sections of
-     *     `06-tdd.md` (post-cutover prose belongs in `tdd-slices/S-<id>.md`).
-     *
-     * Optional + best-effort: omitted on fresh installs and on legacy files
-     * sync hasn't visited yet.
-     */
-    tddCutoverSliceId?: string;
-    /**
-     * v6.14.2 — boundary slice id at which worktree-first protocol began
-     * applying. `cclaw-cli sync` auto-stamps this when
-     * `legacyContinuation: true` AND `worktreeExecutionMode: "worktree-first"`
-     * AND the value is not already set.
-     *
-     * Detection rule (v6.14.2): the highest `S-N` among slices with at
-     * least one completed `slice-implementer` row in the active run that
-     * carries NONE of the worktree-first metadata fields (`claimToken`,
-     * `ownerLaneId`, `leasedUntil`). When no such slice exists, sync
-     * falls back to `tddCutoverSliceId` so legacy v6.12 cutover marks
-     * still confer the exemption.
-     *
-     * Effect: closed slices whose numeric id is `<= tddWorktreeCutoverSliceId`
-     * AND whose `slice-implementer` rows in the active run lack ALL
-     * three worktree fields are exempt from `tdd_slice_lane_metadata_missing`,
-     * `tdd_slice_claim_token_missing`, and `tdd_lease_expired_unreclaimed`.
-     *
-     * One-shot: subsequent sync runs leave the value untouched. Operators
-     * may pin it earlier/later by direct edit + `cclaw-cli internal
-     * flow-state-repair --reason=<slug>`.
-     */
-    tddWorktreeCutoverSliceId?: string;
-    /**
-     * v6.13.0 — when `worktree-first` (default for newly initialized runs),
-     * slice-implementer work happens in isolated git worktrees with explicit
-     * claims/leases and deterministic fan-in integration.
-     *
-     * Omitted on legacy `flow-state.json` files: treated as `single-tree` via
-     * `effectiveWorktreeExecutionMode`.
-     */
-    worktreeExecutionMode?: "single-tree" | "worktree-first";
-    /**
-     * v6.13.0 — set by `cclaw-cli sync` when the plan predates parallel-metadata
-     * fields. Relaxes some plan linters for existing implementation units and
-     * defaults scheduler parallelism to opt-in only for those units.
-     */
-    legacyContinuation?: boolean;
-    /**
-     * v6.14.0 — TDD wave checkpoint mode (stream-style parallel TDD).
-     *
-     * - `per-slice` — default for new projects. Each lane runs RED→GREEN as
-     *   soon as its `dependsOn` closes; the linter enforces RED-before-GREEN
-     *   per slice only (`tdd_slice_red_completed_before_green`). No global
-     *   barrier between Phase A REDs and Phase B GREENs.
-     * - `global-red` — legacy v6.12/v6.13 behavior. ALL Phase A REDs in a
-     *   wave must complete before ANY Phase B GREEN starts. Auto-applied
-     *   for projects with `legacyContinuation: true` so hox-style runs
-     *   continue to enforce the wave barrier.
-     *
-     * Omitted on legacy state files (treated as `"global-red"` for
-     * `legacyContinuation: true` and `"per-slice"` otherwise via
-     * `effectiveTddCheckpointMode`).
-     */
-    tddCheckpointMode?: "per-slice" | "global-red";
-    /**
-     * v6.14.0 — integration-overseer dispatch mode.
-     *
-     * - `conditional` — default for new projects. The controller calls
-     *   `integrationCheckRequired(events)` after wave closeout; the
-     *   integration-overseer is dispatched only when (a) two or more
-     *   closed slices share import boundaries (heuristic: shared
-     *   directory in `evidenceRefs`/`claimedPaths`), (b) any slice has
-     *   `riskTier === "high"`, or (c) deterministic fan-in reported a
-     *   `cclaw_fanin_conflict`. Otherwise the linter emits the audit
-     *   row `cclaw_integration_overseer_skipped` and skips dispatch.
-     * - `always` — legacy v6.13 behavior. Run integration-overseer
-     *   after every multi-slice wave regardless of trigger.
-     *
-     * Omitted on legacy state files (treated as `"always"`).
-     */
-    integrationOverseerMode?: "conditional" | "always";
-    /**
-     * v6.14.2 — minimum elapsed milliseconds between `acknowledged` and
-     * `completed` for a `slice-implementer --phase green` row. The hook
-     * helper rejects fast-greens (`completedTs - ackTs < this`) with
-     * `green_evidence_too_fresh` unless the dispatch carries
-     * `--allow-fast-green --green-mode=observational`.
+     * Minimum elapsed milliseconds between `acknowledged` and `completed`
+     * for a `slice-builder --phase green` row. The hook helper rejects
+     * fast-greens (`completedTs - ackTs < this`) with `green_evidence_too_fresh`
+     * unless the dispatch carries `--allow-fast-green --green-mode=observational`.
      *
      * Default 4000ms when omitted (see `effectiveTddGreenMinElapsedMs`).
      * Operators tuning the floor for very fast suites may set it lower
-     * (e.g. `1500`) or set it to `0` to disable the check entirely while
-     * keeping the other Fix 4 contracts (RED test name match, passing
-     * assertion line) active.
+     * (e.g. `1500`) or `0` to disable the check entirely while keeping the
+     * other freshness contracts (RED test name match, passing assertion line)
+     * active.
      */
     tddGreenMinElapsedMs?: number;
 }
-/**
- * Effective worktree mode: legacy state files without the field keep
- * single-tree scheduling to avoid breaking existing runs on upgrade.
- */
-export declare function effectiveWorktreeExecutionMode(state: FlowState): "single-tree" | "worktree-first";
-/**
- * Effective v6.14 TDD checkpoint mode: legacy state files without the
- * field default to `global-red` when `legacyContinuation: true` (hox)
- * and `per-slice` otherwise. Explicit values always win.
- */
-export declare function effectiveTddCheckpointMode(state: FlowState): "per-slice" | "global-red";
-/**
- * Effective v6.14 integration-overseer mode: legacy state files without
- * the field default to `always` (matches v6.13 behavior).
- */
-export declare function effectiveIntegrationOverseerMode(state: FlowState): "conditional" | "always";
 export declare const DEFAULT_TDD_GREEN_MIN_ELAPSED_MS = 4000;
 /**
- * v6.14.2 — effective minimum GREEN elapsed window in milliseconds.
- * Returns the per-project override when present and finite; otherwise
- * the documented 4000ms default. Negative values or NaN fall through
- * to the default so a hand-edited `flow-state.json` cannot accidentally
- * disable the check via `-1` or `"oops"`.
+ * Effective minimum GREEN elapsed window in milliseconds. Returns the
+ * per-project override when present and finite; otherwise the documented
+ * 4000ms default. Negative values or NaN fall through to the default so a
+ * hand-edited `flow-state.json` cannot accidentally disable the check via
+ * `-1` or `"oops"`.
  */
 export declare function effectiveTddGreenMinElapsedMs(state: FlowState): number;
 export interface StageInteractionHint {
@@ -253,10 +148,10 @@ export interface StageInteractionHint {
     sourceStage?: FlowStage;
     recordedAt?: string;
     /**
-     * Wave 23 (v5.0.0) — `/cc-ideate` handoff carry-forward.
-     * When a brainstorm run is started from a `/cc-ideate` recommendation,
-     * `start-flow` records the originating idea artifact so brainstorm can
-     * reuse the divergent + critique + rank work instead of re-generating it.
+     * `/cc-ideate` handoff carry-forward. When a brainstorm run is started
+     * from a `/cc-ideate` recommendation, `start-flow` records the originating
+     * idea artifact so brainstorm can reuse the divergent + critique + rank
+     * work instead of re-generating it.
      *
      * `fromIdeaArtifact` is a workspace-relative POSIX path to
      * `.cclaw/ideas/idea-YYYY-MM-DD-<slug>.md` (or wherever `/cc-ideate`

package/dist/flow-state.js

@@ -44,38 +44,13 @@ export function createInitialCloseoutState() {
         compoundPromoted: 0
     };
 }
-/**
- * Effective worktree mode: legacy state files without the field keep
- * single-tree scheduling to avoid breaking existing runs on upgrade.
- */
-export function effectiveWorktreeExecutionMode(state) {
-    return state.worktreeExecutionMode ?? "single-tree";
-}
-/**
- * Effective v6.14 TDD checkpoint mode: legacy state files without the
- * field default to `global-red` when `legacyContinuation: true` (hox)
- * and `per-slice` otherwise. Explicit values always win.
- */
-export function effectiveTddCheckpointMode(state) {
-    if (state.tddCheckpointMode === "per-slice" || state.tddCheckpointMode === "global-red") {
-        return state.tddCheckpointMode;
-    }
-    return state.legacyContinuation === true ? "global-red" : "per-slice";
-}
-/**
- * Effective v6.14 integration-overseer mode: legacy state files without
- * the field default to `always` (matches v6.13 behavior).
- */
-export function effectiveIntegrationOverseerMode(state) {
-    return state.integrationOverseerMode === "conditional" ? "conditional" : "always";
-}
 export const DEFAULT_TDD_GREEN_MIN_ELAPSED_MS = 4000;
 /**
- * v6.14.2 — effective minimum GREEN elapsed window in milliseconds.
- * Returns the per-project override when present and finite; otherwise
- * the documented 4000ms default. Negative values or NaN fall through
- * to the default so a hand-edited `flow-state.json` cannot accidentally
- * disable the check via `-1` or `"oops"`.
+ * Effective minimum GREEN elapsed window in milliseconds. Returns the
+ * per-project override when present and finite; otherwise the documented
+ * 4000ms default. Negative values or NaN fall through to the default so a
+ * hand-edited `flow-state.json` cannot accidentally disable the check via
+ * `-1` or `"oops"`.
  */
 export function effectiveTddGreenMinElapsedMs(state) {
     const raw = state.tddGreenMinElapsedMs;

package/dist/gate-evidence.d.ts

@@ -13,13 +13,13 @@ export interface QaLogFloorSignal {
     ok: boolean;
     count: number;
     /**
-     * Wave 23 (v5.0.0): always 0. The convergence floor no longer enforces
+     * always 0. The convergence floor no longer enforces
      * a fixed count. Harness UIs may render `questionBudgetHint(track,
      * stage).recommended` separately as a soft hint.
      */
     min: number;
     hasStopSignal: boolean;
-    /** Wave 23: always false. See `min` note above. */
+    /** Always false; see `min` note above. */
     liteShortCircuit: boolean;
     skipQuestionsAdvisory: boolean;
     blocking: boolean;
@@ -66,11 +66,6 @@ export interface VerifyCurrentStageGateEvidenceOptions {
     extraStageFlags?: string[];
 }
 export declare function verifyCurrentStageGateEvidence(projectRoot: string, flowState: FlowState, options?: VerifyCurrentStageGateEvidenceOptions): Promise<GateEvidenceCheckResult>;
-/**
- * Validates that every lane-backed slice which reached REFACTOR has a matching
- * `cclaw_fanin_applied` audit row for the active run (v6.13.0 worktree-first).
- */
-export declare function verifyTddWorktreeFanInClosure(projectRoot: string, flowState: FlowState): Promise<string[]>;
 export declare function verifyCompletedStagesGateClosure(flowState: FlowState): CompletedStagesClosureResult;
 export interface GateReconciliationResult {
     stage: FlowStage;

package/dist/gate-evidence.js

@@ -5,8 +5,7 @@ import { ELICITATION_STAGES, evaluateQaLogFloor } from "./artifact-linter/shared
 import { resolveArtifactPath } from "./artifact-paths.js";
 import { RUNTIME_ROOT } from "./constants.js";
 import { stageSchema } from "./content/stage-schema.js";
-import { readDelegationLedger, readDelegationEvents } from "./delegation.js";
-import { effectiveWorktreeExecutionMode } from "./flow-state.js";
+import { readDelegationLedger } from "./delegation.js";
 import { exists } from "./fs-utils.js";
 import { computeEarlyLoopStatus, isEarlyLoopStage, normalizeEarlyLoopMaxIterations } from "./early-loop.js";
 import { detectPublicApiChanges } from "./internal/detect-public-api-changes.js";
@@ -463,7 +462,7 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState, opt
             forcingPending: floor.forcingPending,
             noNewDecisions: floor.noNewDecisions
         };
-        // v6.9.0 — when the QA log floor is blocking, mirror that decision into
+        // when the QA log floor is blocking, mirror that decision into
         // `gates.issues` so the harness has a single structured source of truth
         // for "this stage is blocked". The `qa_log_unconverged` linter rule
         // remains the verbose detail/fallback channel.
@@ -488,62 +487,6 @@ export async function verifyCurrentStageGateEvidence(projectRoot, flowState, opt
         qaLogFloor
     };
 }
-function sliceHasTerminalRefactor(events, runId, sliceId) {
-    for (const e of events) {
-        if (e.runId !== runId || e.stage !== "tdd" || e.sliceId !== sliceId)
-            continue;
-        if (e.agent !== "slice-implementer" || e.status !== "completed")
-            continue;
-        if (e.phase === "refactor" || e.phase === "refactor-deferred")
-            return true;
-    }
-    return false;
-}
-function closedSlicesWithLane(events, runId) {
-    const withLane = new Set();
-    for (const e of events) {
-        if (e.runId !== runId || e.stage !== "tdd")
-            continue;
-        if (e.agent !== "slice-implementer" || e.status !== "completed" || e.phase !== "green")
-            continue;
-        if (!e.ownerLaneId?.trim() || !e.sliceId)
-            continue;
-        withLane.add(e.sliceId);
-    }
-    const out = new Set();
-    for (const sid of withLane) {
-        if (sliceHasTerminalRefactor(events, runId, sid))
-            out.add(sid);
-    }
-    return out;
-}
-/**
- * Validates that every lane-backed slice which reached REFACTOR has a matching
- * `cclaw_fanin_applied` audit row for the active run (v6.13.0 worktree-first).
- */
-export async function verifyTddWorktreeFanInClosure(projectRoot, flowState) {
-    if (effectiveWorktreeExecutionMode(flowState) !== "worktree-first")
-        return [];
-    const runId = flowState.activeRunId;
-    const { events, fanInAudits } = await readDelegationEvents(projectRoot);
-    const needing = closedSlicesWithLane(events, runId);
-    if (needing.size === 0)
-        return [];
-    const applied = new Set();
-    for (const a of fanInAudits) {
-        if (a.runId !== runId || a.event !== "cclaw_fanin_applied")
-            continue;
-        for (const s of a.sliceIds ?? [])
-            applied.add(s);
-    }
-    const issues = [];
-    for (const sid of needing) {
-        if (!applied.has(sid)) {
-            issues.push(`tdd worktree fan-in closure: slice ${sid} completed on a lane but cclaw_fanin_applied is missing for run ${runId}.`);
-        }
-    }
-    return issues;
-}
 export function verifyCompletedStagesGateClosure(flowState) {
     const issues = [];
     const openStages = [];

package/dist/harness-adapters.d.ts

@@ -79,7 +79,7 @@ export interface HarnessAdapter {
          *   (`codex-rs/collaboration-mode-templates`). Available to agents running
          *   inside Codex but may be hidden on very old builds.
          * - `plain-text`        — fallback only; used when no native primitive is
-         *   available (no shipping harness uses this in v0.41.0).
+         *   available (no shipping harness uses this).
          */
         structuredAsk: "AskUserQuestion" | "AskQuestion" | "question" | "request_user_input" | "plain-text";
         /**

package/dist/harness-adapters.js

@@ -293,7 +293,7 @@ export function harnessesByTier() {
     });
 }
 function ironLawsAgentsMdBlock() {
-    // v6.9.0: keep this set in sync with `ironLawsSkillMarkdown()` —
+    // keep this set in sync with `ironLawsSkillMarkdown()` —
     // post-Phase A, only `stop-clean-or-handoff` is still hook-enforced
     // (Stop hook). All other iron laws live in stage HARD-GATE blocks.
     const enforcedLawIds = new Set([
@@ -351,8 +351,8 @@ Before responding to a coding request:
 
 Three rules apply to every cclaw stage in this project, regardless of which skills loaded:
 
-1. **Q&A convergence before drafting** — for brainstorm / scope / design, walk the stage forcing questions one at a time via the harness-native question tool (Claude \`AskUserQuestion\`, Cursor \`AskQuestion\`, Codex \`request_user_input\`, Gemini \`ask_user\`). The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence has not been reached. Convergence is satisfied when ANY of: (a) every forcing-question topic id is tagged \`[topic:<id>]\` in at least one \`## Q&A Log\` row, (b) the last 2 substantive rows produce no decision-changing impact (Ralph-Loop), or (c) an explicit user stop-signal row is recorded. The fixed count floor (10 for standard) was removed in Wave 23. Wave 24 (v6.0.0) made \`[topic:<id>]\` tagging mandatory (no English keyword fallback) so the gate works in any natural language.
-2. **Subagents run after Q&A approval** — mandatory subagents in brainstorm / scope / design (\`product-discovery\`, \`critic\`, \`planner\`, \`architect\`, \`test-author\`) run only AFTER the user approves the elicitation outcome. See each stage's "Run Phase: post-elicitation" rows in the materialized Automatic Subagent Dispatch table.
+1. **Q&A convergence before drafting** — for brainstorm / scope / design, walk the stage forcing questions one at a time via the harness-native question tool (Claude \`AskUserQuestion\`, Cursor \`AskQuestion\`, Codex \`request_user_input\`, Gemini \`ask_user\`). The \`qa_log_unconverged\` linter rule will block \`stage-complete\` when convergence has not been reached. Convergence is satisfied when ANY of: (a) every forcing-question topic id is tagged \`[topic:<id>]\` in at least one \`## Q&A Log\` row, (b) the last 2 substantive rows produce no decision-changing impact (Ralph-Loop), or (c) an explicit user stop-signal row is recorded. \`[topic:<id>]\` tagging is mandatory (no English keyword fallback) so the gate works in any natural language.
+2. **Subagents run after Q&A approval** — mandatory subagents in brainstorm / scope / design (\`product-discovery\`, \`critic\`, \`planner\`, \`architect\`) run only AFTER the user approves the elicitation outcome. See each stage's "Run Phase: post-elicitation" rows in the materialized Automatic Subagent Dispatch table.
 3. **No command-line echo to chat** — the user does not run cclaw helpers manually. Never paste \`node .cclaw/hooks/...\` invocations, \`--evidence-json '{...}'\` payloads, or shell hash commands (\`shasum\`, \`sha256sum\`, \`Get-FileHash\`, \`certutil\`, etc.) into chat. Run helpers via the tool layer; report only the resulting summary.
 
 ${ironLawsAgentsMdBlock()}
@@ -626,15 +626,15 @@ async function writeSkillKindShims(commandDir) {
     }
 }
 /**
- * Legacy codex surfaces cclaw wrote before v0.39.0 that Codex CLI never
+ * Legacy codex surfaces cclaw wrote before that Codex CLI never
  * consumed (`.codex/commands/*.md` had no discovery primitive). We keep
  * removing `.codex/commands/` on every sync so upgrades from those
- * installs leave a clean slate, but as of v0.40.0 we DO write
+ * installs leave a clean slate, but as of we DO write
  * `.codex/hooks.json` again — Codex CLI grew a real hooks API in
- * v0.114.0 (Mar 2026), and that file is the current, supported target.
+(Mar 2026), and that file is the current, supported target.
  *
  * This function also removes skill folders named after the old
- * `cclaw-cc*` scheme (v0.39.0 / v0.39.1) now that cclaw installs them
+ * `cclaw-cc*` scheme now that cclaw installs them
  * as plain `cc*`. Leaving them around would make Codex list two skills
  * for the same entry point.
  */
@@ -713,22 +713,23 @@ function enhancedAgentInstruction(agentName) {
     return `## Worker ACK Contract\n\nYou are the cclaw ${agentName} subagent. Follow the parent prompt as the task boundary. ACK first with JSON containing spanId, dispatchId or workerRunId, dispatchSurface, agentDefinitionPath, ackTs, and status: "ACK". Finish with the strict return schema plus the same spanId+dispatchId proof so the parent can append .cclaw/state/delegation-events.jsonl and .cclaw/state/delegation-log.json. Do not let the parent claim isolated completion without matching ACK/result proof. Do not recursively orchestrate other agents unless the parent explicitly asks.`;
 }
 async function syncAgentFiles(projectRoot, harnesses) {
+    const agents = CCLAW_AGENTS;
     const agentsDir = path.join(projectRoot, RUNTIME_ROOT, "agents");
     await ensureDir(agentsDir);
-    for (const agent of CCLAW_AGENTS) {
+    for (const agent of agents) {
         await writeFileSafe(path.join(agentsDir, `${agent.name}.md`), agentMarkdown(agent));
     }
     if (harnesses.includes("opencode")) {
         const opencodeAgentsDir = path.join(projectRoot, ".opencode/agents");
         await ensureDir(opencodeAgentsDir);
-        for (const agent of CCLAW_AGENTS) {
+        for (const agent of agents) {
             await writeFileSafe(path.join(opencodeAgentsDir, `${agent.name}.md`), opencodeAgentMarkdown(agent));
         }
     }
     if (harnesses.includes("codex")) {
         const codexAgentsDir = path.join(projectRoot, ".codex/agents");
         await ensureDir(codexAgentsDir);
-        for (const agent of CCLAW_AGENTS) {
+        for (const agent of agents) {
             await writeFileSafe(path.join(codexAgentsDir, `${agent.name}.toml`), codexAgentToml(agent));
         }
     }