cclaw-cli 0.3.0 → 0.5.0

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

@@ -0,0 +1,10 @@
+/**
+ * Command contract for /cc — the unified entry point.
+ * No args → behaves like /cc-next (resume or start brainstorm).
+ * With prompt → starts brainstorm with the given idea.
+ */
+export declare function startCommandContract(): string;
+/**
+ * Skill body for /cc — the unified entry point.
+ */
+export declare function startCommandSkillMarkdown(): string;

package/dist/content/start-command.js

@@ -0,0 +1,109 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const START_SKILL_FOLDER = "flow-start";
+const START_SKILL_NAME = "flow-start";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+/**
+ * Command contract for /cc — the unified entry point.
+ * No args → behaves like /cc-next (resume or start brainstorm).
+ * With prompt → starts brainstorm with the given idea.
+ */
+export function startCommandContract() {
+    const flowPath = flowStatePath();
+    return `# /cc
+
+## Purpose
+
+**The unified entry point for the cclaw flow.**
+
+- \`/cc\` (no arguments) → behaves exactly like \`/cc-next\`: reads flow state and resumes the current stage, or starts brainstorm if the flow is fresh.
+- \`/cc <prompt>\` (with an idea/description) → saves the prompt as brainstorm context and begins the brainstorm stage, regardless of current flow state.
+
+This is the **recommended way to start** working with cclaw. Use \`/cc-next\` for subsequent stage progression.
+
+## HARD-GATE
+
+- **Do not** skip reading \`${flowPath}\` — always check current state before acting.
+- **Do not** start implementation stages directly from \`/cc <prompt>\` — always begin at brainstorm.
+
+## Algorithm
+
+### With prompt (\`/cc <text>\`)
+
+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.
+
+### Without prompt (\`/cc\`)
+
+1. Read \`${flowPath}\`.
+2. If flow state is missing → run \`cclaw init\` guidance and stop.
+3. Behave exactly like \`/cc-next\`: check current stage gates, resume if incomplete, advance if complete.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${START_SKILL_FOLDER}/SKILL.md**
+`;
+}
+/**
+ * Skill body for /cc — the unified entry point.
+ */
+export function startCommandSkillMarkdown() {
+    const flowPath = flowStatePath();
+    return `---
+name: ${START_SKILL_NAME}
+description: "Unified entry point for the cclaw flow. No args = resume/next. With prompt = start brainstorm with idea."
+---
+
+# /cc — Flow Entry Point
+
+## Overview
+
+\`/cc\` is the **starting command** for cclaw. It intelligently routes:
+
+- **No arguments** → acts as \`/cc-next\` (resume current stage or advance to next)
+- **With a prompt** → captures the idea and starts brainstorm
+
+## HARD-GATE
+
+Do **not** silently discard an existing flow when the user provides a prompt. If completed stages exist, inform and confirm before resetting.
+
+## Protocol
+
+### Path A: \`/cc <prompt>\`
+
+1. Read \`${flowPath}\`.
+2. If \`completedStages\` is non-empty:
+   - 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\`.
+
+### Path B: \`/cc\` (no arguments)
+
+Delegate entirely to \`/cc-next\` behavior:
+
+1. Read \`${flowPath}\`.
+2. Check gates for \`currentStage\`.
+3. If incomplete → load current stage skill and execute.
+4. If complete → advance to next stage and execute.
+5. If flow is done → report completion.
+
+## When to use \`/cc\` vs \`/cc-next\`
+
+| Scenario | Command |
+|---|---|
+| Starting work for the first time | \`/cc\` or \`/cc <idea>\` |
+| Resuming in a new session | \`/cc\` |
+| Progressing after completing a stage | \`/cc-next\` |
+| Starting with a specific idea | \`/cc <idea>\` |
+
+Both commands read the same \`flow-state.json\`. The difference is that \`/cc <prompt>\` always targets brainstorm, while \`/cc\` and \`/cc-next\` follow the state.
+`;
+}

package/dist/content/subagents.js

