cclaw-cli 0.48.35 → 0.51.0

package/dist/content/retro-command.js

@@ -1,165 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-const RETRO_SKILL_FOLDER = "flow-retro";
-const RETRO_SKILL_NAME = "flow-retro";
-function flowStatePath() {
-    return `${RUNTIME_ROOT}/state/flow-state.json`;
-}
-function retroArtifactPath() {
-    return `${RUNTIME_ROOT}/artifacts/09-retro.md`;
-}
-function knowledgePath() {
-    return `${RUNTIME_ROOT}/knowledge.jsonl`;
-}
-export function retroCommandContract() {
-    return `# /cc-ops retro
-
-## Purpose
-
-Auto-triggered retrospective after ship. \`/cc-next\` drafts \`${retroArtifactPath()}\`
-from run artifacts and knowledge, then asks the user exactly ONE structured
-question: **edit / accept / skip / rewind_for_fix**. Default = accept.
-
-This command is normally invoked indirectly by \`/cc-next\` when
-\`closeout.shipSubstate === "retro_review"\`. Invoking it directly is still
-supported for manual re-runs.
-
-## HARD-GATE
-
-- Do not finalize retro without \`${retroArtifactPath()}\` on disk (or an explicit
-  \`retroSkipped: true\` in closeout with a one-line reason).
-- Do not finalize without appending **at least one** \`type=compound\` entry to
-  \`${knowledgePath()}\` (skipped runs set \`compoundEntries: 0\` instead).
-- Never advance to compound/archive with \`shipSubstate\` still at
-  \`"retro_review"\`.
-
-## Inputs
-
-\`/cc-ops retro\` (no flags). If the user wants to skip, they answer **skip**
-in the structured ask; there is no \`--skip\` flag.
-
-## Algorithm
-
-1. Read \`${flowStatePath()}\`; confirm \`completedStages\` contains \`"ship"\`.
-2. If \`closeout.shipSubstate !== "retro_review"\`, and \`retro.completedAt\`
-   is already set, report "retro already complete" and stop.
-3. Draft \`${retroArtifactPath()}\` from available evidence:
-   - scan \`.cclaw/artifacts/01..08-*.md\` for decisions, blockers, rewinds,
-   - scan \`.cclaw/state/delegation-log.json\` for subagent outcomes,
-   - scan \`${knowledgePath()}\` for entries recorded during this run,
-   - structure the draft as: Outcomes / Slowed / Accelerated / Repeatable rule.
-4. Update \`closeout.retroDraftedAt = <ISO>\` in flow-state.
-5. Present **one** structured ask using the harness's native tool
-   (\`AskUserQuestion\` on Claude, \`AskQuestion\` on Cursor, \`question\` on
-   OpenCode when \`permission.question: "allow"\` is set,
-   \`request_user_input\` on Codex in Plan / Collaboration mode; fall back
-   to a plain-text lettered list when the tool is hidden or errors):
-   - \`accept\` (default) — keep the draft as-is,
-   - \`edit\` — user edits \`${retroArtifactPath()}\` in-place, then re-runs \`/cc-next\`,
-   - \`skip\` — record \`retroSkipped: true\` + one-line reason, no compound entry required,
-   - \`rewind_for_fix\` — route back to \`plan\` / \`tdd\` / \`review\` with a non-empty reason.
-6. On **accept**:
-   - append >=1 strict-schema JSONL line to \`${knowledgePath()}\` with
-     \`type: "compound"\`, \`source: "retro"\`, and \`stage: null\`,
-   - set \`retro.required = true\`, \`retro.completedAt = <ISO>\`,
-     \`retro.compoundEntries = <count>\`,
-   - set \`closeout.retroAcceptedAt = <ISO>\`,
-   - set \`closeout.shipSubstate = "compound_review"\`.
-7. On **edit**:
-   - leave \`shipSubstate = "retro_review"\`,
-   - tell user to edit \`${retroArtifactPath()}\` and run \`/cc-next\` again.
-8. On **skip**:
-   - require a one-line reason; if empty, re-ask once then escalate,
-   - set \`closeout.retroSkipped = true\`, \`closeout.retroSkipReason = <text>\`,
-     \`closeout.retroAcceptedAt = <ISO>\`,
-   - set \`retro.completedAt = <ISO>\` (marks gate satisfied for archive), and
-     \`retro.compoundEntries = 0\`,
-   - set \`closeout.shipSubstate = "compound_review"\`.
-9. On **rewind_for_fix**:
-   - require \`targetStage\` in \`{ plan, tdd, review }\`,
-   - require a concise rationale (min 20 chars),
-   - instruct \`/cc-ops rewind <targetStage> "<reason>"\`,
-   - reset closeout progression by setting \`closeout.shipSubstate = "idle"\`.
-10. Emit a one-line summary: \`retro: accepted|edited|skipped|rewind_for_fix | next: /cc-next\`.
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${RETRO_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function retroCommandSkillMarkdown() {
-    return `---
-name: ${RETRO_SKILL_NAME}
-description: "Auto-drafted retrospective with a single structured accept/edit/skip/rewind_for_fix ask. Triggered from /cc-next when shipSubstate=retro_review."
----
-
-# /cc-ops retro
-
-## HARD-GATE
-
-Archive stays blocked until one of:
-- retro artifact exists **and** one compound knowledge entry was appended, OR
-- retro was explicitly skipped with a one-line reason recorded in closeout.
-
-Do not silently skip. Do not finalize without updating \`flow-state.json\`.
-
-## Protocol
-
-1. Confirm ship completion by reading \`${flowStatePath()}\`.
-2. If retro draft does not yet exist, synthesise \`${retroArtifactPath()}\` using:
-   - all \`.cclaw/artifacts/*-*.md\` from the active run (stages 01–08),
-   - \`.cclaw/state/delegation-log.json\` entries,
-   - \`${knowledgePath()}\` entries written during this run.
-   Draft sections:
-   - **Outcomes** — what was actually shipped.
-   - **Slowed** — concrete friction points (cite artifact line or delegation id).
-   - **Accelerated** — patterns/decisions that worked and are worth keeping.
-   - **Repeatable rule** — one candidate rule/pattern for next run.
-   Record \`closeout.retroDraftedAt\`.
-3. Ask the user **one** structured question via the harness's native
-   ask tool (\`AskUserQuestion\` / \`AskQuestion\` / \`question\` /
-   \`request_user_input\`; plain-text lettered list as fallback):
-
-   > Retro draft ready at \`${retroArtifactPath()}\`. How do you want to
-   > proceed? (default: accept)
-   >
-   > - **accept** — keep the draft and continue.
-   > - **edit** — I'll edit it, then re-run \`/cc-next\`.
-   > - **skip** — no retro this run (requires one-line reason).
-   > - **rewind_for_fix** — route back to plan/tdd/review because post-ship issues were found.
-
-4. Apply the state transition for the chosen option:
-   - \`accept\` → append \`{ "type": "compound", "source": "retro", "stage": null, ... }\` line
-     to \`${knowledgePath()}\`; set \`retro.completedAt\`, \`retro.compoundEntries\`,
-     \`closeout.retroAcceptedAt\`; set \`closeout.shipSubstate = "compound_review"\`.
-   - \`edit\` → leave \`shipSubstate = "retro_review"\`; announce resume path.
-   - \`skip\` → set \`closeout.retroSkipped\`, \`closeout.retroSkipReason\`,
-     \`closeout.retroAcceptedAt\`, \`retro.completedAt\`,
-     \`retro.compoundEntries = 0\`; set \`closeout.shipSubstate = "compound_review"\`.
-   - \`rewind_for_fix\` → require \`targetStage ∈ {plan,tdd,review}\` and
-     reason (>=20 chars), then instruct \`/cc-ops rewind <targetStage> "<reason>"\`
-     and set \`closeout.shipSubstate = "idle"\` to restart closeout after rework.
-
-5. Print one-line completion summary:
-   - \`retro gate: accepted (<N> compound entries)\`
-   - \`retro gate: skipped (reason: <text>)\`
-   - \`retro gate: editing (re-run /cc-next when ready)\`
-   - \`retro gate: rewind_for_fix (target=<stage>)\`
-
-## Resume semantics
-
-A new session with \`closeout.shipSubstate === "retro_review"\` resumes
-exactly here. If \`closeout.retroDraftedAt\` is present but
-\`retroAcceptedAt\` is missing, re-ask the same structured question without
-regenerating the draft.
-
-## Validation
-
-- \`${retroArtifactPath()}\` exists and is non-empty, **or**
-  \`closeout.retroSkipped === true\` with a non-empty reason.
-- When accepted: \`${knowledgePath()}\` gained a valid \`compound\` line
-  and \`retro.compoundEntries > 0\`.
-- \`retro.completedAt\` is set.
-- \`closeout.shipSubstate\` is \`"compound_review"\` (or still
-  \`"retro_review"\` when user picked \`edit\`).
-`;
-}

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

