cclaw-cli 0.48.35 → 0.51.0

package/dist/run-archive.js

@@ -2,7 +2,6 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
 import { createInitialFlowState } from "./flow-state.js";
-import { readActiveFeature, syncActiveFeatureSnapshot } from "./feature-system.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { readKnowledgeSafely } from "./knowledge-store.js";
 import { evaluateRetroGate } from "./retro-gate.js";
@@ -90,7 +89,7 @@ function toArchiveDate(date = new Date()) {
     const dd = date.getDate().toString().padStart(2, "0");
     return `${yyyy}-${mm}-${dd}`;
 }
-function slugifyFeatureName(value) {
+function slugifyRunName(value) {
     const slug = value
         .toLowerCase()
         .trim()
@@ -98,14 +97,14 @@ function slugifyFeatureName(value) {
         .replace(/^-+/u, "")
         .replace(/-+$/u, "");
     if (slug.length === 0) {
-        return "feature";
+        return "run";
     }
     return slug.slice(0, 64);
 }
-async function inferFeatureNameFromArtifacts(projectRoot) {
+async function inferRunNameFromArtifacts(projectRoot) {
     const ideaPath = path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH, "00-idea.md");
     if (!(await exists(ideaPath))) {
-        return "feature";
+        return "run";
     }
     try {
         const raw = await fs.readFile(ideaPath, "utf8");
@@ -114,12 +113,12 @@ async function inferFeatureNameFromArtifacts(projectRoot) {
             .map((line) => line.trim())
             .find((line) => line.length > 0);
         if (!firstMeaningful) {
-            return "feature";
+            return "run";
         }
-        return firstMeaningful.replace(/^[-#*\s]+/u, "").trim() || "feature";
+        return firstMeaningful.replace(/^[-#*\s]+/u, "").trim() || "run";
     }
     catch {
-        return "feature";
+        return "run";
     }
 }
 async function uniqueArchiveId(projectRoot, baseId) {
@@ -159,7 +158,7 @@ export async function listRuns(projectRoot) {
     }
     return runs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
-export async function archiveRun(projectRoot, featureName, options = {}) {
+export async function archiveRun(projectRoot, runName, options = {}) {
     await ensureRunSystem(projectRoot);
     // Hold BOTH archive.lock and flow-state.lock for the entire archive:
     // the outer archive lock serializes two concurrent archives; the
@@ -168,15 +167,14 @@ export async function archiveRun(projectRoot, featureName, options = {}) {
     // which used to cause lost-update races.
     return withDirectoryLock(archiveLockPath(projectRoot), async () => {
         return withDirectoryLock(flowStateLockPathFor(projectRoot), async () => {
-            const activeFeature = await readActiveFeature(projectRoot);
             const artifactsDir = activeArtifactsPath(projectRoot);
             const runsDir = runsRoot(projectRoot);
             await ensureDir(runsDir);
             await ensureDir(artifactsDir);
-            const feature = (featureName?.trim() && featureName.trim().length > 0)
-                ? featureName.trim()
-                : await inferFeatureNameFromArtifacts(projectRoot);
-            const archiveBaseId = `${toArchiveDate()}-${slugifyFeatureName(feature)}`;
+            const archiveRunName = (runName?.trim() && runName.trim().length > 0)
+                ? runName.trim()
+                : await inferRunNameFromArtifacts(projectRoot);
+            const archiveBaseId = `${toArchiveDate()}-${slugifyRunName(archiveRunName)}`;
             const archiveId = await uniqueArchiveId(projectRoot, archiveBaseId);
             const archivePath = path.join(runsDir, archiveId);
             const archiveArtifactsPath = path.join(archivePath, "artifacts");
@@ -256,11 +254,10 @@ export async function archiveRun(projectRoot, featureName, options = {}) {
                 stateReset = true;
                 await resetCarryoverStateFiles(projectRoot, resetState.activeRunId);
                 const manifest = {
-                    version: 1,
+                    version: 2,
                     archiveId,
                     archivedAt,
-                    featureName: feature,
-                    activeFeature,
+                    runName: archiveRunName,
                     sourceRunId: sourceState.activeRunId,
                     sourceCurrentStage: sourceState.currentStage,
                     sourceCompletedStages: sourceState.completedStages,
@@ -271,13 +268,11 @@ export async function archiveRun(projectRoot, featureName, options = {}) {
                 // Manifest landed — sentinel is no longer needed.
                 await fs.unlink(sentinelPath).catch(() => undefined);
                 const knowledgeStats = await readKnowledgeStats(projectRoot);
-                await syncActiveFeatureSnapshot(projectRoot);
                 return {
                     archiveId,
                     archivePath,
                     archivedAt,
-                    featureName: feature,
-                    activeFeature,
+                    runName: archiveRunName,
                     resetState,
                     snapshottedStateFiles,
                     knowledge: knowledgeStats,

package/dist/run-persistence.d.ts

@@ -21,8 +21,8 @@ export interface WriteFlowStateOptions {
 }
 export interface ReadFlowStateOptions {
     /**
-     * When false, skip feature-system auto-repair writes and read flow-state in
-     * pure diagnostic mode.
+     * Reserved compatibility switch from older runtimes. The repair layer was removed,
+     * so this flag is now a no-op and only preserved for API stability.
      */
     repairFeatureSystem?: boolean;
 }

package/dist/run-persistence.js

@@ -1,8 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
-import { canTransition, createInitialCloseoutState, createInitialFlowState, isFlowTrack, skippedStagesForTrack, SHIP_SUBSTATES } from "./flow-state.js";
-import { ensureFeatureSystem, syncActiveFeatureSnapshot } from "./feature-system.js";
+import { canTransition, createInitialCloseoutState, createInitialFlowState, FLOW_STATE_SCHEMA_VERSION, isFlowTrack, skippedStagesForTrack, SHIP_SUBSTATES } from "./flow-state.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 import { FLOW_STAGES } from "./types.js";
 export class InvalidStageTransitionError extends Error {
@@ -283,6 +282,7 @@ function coerceFlowState(parsed) {
         ? activeRunIdRaw.trim()
         : next.activeRunId;
     return {
+        schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
         currentStage: isFlowStage(parsed.currentStage) ? parsed.currentStage : next.currentStage,
         completedStages: sanitizeCompletedStages(parsed.completedStages),
@@ -334,9 +334,7 @@ async function quarantineCorruptState(statePath, cause) {
     throw new CorruptFlowStateError(statePath, quarantinedPath, cause);
 }
 export async function readFlowState(projectRoot, options = {}) {
-    if (options.repairFeatureSystem !== false) {
-        await ensureFeatureSystem(projectRoot);
-    }
+    void options;
     const statePath = flowStatePath(projectRoot);
     if (!(await exists(statePath))) {
         return createInitialFlowState();
@@ -361,7 +359,6 @@ export async function readFlowState(projectRoot, options = {}) {
     return coerceFlowState(parsed);
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
-    await ensureFeatureSystem(projectRoot);
     const doWrite = async () => {
         const statePath = flowStatePath(projectRoot);
         if (!options.allowReset && (await exists(statePath))) {
@@ -389,7 +386,6 @@ export async function writeFlowState(projectRoot, state, options = {}) {
     else {
         await withDirectoryLock(flowStateLockPath(projectRoot), doWrite);
     }
-    await syncActiveFeatureSnapshot(projectRoot);
 }
 /**
  * Exposed path helper so callers that need to serialize a multi-step
@@ -400,7 +396,6 @@ export function flowStateLockPathFor(projectRoot) {
     return flowStateLockPath(projectRoot);
 }
 export async function ensureRunSystem(projectRoot, _options = {}) {
-    await ensureFeatureSystem(projectRoot);
     await ensureDir(runsRoot(projectRoot));
     await ensureDir(activeArtifactsPath(projectRoot));
     const statePath = flowStatePath(projectRoot);
@@ -408,6 +403,5 @@ export async function ensureRunSystem(projectRoot, _options = {}) {
     if (!(await exists(statePath))) {
         await writeFlowState(projectRoot, state, { allowReset: true });
     }
-    await syncActiveFeatureSnapshot(projectRoot);
     return state;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.48.35",
+  "version": "0.51.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {
@@ -40,7 +40,6 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "openai": "^4.104.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {

package/dist/content/archive-command.d.ts

@@ -1,2 +0,0 @@
-export declare function archiveCommandContract(): string;
-export declare function archiveCommandSkillMarkdown(): string;

package/dist/content/archive-command.js

@@ -1,124 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-const ARCHIVE_SKILL_FOLDER = "flow-archive";
-const ARCHIVE_SKILL_NAME = "flow-archive";
-function flowStatePath() {
-    return `${RUNTIME_ROOT}/state/flow-state.json`;
-}
-function runsPath() {
-    return `${RUNTIME_ROOT}/runs`;
-}
-function activeArtifactsPath() {
-    return `${RUNTIME_ROOT}/artifacts`;
-}
-export function archiveCommandContract() {
-    return `# /cc-ops archive
-
-## Purpose
-
-Finalize the active cclaw run: move artifacts to \`${runsPath()}/<archive-id>\`,
-snapshot state, write a manifest, and reset runtime for the next run.
-
-Auto-triggered by \`/cc-next\` when \`closeout.shipSubstate === "ready_to_archive"\`.
-Direct invocation from a harness command is supported but rarely needed.
-
-## HARD-GATE
-
-- Do not archive with \`closeout.shipSubstate !== "ready_to_archive"\`.
-- Do not archive a shipped run when \`retro.completedAt\` is missing and
-  \`closeout.retroSkipped !== true\`.
-- Never hand-move files between \`${activeArtifactsPath()}\` and \`${runsPath()}\`.
-  Always run the archive runtime command so the snapshot+manifest stay
-  atomic.
-
-## Inputs
-
-\`/cc-ops archive [--name=<slug>]\`
-
-(Legacy flags \`--skip-retro --retro-reason=<text>\` still exist for CLI
-invocations; in-harness the skip path is driven by \`closeout.retroSkipped\`
-set during retro.)
-
-## Algorithm
-
-1. Read \`${flowStatePath()}\`.
-2. Verify \`closeout.shipSubstate === "ready_to_archive"\`. If not, report
-   \`closeout not ready (state=<substate>) | run: /cc-next\` and stop.
-3. Build archive command:
-   - base: \`npx cclaw archive\`,
-   - optional: \`--name=<slug>\`,
-   - legacy override: \`--skip-retro --retro-reason=<text>\` (only when user
-     explicitly wants the CLI skip path).
-4. Execute the archive command in project root.
-5. On success, flow-state is reset to the initial stage for the default
-   track; \`closeout.shipSubstate\` returns to \`"idle"\` on reset.
-6. Surface:
-   - archive id/path,
-   - reset stage,
-   - knowledge curation hint when \`activeEntryCount >= softThreshold\`.
-
-## Output format
-
-\`\`\`
-cclaw archive
-  status: archived
-  run: <archive-id>
-  path: .cclaw/runs/<archive-id>
-  next: /cc <new-idea>
-\`\`\`
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${ARCHIVE_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function archiveCommandSkillMarkdown() {
-    return `---
-name: ${ARCHIVE_SKILL_NAME}
-description: "Finalize the active cclaw run. Auto-triggered by /cc-next when shipSubstate=ready_to_archive."
----
-
-# /cc-ops archive
-
-## HARD-GATE
-
-Never simulate archive by hand-editing runtime files. Always execute the
-archive runtime command so state snapshots and manifest generation stay
-atomic. Never bypass the substate check — if retro/compound haven't
-advanced the substate to \`ready_to_archive\`, stop and surface the
-mismatch.
-
-## Protocol
-
-1. Read \`${flowStatePath()}\`:
-   - if \`closeout.shipSubstate !== "ready_to_archive"\`, stop and route
-     the user back to \`/cc-next\` (it will resume at the correct step),
-   - sanity-check: \`completedStages\` must include \`"ship"\`,
-   - sanity-check: \`retro.completedAt\` is set **or**
-     \`closeout.retroSkipped === true\` with a reason.
-2. Build shell command:
-   - \`npx cclaw archive\`,
-   - append \`--name=<slug>\` when provided,
-   - append legacy \`--skip-retro --retro-reason=<text>\` only when the user
-     explicitly requests the CLI skip path (normally not needed — skip is
-     captured in \`closeout\` during retro).
-3. Run command from repo root.
-4. Relay key lines from output:
-   - archive destination under \`${runsPath()}\`,
-   - flow reset confirmation,
-   - knowledge curation recommendation if \`activeEntryCount >= 50\`.
-
-## Resume semantics
-
-Archive is idempotent on a per-run basis. If a previous session ran
-archive successfully, the active artifacts directory is empty and
-\`closeout.shipSubstate\` is \`"idle"\`; \`/cc-next\` will simply report
-"Flow complete" or prompt for a new \`/cc\` input.
-
-## Validation
-
-- \`${runsPath()}\` contains a new archive folder for this run.
-- \`${activeArtifactsPath()}\` is reset for the next run.
-- \`${flowStatePath()}\` is valid JSON and points to the initial stage.
-- \`closeout.shipSubstate === "idle"\` after reset.
-`;
-}

package/dist/content/compound-command.d.ts

@@ -1,5 +0,0 @@
-export interface CompoundCommandOptions {
-    recurrenceThreshold?: number;
-}
-export declare function compoundCommandContract(options?: CompoundCommandOptions): string;
-export declare function compoundCommandSkillMarkdown(options?: CompoundCommandOptions): string;

package/dist/content/compound-command.js

@@ -1,193 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-const COMPOUND_SKILL_FOLDER = "flow-compound";
-const COMPOUND_SKILL_NAME = "flow-compound";
-const DEFAULT_RECURRENCE_THRESHOLD = 3;
-const SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD = 5;
-const SMALL_PROJECT_RECURRENCE_THRESHOLD = 2;
-function resolveRecurrenceThreshold(options) {
-    const threshold = options.recurrenceThreshold;
-    if (typeof threshold === "number" && Number.isInteger(threshold) && threshold >= 1) {
-        return threshold;
-    }
-    return DEFAULT_RECURRENCE_THRESHOLD;
-}
-export function compoundCommandContract(options = {}) {
-    const recurrenceThreshold = resolveRecurrenceThreshold(options);
-    return `# /cc-ops compound
-
-## Purpose
-
-Lift repeated lessons from \`${RUNTIME_ROOT}/knowledge.jsonl\` into durable
-project assets (rules, protocols, skills) so the next run is easier and safer.
-
-Auto-triggered by \`/cc-next\` when \`closeout.shipSubstate === "compound_review"\`.
-Direct invocation is supported but rarely needed.
-
-## HARD-GATE
-
-- Do not mutate rules/skills/protocols without explicit user approval.
-- Every proposal must cite concrete knowledge evidence (line refs or IDs).
-- Keep scope focused: one compound change set per run.
-- Do not block the archive step if no clusters qualify — record an empty
-  compound pass and advance.
-
-## Inputs
-
-\`/cc-ops compound\` (no flags). The structured ask presents candidates;
-the user can approve individual lifts, accept-all, or skip.
-
-## Algorithm
-
-1. Read \`${RUNTIME_ROOT}/knowledge.jsonl\` (strict JSONL, one entry per line).
-2. Cluster entries by \`trigger\` + \`action\` similarity.
-3. Resolve recurrence policy:
-   - base threshold = \`${recurrenceThreshold}\` (from \`config.compound.recurrenceThreshold\`),
-   - count archived runs under \`${RUNTIME_ROOT}/runs/\`,
-   - if archived run count is < ${SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD}, use
-     effective threshold = \`min(base threshold, ${SMALL_PROJECT_RECURRENCE_THRESHOLD})\` for this pass.
-4. Filter candidates that satisfy at least one trigger:
-   - recurrence count >= effective threshold, or
-   - any knowledge entry in the cluster has \`severity: "critical"\`
-     (critical override, recurrence can be 1).
-5. If **no candidates** exist:
-   - set \`closeout.compoundCompletedAt = <ISO>\`,
-   - set \`closeout.compoundPromoted = 0\`,
-   - set \`closeout.shipSubstate = "ready_to_archive"\`,
-   - emit \`compound: no candidates | next: /cc-next\` and stop.
-6. **Drift check** each surviving candidate before presenting it (see
-   "Drift check" section in the skill): confirm the lift target file is
-   current, spot-check the repo for contradictions, demote stale clusters
-   into a new superseding entry instead of a lift.
-7. Otherwise, present **one** structured ask via the harness's native ask
-   tool (\`AskUserQuestion\` / \`AskQuestion\` / \`question\` /
-   \`request_user_input\`; plain-text lettered list as fallback) summarising
-   all candidates at once:
-   - \`apply-all\` (default) — apply every listed lift,
-   - \`apply-selected\` — prompt per-candidate,
-   - \`skip\` — record a skip reason and advance without changes.
-8. Apply approved lifts to the target file(s). Each lift also appends a
-   \`type: "compound"\` entry back to \`${RUNTIME_ROOT}/knowledge.jsonl\`
-   summarising what was lifted.
-9. Update flow-state:
-   - \`closeout.compoundCompletedAt = <ISO>\`,
-   - \`closeout.compoundPromoted = <count>\`,
-   - \`closeout.compoundSkipped = true\` if user picked skip,
-   - \`closeout.shipSubstate = "ready_to_archive"\`.
-10. Emit one-line summary: \`compound: promoted=<N> skipped=<bool> | next: /cc-next\`.
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${COMPOUND_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function compoundCommandSkillMarkdown(options = {}) {
-    const recurrenceThreshold = resolveRecurrenceThreshold(options);
-    return `---
-name: ${COMPOUND_SKILL_NAME}
-description: "Lift repeated learnings into durable rules/protocols/skills. Auto-triggered after retro accept."
----
-
-# /cc-ops compound
-
-## Announce at start
-
-"Using flow-compound to lift repeated learnings into durable workflow assets."
-
-## HARD-GATE
-
-No silent codification. Every lift requires explicit user approval. An
-empty pass is allowed and must advance \`closeout.shipSubstate\` to
-\`"ready_to_archive"\`.
-
-## Protocol
-
-1. Parse \`.cclaw/knowledge.jsonl\` and group repeated lessons by
-   trigger+action similarity.
-2. Resolve recurrence policy:
-   - base threshold = \`${recurrenceThreshold}\` from \`config.compound.recurrenceThreshold\`,
-   - count archived runs under \`.cclaw/runs/\`,
-   - if archived run count is < ${SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD}, use
-     effective threshold = \`min(base threshold, ${SMALL_PROJECT_RECURRENCE_THRESHOLD})\` for this pass.
-3. Keep only candidates that meet at least one trigger:
-   - recurrence >= effective threshold and actionable lift path, or
-   - a cluster entry with \`severity: critical\` (critical override, recurrence can be 1).
-4. If none qualify, record an empty pass:
-   - \`closeout.compoundCompletedAt = <ISO>\`,
-   - \`closeout.compoundPromoted = 0\`,
-   - \`closeout.shipSubstate = "ready_to_archive"\`,
-   - announce \`compound: no candidates\` and stop.
-5. **Drift check — run before presenting any candidate.** Knowledge lines
-   are append-only, so textual repetition alone does not prove the rule is
-   still true. For every cluster that survives the recurrence filter:
-
-   - **Read the lift target.** Open the rule/protocol/skill file you would
-     edit. If the current contents already encode a stronger version of
-     the cluster's \`action\`, drop the candidate (nothing to lift).
-   - **Grep for contradictions.** Run a quick repo search on the cluster's
-     \`trigger\` keywords. If recent code or docs contradict the cluster,
-     treat the cluster as stale.
-   - **Check age.** Inspect \`last_seen_ts\` across the cluster's lines. If
-     every contributing line is older than ~90 days with no fresh
-     observation, treat the cluster as stale.
-   - **Handle stale clusters correctly.** Do **not** silently skip them.
-     Append a new superseding \`type: "lesson"\` line to
-     \`.cclaw/knowledge.jsonl\` whose \`trigger\` explicitly references the
-     old pattern (e.g. \`"when previous rule about X no longer holds: ..."\`)
-     and whose \`action\` documents the replacement or archive reason.
-     Then drop the candidate from the lift list.
-   - **Cite line IDs.** Every surviving candidate must list the concrete
-     knowledge line indices (1-based) that back it, not just a
-     summary string. This is what makes the lift auditable.
-   - **Include qualification reason.** Mark each candidate as
-     \`recurrence\` or \`critical_override\` so reviewers can see why it passed
-     the filter.
-   - Optionally invoke the \`knowledge-curation\` utility skill's
-     stale/duplicate/supersede heuristics if you want a second pass.
-
-6. Otherwise, render each candidate as:
-
-\`\`\`
-Candidate: <short title>
-Qualification: <recurrence|critical_override>
-Evidence: <knowledge line-ids>
-Freshness: <newest last_seen_ts among evidence lines>
-Lift target: <rule/protocol/skill file>
-Change type: <add/update/remove>
-Expected benefit: <what regressions this prevents>
-\`\`\`
-
-7. Present **one** structured question with three options:
-   - \`apply-all\` (default) — apply every candidate,
-   - \`apply-selected\` — prompt per-candidate approval next,
-   - \`skip\` — record a skip reason and advance.
-
-8. For approved candidates:
-   - edit the target file(s) with the lift,
-   - append a \`type: "compound"\` entry to \`.cclaw/knowledge.jsonl\`
-     describing what was promoted, including the source line IDs.
-
-9. Update flow-state \`closeout\`:
-   - \`compoundCompletedAt\`,
-   - \`compoundPromoted\` (count),
-   - \`compoundSkipped\` (boolean) + \`compoundSkipReason\` when applicable,
-   - \`shipSubstate = "ready_to_archive"\`.
-
-## Resume semantics
-
-A new session with \`shipSubstate === "compound_review"\` re-runs the scan
-and re-asks the structured question. If the user already applied lifts in
-a previous session but the state file was not updated, they should pick
-\`skip\` with reason \`already-applied\` — compound is idempotent from the
-closeout chain's perspective.
-
-## Validation
-
-- \`closeout.compoundCompletedAt\` is set.
-- \`closeout.shipSubstate === "ready_to_archive"\`.
-- If lifts were applied, the target files show the edit and at least one
-  new \`compound\` line exists in \`.cclaw/knowledge.jsonl\`, and the new
-  line references the source knowledge line IDs.
-- If drift check demoted any cluster, a new superseding \`lesson\` line
-  exists on the same run documenting the replacement.
-`;
-}

package/dist/content/contexts.d.ts

@@ -1,9 +0,0 @@
-export declare const DEFAULT_CONTEXT_MODE = "default";
-export declare const CONTEXT_MODES: Record<string, string>;
-export declare function contextModeFiles(): Record<string, string>;
-export interface ContextModeState {
-    activeMode: string;
-    updatedAt: string;
-    availableModes: string[];
-}
-export declare function createInitialContextModeState(nowIso?: string): ContextModeState;

package/dist/content/contexts.js

@@ -1,65 +0,0 @@
-export const DEFAULT_CONTEXT_MODE = "default";
-export const CONTEXT_MODES = {
-    default: `# Context Mode: default
-
-Use for most day-to-day feature work.
-
-## Focus
-- Follow the active cclaw stage strictly.
-- Keep changes within the current task blast radius.
-- Prefer incremental progress with frequent verification.
-
-## Decision posture
-- Escalate only meaningful trade-offs.
-- Ask for user confirmation only at explicit stage gates.
-`,
-    execution: `# Context Mode: execution
-
-Use when plan/spec are approved and the goal is high-throughput delivery.
-
-## Focus
-- Prioritize deterministic implementation flow (RED -> GREEN -> REFACTOR).
-- Minimize conversational overhead; keep updates concise and evidence-first.
-- Batch machine-only checks through subagent dispatch where supported.
-
-## Decision posture
-- Avoid reopening settled design debates unless a blocker appears.
-- Stop immediately on failing quality gates or unresolved critical findings.
-`,
-    review: `# Context Mode: review
-
-Use for deep validation, risk discovery, and merge readiness.
-
-## Focus
-- Bias toward finding concrete defects, regressions, and evidence gaps.
-- Cross-check spec, plan, tests, and implementation alignment.
-- Treat unsupported claims as unverified until backed by command output.
-
-## Decision posture
-- Classify findings by severity and expected blast radius.
-- Block ship decisions when critical issues remain unresolved.
-`,
-    incident: `# Context Mode: incident
-
-Use for production failures, emergency regressions, or urgent stabilization.
-
-## Focus
-- Reproduce first, then isolate, then fix.
-- Favor smallest safe change with rollback clarity.
-- Preserve timeline and evidence for post-incident learning.
-
-## Decision posture
-- Prefer containment over optimization.
-- Require explicit evidence for declaring recovery complete.
-`
-};
-export function contextModeFiles() {
-    return { ...CONTEXT_MODES };
-}
-export function createInitialContextModeState(nowIso = new Date().toISOString()) {
-    return {
-        activeMode: DEFAULT_CONTEXT_MODE,
-        updatedAt: nowIso,
-        availableModes: Object.keys(CONTEXT_MODES)
-    };
-}

package/dist/content/contracts.d.ts

@@ -1,2 +0,0 @@
-import type { FlowStage, FlowTrack } from "../types.js";
-export declare function stageCommandContract(stage: FlowStage, track?: FlowTrack): string;

package/dist/content/contracts.js

@@ -1,51 +0,0 @@
-import { stagePolicyNeedles, stageSchema } from "./stage-schema.js";
-import { stageSkillFolder } from "./skills.js";
-export function stageCommandContract(stage, track = "standard") {
-    const schema = stageSchema(stage, track);
-    const skillPath = `.cclaw/skills/${stageSkillFolder(stage)}/SKILL.md`;
-    const reads = schema.crossStageTrace.readsFrom;
-    const readsLine = reads.length > 0 ? reads.join(", ") : "(first stage)";
-    const hydrationLines = reads.length > 0
-        ? reads.map((readPath) => `- \`${readPath}\``).join("\n")
-        : "- (first stage — no upstream artifacts)";
-    const gateIds = schema.requiredGates
-        .map((g) => `\`${g.id}\``)
-        .join(", ");
-    const writes = schema.crossStageTrace.writesTo;
-    const writesLine = writes.map((w) => `\`${w}\``).join(", ");
-    const primaryArtifact = `.cclaw/artifacts/${schema.artifactFile}`;
-    const writeStepPaths = writes.length > 1
-        ? writes.map((w) => `\`${w}\``).join(" and ")
-        : `\`${primaryArtifact}\``;
-    const policyNeedles = stagePolicyNeedles(stage, track);
-    return `# /cc-${stage}
-
-Load and follow **${skillPath}** — it contains the full checklist, examples, interaction protocol, and verification discipline.
-
-## HARD-GATE
-${schema.hardGate}
-
-## In / Out
-- **Reads:** ${readsLine}
-- **Writes:** ${writesLine}
-- **Next:** \`/cc-next\` (updates flow-state and loads the next stage)
-
-## Context Hydration (mandatory before stage work)
-1. Read \`.cclaw/state/flow-state.json\`.
-2. Resolve active artifact root: \`.cclaw/artifacts/\`.
-3. Load required upstream artifacts for this stage:
-${hydrationLines}
-4. Stream \`.cclaw/knowledge.jsonl\` and apply relevant JSON-line entries (strict schema: type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project; optional: source, severity).
-5. Write stage output to ${writeStepPaths}.
-6. Do NOT copy artifacts into \`.cclaw/runs/\`; archival is handled by \`/cc-ops archive\` (agent-facing wrapper over archive runtime).
-
-## Gates
-${gateIds}
-
-## Exit
-${schema.exitCriteria.map((v) => `- ${v}`).join("\n")}
-
-## Anchors
-${policyNeedles.map((v) => `- ${v}`).join("\n")}
-`;
-}

package/dist/content/doctor-references.d.ts

@@ -1,2 +0,0 @@
-export declare const DOCTOR_REFERENCE_DIR = ".cclaw/references/doctor";
-export declare const DOCTOR_REFERENCE_MARKDOWN: Record<string, string>;