@@ -34,7 +34,7 @@ This pattern is intentionally **Superpowers-style**: cheap parallelism where it
 For cclaw flow stages, machine-only specialist work should auto-dispatch without waiting for a manual user request:
 
 - **design/plan:** planner
-- **test/build:** test-author
+- **tdd:** test-author
 - **review:** spec-reviewer + code-reviewer (security-reviewer when trust boundaries moved)
 - **ship:** doc-updater
 
@@ -295,7 +295,7 @@ Implementation that touches shared source trees must remain **sequential** unles
   - **3–4:** appendix / “worth tracking” section (not merge-blocking alone)
   - **1–2:** suppress from primary narrative unless paired with stronger evidence
 
-### Review Army Artifact Contract (required in /cc-review)
+### Review Army Artifact Contract (required in review stage via /cc-next)
 
 Write a structured reconciliation artifact at \`.cclaw/artifacts/07-review-army.json\` using this schema:
 
@@ -620,7 +620,7 @@ Status contract: DONE | DONE_WITH_CONCERNS | NEEDS_CONTEXT | BLOCKED.
 - Controller sequentially dispatches **implementer → reviewer** loops per task.
 - HARD-GATE: paste **self-contained task text**; never point subagents at plan files to “discover” scope.
 - **Spec fixers** are **fresh agents** after failed spec reviews — avoids parent-context pollution.
-- **Machine-only flow checks auto-dispatch** by stage (design/plan/test/build/review/ship) without asking the user to trigger each specialist manually.
+- **Machine-only flow checks auto-dispatch** by stage (design/plan/tdd/review/ship) without asking the user to trigger each specialist manually.
 
 ### Parallel Agents (\`dispatching-parallel-agents\` skill)
 

package/dist/content/templates.d.ts

@@ -1,4 +1,4 @@
 export declare const ARTIFACT_TEMPLATES: Record<string, string>;
-export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship\n- Require explicit user confirmation after /plan before /test or /build\n- Keep evidence artifacts in `.cclaw/artifacts/`\n- Enforce RED before GREEN in TDD\n- Run two-layer review (spec_compliance and code_quality) before ship\n- Validate all inputs before processing \u2014 never trust external data without sanitization\n- Prefer immutable data patterns and pure functions where the language supports them\n- Follow existing repo conventions, patterns, and directory structure \u2014 match the codebase\n- Verify claims with fresh evidence: \"tests pass\" requires running tests in this message\n- Use conventional commits: `type(scope): description` (feat, fix, refactor, test, docs, chore)\n\n## MUST_NEVER\n- Skip /test and jump directly to /build\n- Ship with critical review findings\n- Start implementation during /brainstorm\n- Modify generated cclaw files manually when CLI can regenerate them\n- Commit `.cclaw/` or generated shim files\n- Expose secrets, tokens, API keys, or absolute system paths in agent output\n- Duplicate existing functionality without explicit justification \u2014 search before building\n- Bypass security checks, linting hooks, or type checking to \"move faster\"\n- Claim success (\"Done,\" \"All good,\" \"Tests pass\") without running verification in this message\n- Make changes outside the blast radius of the current task without user consent\n\n## DELEGATION\nWhen a task requires specialist knowledge (security audit, performance profiling, database review),\ndelegate to a specialized agent or skill if the harness supports it. The primary agent should:\n1. Identify the specialist domain\n2. Provide focused context (relevant files, the specific concern)\n3. Evaluate the specialist output before acting on it \u2014 do not blindly apply recommendations\n";
-export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship.\n- Read `.cclaw/state/flow-state.json` before acting; continue from current stage when active.\n- Use `/cc-next` only after required gates pass; never bypass explicit pause/approval rules.\n- Keep evidence in `.cclaw/artifacts/` and canonical run copies in `.cclaw/runs/<activeRunId>/artifacts/`.\n- For machine-only checks in design/plan/test/build/review/ship, dispatch required specialists automatically when tooling supports it.\n- Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).\n- Treat `.cclaw/skills/using-cclaw/SKILL.md` as routing source of truth; load contextual utility skills only when their triggers apply.\n";
+export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship\n- Require explicit user confirmation after plan before TDD\n- Keep evidence artifacts in `.cclaw/artifacts/`\n- Enforce RED before GREEN in TDD\n- Run two-layer review (spec_compliance and code_quality) before ship\n- Validate all inputs before processing \u2014 never trust external data without sanitization\n- Prefer immutable data patterns and pure functions where the language supports them\n- Follow existing repo conventions, patterns, and directory structure \u2014 match the codebase\n- Verify claims with fresh evidence: \"tests pass\" requires running tests in this message\n- Use conventional commits: `type(scope): description` (feat, fix, refactor, test, docs, chore)\n\n## MUST_NEVER\n- Skip RED phase and jump directly to GREEN in TDD\n- Ship with critical review findings\n- Start implementation during /brainstorm\n- Modify generated cclaw files manually when CLI can regenerate them\n- Commit `.cclaw/` or generated shim files\n- Expose secrets, tokens, API keys, or absolute system paths in agent output\n- Duplicate existing functionality without explicit justification \u2014 search before building\n- Bypass security checks, linting hooks, or type checking to \"move faster\"\n- Claim success (\"Done,\" \"All good,\" \"Tests pass\") without running verification in this message\n- Make changes outside the blast radius of the current task without user consent\n\n## DELEGATION\nWhen a task requires specialist knowledge (security audit, performance profiling, database review),\ndelegate to a specialized agent or skill if the harness supports it. The primary agent should:\n1. Identify the specialist domain\n2. Provide focused context (relevant files, the specific concern)\n3. Evaluate the specialist output before acting on it \u2014 do not blindly apply recommendations\n";
+export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship.\n- Read `.cclaw/state/flow-state.json` before acting; continue from current stage when active.\n- Use `/cc-next` only after required gates pass; never bypass explicit pause/approval rules.\n- Keep evidence in `.cclaw/artifacts/` and canonical run copies in `.cclaw/runs/<activeRunId>/artifacts/`.\n- For machine-only checks in design/plan/tdd/review/ship, dispatch required specialists automatically when tooling supports it.\n- Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).\n- Treat `.cclaw/skills/using-cclaw/SKILL.md` as routing source of truth; load contextual utility skills only when their triggers apply.\n";
 export declare function buildRulesJson(): Record<string, unknown>;

package/dist/content/templates.js

@@ -292,8 +292,8 @@ Execution rule: complete and verify each wave before starting the next wave.
 export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook
 
 ## MUST_ALWAYS
-- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship
-- Require explicit user confirmation after /plan before /test or /build
+- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship
+- Require explicit user confirmation after plan before TDD
 - Keep evidence artifacts in \`.cclaw/artifacts/\`
 - Enforce RED before GREEN in TDD
 - Run two-layer review (spec_compliance and code_quality) before ship
@@ -304,7 +304,7 @@ export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook
 - Use conventional commits: \`type(scope): description\` (feat, fix, refactor, test, docs, chore)
 
 ## MUST_NEVER
-- Skip /test and jump directly to /build
+- Skip RED phase and jump directly to GREEN in TDD
 - Ship with critical review findings
 - Start implementation during /brainstorm
 - Modify generated cclaw files manually when CLI can regenerate them
@@ -333,11 +333,11 @@ alwaysApply: true
 
 # Cclaw Workflow Guardrails
 
-- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> test -> build -> review -> ship.
+- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship.
 - Read \`.cclaw/state/flow-state.json\` before acting; continue from current stage when active.
 - Use \`/cc-next\` only after required gates pass; never bypass explicit pause/approval rules.
 - Keep evidence in \`.cclaw/artifacts/\` and canonical run copies in \`.cclaw/runs/<activeRunId>/artifacts/\`.
-- For machine-only checks in design/plan/test/build/review/ship, dispatch required specialists automatically when tooling supports it.
+- For machine-only checks in design/plan/tdd/review/ship, dispatch required specialists automatically when tooling supports it.
 - Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).
 - Treat \`.cclaw/skills/using-cclaw/SKILL.md\` as routing source of truth; load contextual utility skills only when their triggers apply.
 `;