@@ -1,2 +0,0 @@
-export declare function rewindCommandContract(): string;
-export declare function rewindCommandSkillMarkdown(): string;

package/dist/content/rewind-command.js

@@ -1,106 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-const REWIND_SKILL_FOLDER = "flow-rewind";
-const REWIND_SKILL_NAME = "flow-rewind";
-function flowStatePath() {
-    return `${RUNTIME_ROOT}/state/flow-state.json`;
-}
-function artifactsPath() {
-    return `${RUNTIME_ROOT}/artifacts`;
-}
-function rewindLogPath() {
-    return `${RUNTIME_ROOT}/state/rewind-log.jsonl`;
-}
-export function rewindCommandContract() {
-    return `# /cc-ops rewind
-
-## Purpose
-
-Rewind active flow to an earlier stage, or acknowledge stale markers after
-intentional rework.
-
-## HARD-GATE
-
-- Never rewind without preserving downstream artifact history.
-- Mark downstream stages as stale; do not leave completedStages pointing to invalidated work.
-- Record a rewind reason in \`${rewindLogPath()}\`.
-
-## Inputs
-
-\`/cc-ops rewind <target-stage> [reason]\`
-or
-\`/cc-ops rewind --ack <stage>\`
-
-## Algorithm
-
-### rewind mode
-1. Read \`${flowStatePath()}\` and current track.
-2. Validate \`target-stage\` belongs to the active track and is not ahead of current stage.
-3. Compute downstream stages to invalidate (all stages after target that were completed or current).
-4. Archive downstream artifacts into \`${artifactsPath()}/_rewind-archive/<rewind-id>/\`.
-5. Rename active downstream artifacts to \`*.stale.md\`.
-6. Update flow-state:
-   - \`currentStage = target-stage\`
-   - trim \`completedStages\` to stages before target-stage
-   - clear gate evidence/catalog for target-stage and downstream
-   - mark downstream entries in \`staleStages\`
-   - append \`rewinds[]\` record
-7. Append JSON line to \`${rewindLogPath()}\`.
-
-### acknowledge mode (\`--ack\`)
-1. Read \`${flowStatePath()}\`.
-2. If \`staleStages.<stage>\` is missing, report no-op.
-3. Remove \`staleStages.<stage>\`.
-4. Write updated flow-state.
-5. Print remaining stale stages (if any).
-
-## Output
-
-- In rewind mode:
-  - rewind id
-  - from -> to stage
-  - invalidated stages list
-  - number of stale artifacts
-- In acknowledge mode:
-  - acknowledged stage
-  - remaining stale stages
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${REWIND_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function rewindCommandSkillMarkdown() {
-    return `---
-name: ${REWIND_SKILL_NAME}
-description: "Rewind active flow stage safely and acknowledge stale invalidations."
----
-
-# /cc-ops rewind
-
-## HARD-GATE
-
-Rewind is an atomic state transition. Never leave flow-state half-updated (for example currentStage changed but stale markers/artifact archive missing).
-
-## Protocol
-
-### rewind
-1. Validate target stage belongs to current track and is upstream.
-2. Archive downstream artifacts under \`${artifactsPath()}/_rewind-archive/<rewind-id>/\`.
-3. Mark downstream artifacts as stale (\`*.stale.md\`).
-4. Reset downstream gate catalog and guard evidence.
-5. Record \`rewinds[]\` and \`staleStages\` in flow-state.
-6. Append rewind entry into \`${rewindLogPath()}\`.
-
-### rewind --ack <stage>
-1. Load flow-state stale map.
-2. Remove exactly one stale stage marker.
-3. Report remaining stale stages.
-
-## Validation checklist
-
-- \`${flowStatePath()}\` remains valid JSON.
-- \`currentStage\` equals requested rewind target.
-- invalidated stages are absent from \`completedStages\`.
-- archived copies exist for each moved artifact.
-`;
-}

package/dist/content/tdd-log-command.d.ts

@@ -1,2 +0,0 @@
-export declare function tddLogCommandContract(): string;
-export declare function tddLogCommandSkillMarkdown(): string;

package/dist/content/tdd-log-command.js

@@ -1,85 +0,0 @@
-import { RUNTIME_ROOT } from "../constants.js";
-const TDD_LOG_SKILL_FOLDER = "tdd-cycle-log";
-const TDD_LOG_SKILL_NAME = "tdd-cycle-log";
-function logPath() {
-    return `${RUNTIME_ROOT}/state/tdd-cycle-log.jsonl`;
-}
-function flowStatePath() {
-    return `${RUNTIME_ROOT}/state/flow-state.json`;
-}
-export function tddLogCommandContract() {
-    return `# /cc-ops tdd-log
-
-## Purpose
-
-Record explicit RED/GREEN/REFACTOR evidence used by workflow guard and doctor checks.
-
-## HARD-GATE
-
-- Every implementation write in tdd must be preceded by a logged RED event.
-- Use append-only JSONL at \`${logPath()}\`; never rewrite prior lines.
-
-## Subcommands
-
-- \`/cc-ops tdd-log red <slice> <command> [note]\`
-- \`/cc-ops tdd-log green <slice> <command> [note]\`
-- \`/cc-ops tdd-log refactor <slice> <command> [note]\`
-- \`/cc-ops tdd-log show\`
-
-## Log Schema
-
-Each JSON line must include:
-- \`ts\` (ISO timestamp)
-- \`runId\` (from flow-state)
-- \`stage\` (usually \`tdd\`)
-- \`slice\` (e.g. \`S-1\`)
-- \`phase\` (\`red\` | \`green\` | \`refactor\`)
-- \`command\`
-- optional: \`files\`, \`exitCode\`, \`note\`, \`acIds\` (array of acceptance
-  criterion IDs like \`["AC-1"]\` — GREEN rows use this to drive the Ralph
-  Loop status summary at \`.cclaw/state/ralph-loop.json\`).
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${TDD_LOG_SKILL_FOLDER}/SKILL.md**
-`;
-}
-export function tddLogCommandSkillMarkdown() {
-    return `---
-name: ${TDD_LOG_SKILL_NAME}
-description: "Append RED/GREEN/REFACTOR entries into tdd-cycle-log.jsonl for guard/doctor enforcement."
----
-
-# /cc-ops tdd-log
-
-## HARD-GATE
-
-Do not fake RED evidence. A \`red\` entry must correspond to a failing test command.
-
-## Protocol
-
-1. Read \`${flowStatePath()}\` and capture \`activeRunId\` + \`currentStage\`.
-2. Build JSON entry:
-   - \`ts\`: now ISO
-   - \`runId\`: activeRunId
-   - \`stage\`: currentStage
-   - \`slice\`: user-provided slice id
-   - \`phase\`: red|green|refactor
-   - \`command\`: test command or refactor verification command
-   - \`acIds\` (optional, recommended on \`green\`): the acceptance-criterion
-     IDs this GREEN row closes (e.g. \`["AC-1","AC-3"]\`). The SessionStart
-     hook aggregates distinct \`acIds\` from green rows into \`acClosed\`
-     inside \`.cclaw/state/ralph-loop.json\` so \`/cc-next\` can answer
-     "is the Ralph Loop done?" without parsing the artifact.
-3. Append one line to \`${logPath()}\`.
-4. After append, refresh Ralph Loop status with
-   \`cclaw internal tdd-loop-status --quiet\` (the SessionStart hook also
-   refreshes it, but a manual refresh is safe and idempotent).
-5. \`show\`: print the last 20 lines grouped by slice.
-
-## Validation
-
-- File remains valid JSONL (one JSON object per line).
-- For each slice, first phase must be \`red\`.
-`;
-}