package/dist/content/utility-skills.js

@@ -26,7 +26,7 @@ Do not approve code with known Critical security issues. No exceptions.
 - Before shipping any user-facing feature
 - When adding authentication, authorization, or secrets handling
 - When handling user input, file uploads, or external API data
-- During the review stage (\`/cc-review\`) as a specialist lens
+- During the review stage (entered via \`/cc-next\`) as a specialist lens
 - When the security-reviewer agent persona is activated
 
 ## Checklist
@@ -534,7 +534,7 @@ Do not keep stale or oversized context loaded when task intent changes. Context
 
 Modes are stored in \`.cclaw/contexts/\`:
 - \`default\` — balanced execution
-- \`execution\` — fast plan/test/build throughput
+- \`execution\` — fast plan/tdd throughput
 - \`review\` — defect/risk discovery
 - \`incident\` — stabilization and recovery
 

package/dist/doctor.js

@@ -304,23 +304,12 @@ export async function doctorChecks(projectRoot, options = {}) {
             });
             continue;
         }
-        for (const stage of COMMAND_FILE_ORDER) {
-            const shimPath = path.join(projectRoot, adapter.commandDir, `cc-${stage}.md`);
-            let shimOk = await exists(shimPath);
-            let details = shimPath;
-            if (shimOk) {
-                const content = await fs.readFile(shimPath, "utf8");
-                const hasSkillReference = content.includes(`.cclaw/skills/${stageSkillFolder(stage)}/SKILL.md`);
-                const hasCommandReference = content.includes(`.cclaw/commands/${stage}.md`);
-                shimOk = hasSkillReference && hasCommandReference;
-                details = hasSkillReference && hasCommandReference
-                    ? `${shimPath} aligned`
-                    : `${shimPath} missing stage references`;
-            }
+        for (const shim of ["cc.md", "cc-next.md", "cc-learn.md"]) {
+            const shimPath = path.join(projectRoot, adapter.commandDir, shim);
             checks.push({
-                name: `shim:${harness}:${stage}`,
-                ok: shimOk,
-                details
+                name: `shim:${harness}:${shim.replace(".md", "")}`,
+                ok: await exists(shimPath),
+                details: shimPath
             });
         }
     }
@@ -329,12 +318,13 @@ export async function doctorChecks(projectRoot, options = {}) {
     if (await exists(agentsFile)) {
         const content = await fs.readFile(agentsFile, "utf8");
         const hasMarkers = content.includes(CCLAW_MARKER_START) && content.includes(CCLAW_MARKER_END);
-        const hasAllCommands = COMMAND_FILE_ORDER.every((stage) => content.includes(`/cc-${stage}`));
-        const hasRouting = content.includes("Intent → Stage Routing") || content.includes("Intent → Stage");
+        const hasCcCommand = content.includes("/cc");
+        const hasCcNext = content.includes("/cc-next");
+        const hasCcLearn = content.includes("/cc-learn");
         const hasVerification = content.includes("Verification Discipline");
         const hasMinimalMarker = content.includes("intentionally minimal for cross-project use");
         const hasMetaSkillPointer = content.includes(".cclaw/skills/using-cclaw/SKILL.md");
-        agentsBlockOk = hasMarkers && hasAllCommands && hasRouting && hasVerification && hasMinimalMarker && hasMetaSkillPointer;
+        agentsBlockOk = hasMarkers && hasCcCommand && hasCcNext && hasCcLearn && hasVerification && hasMinimalMarker && hasMetaSkillPointer;
     }
     checks.push({
         name: "agents:cclaw_block",
@@ -342,7 +332,7 @@ export async function doctorChecks(projectRoot, options = {}) {
         details: `${agentsFile} must contain the managed cclaw marker block with routing, verification, and minimal detail pointer`
     });
     // Utility commands
-    for (const cmd of ["learn", "autoplan"]) {
+    for (const cmd of ["learn"]) {
         const cmdPath = path.join(projectRoot, RUNTIME_ROOT, "commands", `${cmd}.md`);
         checks.push({
             name: `utility_command:${cmd}`,
@@ -353,7 +343,6 @@ export async function doctorChecks(projectRoot, options = {}) {
     // Utility skills
     for (const [folder, label] of [
         ["learnings", "learnings"],
-        ["autoplan", "autoplan"],
         ["subagent-dev", "sdd"],
         ["parallel-dispatch", "parallel-agents"],
         ["session", "session"],
@@ -782,26 +771,6 @@ export async function doctorChecks(projectRoot, options = {}) {
             ? `stage "${gateEvidence.stage}" gate evidence is consistent (required=${gateEvidence.requiredCount}, passed=${gateEvidence.passedCount}, blocked=${gateEvidence.blockedCount})`
             : gateEvidence.issues.join(" ")
     });
-    // Utility shims in harness dirs
-    for (const harness of configuredHarnesses) {
-        const adapter = HARNESS_ADAPTERS[harness];
-        if (!adapter) {
-            checks.push({
-                name: `harness:${harness}:supported`,
-                ok: false,
-                details: `Unsupported harness "${harness}" in ${RUNTIME_ROOT}/config.yaml`
-            });
-            continue;
-        }
-        for (const cmd of ["learn", "autoplan"]) {
-            const shimPath = path.join(projectRoot, adapter.commandDir, `cc-${cmd}.md`);
-            checks.push({
-                name: `shim:${harness}:${cmd}`,
-                ok: await exists(shimPath),
-                details: shimPath
-            });
-        }
-    }
     // Self-improvement block in stage skills
     for (const stage of COMMAND_FILE_ORDER) {
         const skillPath = path.join(projectRoot, RUNTIME_ROOT, "skills", stageSkillFolder(stage), "SKILL.md");

package/dist/harness-adapters.js

@@ -1,8 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { COMMAND_FILE_ORDER, RUNTIME_ROOT } from "./constants.js";
+import { RUNTIME_ROOT } from "./constants.js";
 import { CCLAW_AGENTS, agentMarkdown } from "./content/agents.js";
-import { stageSkillFolder } from "./content/skills.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 export const CCLAW_MARKER_START = "<!-- cclaw-start -->";
 export const CCLAW_MARKER_END = "<!-- cclaw-end -->";
@@ -18,30 +17,7 @@ export const HARNESS_ADAPTERS = {
     opencode: { id: "opencode", commandDir: ".opencode/commands" },
     codex: { id: "codex", commandDir: ".codex/commands" }
 };
-function shimFileName(stage) {
-    return `cc-${stage}.md`;
-}
-function shimContent(harness, stage) {
-    const skillFolder = stageSkillFolder(stage);
-    return `---
-name: cc-${stage}
-description: Generated shim for ${harness}. Runs one flow stage with command+skill context.
-source: generated-by-cclaw
----
-
-# cclaw ${stage}
-
-Load and execute:
-1. \`.cclaw/skills/${skillFolder}/SKILL.md\`
-2. \`.cclaw/commands/${stage}.md\`
-
-This command is stage-scoped: do only this stage and then hand off to the next one.
-Use \`.cclaw/state/flow-state.json\` for transition guards and status tracking.
-Do not skip required handoff gates.
-`;
-}
 function agentsMdBlock() {
-    const stageList = COMMAND_FILE_ORDER.map((s) => `| \`/cc-${s}\` | \`.cclaw/skills/${stageSkillFolder(s)}/SKILL.md\` + \`.cclaw/commands/${s}.md\` |`).join("\n");
     return `${CCLAW_MARKER_START}
 ## Cclaw — Workflow Adapter
 
@@ -52,20 +28,19 @@ function agentsMdBlock() {
 
 Before responding to a coding request:
 1. Read \`.cclaw/state/flow-state.json\` for the current stage.
-2. If a stage applies, invoke the matching \`/cc-*\` command.
+2. Use \`/cc\` to start or \`/cc-next\` to continue the flow.
 3. If no stage applies, respond normally.
 
-### Intent → Stage Routing
+### Commands (3 total)
 
-| Command | Loads |
+| Command | Purpose |
 |---|---|
-${stageList}
-| \`/cc-learn\` | \`.cclaw/skills/learnings/SKILL.md\` + \`.cclaw/commands/learn.md\` |
-| \`/cc-autoplan\` | \`.cclaw/skills/autoplan/SKILL.md\` + \`.cclaw/commands/autoplan.md\` |
-| \`/cc-next\` | \`.cclaw/skills/flow-next-step/SKILL.md\` + \`.cclaw/commands/next.md\` |
+| \`/cc\` | **Entry point.** No args = resume current stage. With prompt = start brainstorm with idea. |
+| \`/cc-next\` | **Progression.** Advances to the next stage when current is complete. |
+| \`/cc-learn\` | **Cross-cutting.** Capture or review project learnings. |
 
-**Stage order:** brainstorm > scope > design > spec > plan > test > build > review > ship.
-One stage per invocation. Gates must pass before handoff.
+**Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
+\`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.
 
 ### Verification Discipline
 
@@ -115,8 +90,9 @@ export async function removeCclawFromAgentsMd(projectRoot) {
     }
 }
 function utilityShimContent(harness, command, skillFolder, commandFile) {
+    const shimName = command === "cc" ? "cc" : `cc-${command}`;
     return `---
-name: cc-${command}
+name: ${shimName}
 description: Generated shim for ${harness}. Utility command — not a flow stage.
 source: generated-by-cclaw
 ---
@@ -145,14 +121,9 @@ export async function syncHarnessShims(projectRoot, harnesses) {
         }
         const commandDir = path.join(projectRoot, adapter.commandDir);
         await ensureDir(commandDir);
-        for (const stage of COMMAND_FILE_ORDER) {
-            const fullPath = path.join(commandDir, shimFileName(stage));
-            await writeFileSafe(fullPath, shimContent(harness, stage));
-        }
-        // Utility command shims
-        await writeFileSafe(path.join(commandDir, "cc-learn.md"), utilityShimContent(harness, "learn", "learnings", "learn.md"));
-        await writeFileSafe(path.join(commandDir, "cc-autoplan.md"), utilityShimContent(harness, "autoplan", "autoplan", "autoplan.md"));
+        await writeFileSafe(path.join(commandDir, "cc.md"), utilityShimContent(harness, "cc", "flow-start", "start.md"));
         await writeFileSafe(path.join(commandDir, "cc-next.md"), utilityShimContent(harness, "next", "flow-next-step", "next.md"));
+        await writeFileSafe(path.join(commandDir, "cc-learn.md"), utilityShimContent(harness, "learn", "learnings", "learn.md"));
     }
     await syncAgentFiles(projectRoot);
     await syncAgentsMd(projectRoot);