package/dist/eval/agents/single-shot.d.ts

@@ -1,27 +0,0 @@
-import type { FlowStage } from "../../types.js";
-import type { ChatUsage, EvalLlmClient } from "../llm-client.js";
-import type { EvalCase, ResolvedEvalConfig } from "../types.js";
-export interface SingleShotInput {
-    caseEntry: EvalCase;
-    config: Pick<ResolvedEvalConfig, "model" | "agentTemperature" | "timeoutMs" | "tokenPricing">;
-    projectRoot: string;
-    client: EvalLlmClient;
-    /**
-     * Override the SKILL.md loader. Primarily a test hook so unit tests
-     * can swap a canned system prompt without creating fixtures on disk.
-     */
-    loadSkill?: (stage: FlowStage) => Promise<string>;
-}
-export interface SingleShotOutput {
-    artifact: string;
-    usage: ChatUsage;
-    usageUsd: number;
-    model: string;
-    durationMs: number;
-    attempts: number;
-    systemPrompt: string;
-    userPrompt: string;
-}
-export declare function loadStageSkill(projectRoot: string, stage: FlowStage): Promise<string>;
-/** Run the single-shot AUT (fixture mode + --judge) and return the produced artifact. */
-export declare function runSingleShot(input: SingleShotInput): Promise<SingleShotOutput>;

package/dist/eval/agents/single-shot.js

@@ -1,79 +0,0 @@
-/**
- * Single-shot agent used by fixture mode when `--judge` is set.
- *
- * Simplest realistic AUT: one LLM call with the stage's SKILL.md as the
- * system prompt and the case's `inputPrompt` as the user message. Output
- * is the raw assistant content, returned as the artifact for the judge
- * pipeline.
- *
- * Design notes:
- *
- * - No tools. No multi-turn. No reads of the project beyond the one
- *   SKILL.md. agent/workflow modes layer complexity on top.
- * - Errors are propagated as-is (`EvalLlmError` subclasses) so the
- *   runner can surface them as verifier failures without swallowing the
- *   cause.
- * - Usage and USD cost are surfaced so the runner can commit them to
- *   the cost guard + case-level `costUsd`.
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../../constants.js";
-import { stageSkillFolder } from "../../content/skills.js";
-import { exists } from "../../fs-utils.js";
-import { computeUsageUsd } from "../cost-guard.js";
-export async function loadStageSkill(projectRoot, stage) {
-    const folder = stageSkillFolder(stage);
-    const file = path.join(projectRoot, RUNTIME_ROOT, "skills", folder, "SKILL.md");
-    if (!(await exists(file))) {
-        throw new Error(`Stage skill not found: ${path.relative(projectRoot, file)}. ` +
-            `Run \`cclaw init\` (or \`cclaw sync\`) before \`cclaw eval --mode=fixture --judge\`.`);
-    }
-    return fs.readFile(file, "utf8");
-}
-function buildMessages(systemPrompt, userPrompt) {
-    return [
-        { role: "system", content: systemPrompt },
-        { role: "user", content: userPrompt }
-    ];
-}
-function buildUserPrompt(caseEntry) {
-    const lines = [];
-    lines.push(`Stage: ${caseEntry.stage}`);
-    lines.push(`Case id: ${caseEntry.id}`);
-    lines.push(``);
-    lines.push(`Task:`);
-    lines.push(caseEntry.inputPrompt.trim());
-    lines.push(``);
-    lines.push(`Produce the artifact required by this stage using the SKILL.md above. ` +
-        `Output the artifact directly (markdown with optional YAML frontmatter). ` +
-        `Do not wrap in code fences, do not add commentary before or after.`);
-    return lines.join("\n");
-}
-/** Run the single-shot AUT (fixture mode + --judge) and return the produced artifact. */
-export async function runSingleShot(input) {
-    const { caseEntry, config, projectRoot, client } = input;
-    const started = Date.now();
-    const loader = input.loadSkill ?? ((stage) => loadStageSkill(projectRoot, stage));
-    const systemPrompt = await loader(caseEntry.stage);
-    const userPrompt = buildUserPrompt(caseEntry);
-    const response = await client.chat({
-        model: config.model,
-        messages: buildMessages(systemPrompt, userPrompt),
-        temperature: config.agentTemperature ?? 0.2,
-        timeoutMs: config.timeoutMs
-    });
-    const usageUsd = computeUsageUsd(response.model, response.usage, {
-        tokenPricing: config.tokenPricing
-    });
-    return {
-        artifact: response.content.trim(),
-        usage: response.usage,
-        usageUsd,
-        model: response.model,
-        attempts: response.attempts,
-        durationMs: Date.now() - started,
-        systemPrompt,
-        userPrompt
-    };
-}