package/dist/install.js

@@ -6,10 +6,10 @@ import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT, UTILITY_COMMANDS } from "./constants.js";
 import { writeConfig, createDefaultConfig, readConfig, configPath } from "./config.js";
 import { commandContract } from "./content/contracts.js";
-import { autoplanSkillMarkdown, autoplanCommandContract } from "./content/autoplan.js";
 import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
+import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
@@ -192,8 +192,8 @@ async function writeSkills(projectRoot) {
     }
     // Utility skills (not flow stages)
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());
-    await writeFileSafe(runtimePath(projectRoot, "skills", "autoplan", "SKILL.md"), autoplanSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-start", "SKILL.md"), startCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "parallel-dispatch", "SKILL.md"), parallelAgentsSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
@@ -205,8 +205,8 @@ async function writeSkills(projectRoot) {
 }
 async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
-    await writeFileSafe(runtimePath(projectRoot, "commands", "autoplan.md"), autoplanCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "start.md"), startCommandContract());
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -688,6 +688,9 @@ async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of [
         "project-learnings",
         "auto-orchestration",
+        "autoplan",
+        "red-first-testing",
+        "incremental-implementation",
         "subagent-driven-development",
         "dispatching-parallel-agents",
         "session-guidelines",
@@ -730,7 +733,8 @@ async function cleanStaleFiles(projectRoot) {
         ...COMMAND_FILE_ORDER.map((stage) => `viby-${stage}.md`),
         ...UTILITY_COMMANDS.map((cmd) => `viby-${cmd}.md`),
         ...COMMAND_FILE_ORDER.map((stage) => `cc-${stage}.md`),
-        ...UTILITY_COMMANDS.map((cmd) => `cc-${cmd}.md`)
+        ...UTILITY_COMMANDS.map((cmd) => `cc-${cmd}.md`),
+        "cc.md"
     ]);
     for (const adapter of Object.values(HARNESS_ADAPTERS)) {
         const commandDir = path.join(projectRoot, adapter.commandDir);
@@ -744,7 +748,7 @@ async function cleanStaleFiles(projectRoot) {
             entries = [];
         }
         for (const entry of entries) {
-            if (!/^cc-.*\.md$/u.test(entry))
+            if (!/^cc(?:-.*)?\.md$/u.test(entry))
                 continue;
             if (expectedShimFiles.has(entry))
                 continue;
@@ -930,7 +934,7 @@ export async function uninstallCclaw(projectRoot) {
         try {
             const entries = await fs.readdir(fullDir);
             for (const entry of entries) {
-                if (/^(?:viby|cc)-.*\.md$/u.test(entry)) {
+                if (/^(?:viby|cc)(?:-.*)?\.md$/u.test(entry)) {
                     await fs.rm(path.join(fullDir, entry), { force: true });
                 }
             }

package/dist/policy.js

@@ -66,7 +66,7 @@ export async function policyChecks(projectRoot, options = {}) {
             });
         }
         // --- verification section for build/review/ship skills ---
-        if (["build", "review", "ship"].includes(stage)) {
+        if (["tdd", "review", "ship"].includes(stage)) {
             rules.push({
                 filePath: skillFile,
                 needle: "## Verification Before Completion",
@@ -89,16 +89,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Subcommands", name: "utility_skill:learnings:subcommands" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Confidence Decay", name: "utility_skill:learnings:decay" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "## Phase Sequence", name: "utility_skill:autoplan:phases" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "Decision Principles", name: "utility_skill:autoplan:principles" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "## Decision Taxonomy", name: "utility_skill:autoplan:taxonomy" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:autoplan:hard_gate" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "## Restore Points", name: "utility_skill:autoplan:restore_points" },
-        { file: runtimeFile("skills/autoplan/SKILL.md"), needle: "## Scope Mode Heuristics (Phase 2)", name: "utility_skill:autoplan:scope_heuristics" },
         { file: runtimeFile("commands/learn.md"), needle: "## Subcommands", name: "utility_command:learn:subcommands" },
-        { file: runtimeFile("commands/autoplan.md"), needle: "## Phase Sequence", name: "utility_command:autoplan:phases" },
-        { file: runtimeFile("commands/autoplan.md"), needle: "## Decision Principles", name: "utility_command:autoplan:principles" },
-        { file: runtimeFile("commands/autoplan.md"), needle: "## Scope Mode Heuristics (Phase 2)", name: "utility_command:autoplan:scope_heuristics" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Status Contract", name: "utility_skill:sdd:status_contract" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "Implementer", name: "utility_skill:sdd:implementer_template" },

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export declare const FLOW_STAGES: readonly ["brainstorm", "scope", "design", "spec", "plan", "test", "build", "review", "ship"];
+export declare const FLOW_STAGES: readonly ["brainstorm", "scope", "design", "spec", "plan", "tdd", "review", "ship"];
 export type FlowStage = (typeof FLOW_STAGES)[number];
 export declare const HARNESS_IDS: readonly ["claude", "cursor", "opencode", "codex"];
 export type HarnessId = (typeof HARNESS_IDS)[number];

package/dist/types.js

@@ -4,8 +4,7 @@ export const FLOW_STAGES = [
     "design",
     "spec",
     "plan",
-    "test",
-    "build",
+    "tdd",
     "review",
     "ship"
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {

package/dist/content/autoplan.d.ts

@@ -1,7 +0,0 @@
-/**
- * Autoplan orchestrator content for cclaw.
- * Generates markdown instructions that AI agents follow; cclaw does not execute the pipeline.
- */
-export declare function autoplanSkillMarkdown(): string;
-export declare function autoplanCommandContract(): string;
-export declare function autoplanAgentsMdBlock(): string;