package/dist/eval/agents/with-tools.d.ts

@@ -1,44 +0,0 @@
-import type { ChatUsage, EvalLlmClient } from "../llm-client.js";
-import { createSandbox, type Sandbox } from "../sandbox.js";
-import type { SandboxTool } from "../tools/index.js";
-import type { EvalCase, ResolvedEvalConfig, ToolUseSummary } from "../types.js";
-export declare class MaxTurnsExceededError extends Error {
-    readonly turns: number;
-    constructor(turns: number);
-}
-export interface WithToolsInput {
-    caseEntry: EvalCase;
-    config: Pick<ResolvedEvalConfig, "model" | "agentTemperature" | "timeoutMs" | "tokenPricing" | "toolMaxTurns" | "toolMaxArgumentsBytes" | "toolMaxResultBytes">;
-    projectRoot: string;
-    client: EvalLlmClient;
-    tools?: SandboxTool[];
-    /** Override for the SKILL.md loader (test hook). */
-    loadSkill?: (stage: EvalCase["stage"]) => Promise<string>;
-    /** Override for the sandbox factory (test hook). */
-    createSandboxFn?: typeof createSandbox;
-    /**
-     * Reuse an externally-managed sandbox instead of creating + disposing a
-     * per-call one. Workflow mode uses this so every stage shares the same
-     * sandbox and earlier artifacts remain visible. When set, the caller is
-     * responsible for `dispose()`.
-     */
-    externalSandbox?: Sandbox;
-    /**
-     * Optional override of the default user prompt prefix. Workflow mode uses
-     * this to tell the model which stage it is on and where the prior
-     * artifacts are located.
-     */
-    promptPreamble?: string;
-}
-export interface WithToolsOutput {
-    artifact: string;
-    usage: ChatUsage;
-    usageUsd: number;
-    model: string;
-    attempts: number;
-    durationMs: number;
-    toolUse: ToolUseSummary;
-    systemPrompt: string;
-    userPrompt: string;
-}
-export declare function runWithTools(input: WithToolsInput): Promise<WithToolsOutput>;