cclaw-cli 0.21.1 → 0.21.2

package/dist/content/skills.js

@@ -157,7 +157,7 @@ ${rows}
 function mergedAntiPatterns(schema) {
     const merged = [];
     const seen = new Set();
-    for (const item of [...schema.antiPatterns, ...schema.blockers, ...schema.redFlags]) {
+    for (const item of [...schema.commonRationalizations, ...schema.blockers]) {
         const key = item.trim().toLowerCase();
         if (seen.has(key))
             continue;

package/dist/content/stages/brainstorm.js

@@ -94,18 +94,14 @@ export const BRAINSTORM = {
         "no implementation action taken",
         "artifact reviewed by user"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Asking questions without exploring existing project context first",
         "Asking bundled or purely informational questions that don't change decisions",
         "Proposing cosmetic option variants instead of architecturally distinct approaches",
         "Jumping directly into implementation",
-        "Requesting approval without stating what decision is being approved"
-    ],
-    redFlags: [
-        "No project context exploration before questions",
+        "Requesting approval without stating what decision is being approved",
         "Questions that only gather preferences without design impact",
-        "Options that are variants of one approach, not distinct alternatives",
-        "Approval requested without explicit decision context"
+        "Options that are variants of one approach, not distinct alternatives"
     ],
     policyNeedles: [
         "Explore project context",

package/dist/content/stages/design.js

@@ -106,20 +106,17 @@ export const DESIGN = {
         "completion dashboard present with all review-section statuses",
         "artifact complete for spec handoff"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Architecture deferred to implementation phase",
         "Missing data-flow edge cases",
         "No performance budget for critical path",
         "Batching multiple design issues into one question",
         "Skipping review sections because plan seems simple",
         "Agreeing with user's architecture choice without evaluating alternatives",
-        "Hedging every recommendation with 'it depends' instead of taking a position"
-    ],
-    redFlags: [
+        "Hedging every recommendation with 'it depends' instead of taking a position",
         "No explicit architecture boundary section",
         "No failure recovery strategy",
         "No defined test/perf baseline",
-        "Review sections skipped or condensed",
         "No NOT-in-scope output section",
         "No What-already-exists output section",
         "Design decisions made without reading the actual code first"

package/dist/content/stages/plan.js

@@ -83,14 +83,12 @@ export const PLAN = {
         "artifact ready for TDD execution",
         "acceptance mapping complete"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Horizontal decomposition without end-to-end slices",
         "Tasks without verification steps",
         "Starting execution before approval",
         "Tasks that touch multiple unrelated areas",
-        "Using placeholder tokens or scope-reduction phrases (`v1`, `for now`, `later`) in task definitions"
-    ],
-    redFlags: [
+        "Using placeholder tokens or scope-reduction phrases (`v1`, `for now`, `later`) in task definitions",
         "No dependency graph",
         "No WAIT_FOR_CONFIRM marker",
         "No explicit dependency waves",

package/dist/content/stages/review.js

@@ -88,14 +88,12 @@ export const REVIEW = {
         "critical blockers resolved",
         "ship readiness explicitly stated"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Single generic review without layered structure",
         "No severity classification",
         "Shipping with open criticals",
         "Batching multiple findings into one report without individual resolution",
-        "Skipping Layer 2 sections because Layer 1 passed"
-    ],
-    redFlags: [
+        "Skipping Layer 2 sections because Layer 1 passed",
         "No separate Layer 1/Layer 2 outcomes",
         "No structured review-army reconciliation artifact",
         "No critical bucket",

package/dist/content/stages/schema-types.d.ts

@@ -74,8 +74,14 @@ export interface StageSchema {
     outputs: string[];
     blockers: string[];
     exitCriteria: string[];
-    antiPatterns: string[];
-    redFlags: string[];
+    /**
+     * Consolidated "Common Rationalizations" list — things an agent is likely to
+     * talk itself into that should stop the stage. Rendered under the
+     * "Anti-Patterns & Red Flags" heading in the generated SKILL.md. Replaces
+     * the former split between `antiPatterns` and `redFlags`, which produced
+     * near-duplicate entries and forced downstream code to merge them anyway.
+     */
+    commonRationalizations: string[];
     policyNeedles: string[];
     artifactFile: string;
     next: FlowStage | "done";

package/dist/content/stages/scope.js

@@ -96,7 +96,7 @@ export const SCOPE = {
         "completion dashboard produced",
         "scope summary produced"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Scope silently expanded during discussion",
         "No explicit out-of-scope section",
         "Premise accepted without challenge",
@@ -104,16 +104,12 @@ export const SCOPE = {
         "Hedged recommendations that avoid taking a position",
         "Batching multiple scope issues into one question",
         "Re-arguing for smaller scope after user rejects reduction",
-        "Using scope-reduction placeholders (`v1`, `for now`, `we can do later`) instead of explicit user-approved boundaries"
-    ],
-    redFlags: [
+        "Using scope-reduction placeholders (`v1`, `for now`, `we can do later`) instead of explicit user-approved boundaries",
         "No selected mode in artifact",
         "Mode selected without heuristic justification",
         "No discretion section (or explicit `None`) in artifact",
         "No deferred/not-in-scope section",
         "No user approval marker",
-        "Premise challenge missing or superficial",
-        "No implementation alternatives evaluated",
         "Missing Locked Decisions section or decisions without D-XX IDs"
     ],
     policyNeedles: ["Scope mode", "In Scope", "Out of Scope", "Discretion Areas", "NOT in scope", "Premise Challenge", "Locked Decisions"],

package/dist/content/stages/ship.js

@@ -77,14 +77,12 @@ export const SHIP = {
         "rollback and release notes complete",
         "finalization action explicitly chosen and executed"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Shipping without rollback strategy",
         "Implicit finalization decision",
         "Bypassing preflight due to urgency",
         "Selecting multiple finalization modes",
-        "Shipping with BLOCKED review verdict"
-    ],
-    redFlags: [
+        "Shipping with BLOCKED review verdict",
         "No rollback trigger/steps",
         "More than one finalization mode implied",
         "No explicit preflight result",

package/dist/content/stages/spec.js

@@ -77,14 +77,11 @@ export const SPEC = {
         "plan-ready acceptance mapping exists",
         "testability confirmed for all criteria"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "High-level goals without measurable outcomes",
         "Implicit assumptions",
         "Proceeding to plan before approval",
-        "Using vague adjectives (fast, intuitive, robust) without thresholds"
-    ],
-    redFlags: [
-        "Criteria use vague language (fast, intuitive, robust) without thresholds",
+        "Using vague adjectives (fast, intuitive, robust) without thresholds",
         "No explicit assumptions section",
         "No approval record",
         "No testability mapping",

package/dist/content/stages/tdd.js

@@ -88,16 +88,14 @@ export const TDD = {
         "required gates marked satisfied",
         "traceability annotated"
     ],
-    antiPatterns: [
+    commonRationalizations: [
         "Writing code before failing test",
         "Asserting implementation details instead of behavior",
         "Big-bang implementation across multiple slices",
         "Partial test runs presented as GREEN",
         "Skipping evidence capture",
         "Undocumented refactor changes",
-        "Adding features beyond what RED tests require"
-    ],
-    redFlags: [
+        "Adding features beyond what RED tests require",
         "No failing test output (RED missing)",
         "Implementation edits appear before RED evidence",
         "No full-suite GREEN evidence",

package/dist/runs.d.ts

@@ -52,19 +52,6 @@ export interface ArchiveManifest {
     snapshottedStateFiles: string[];
     retro: ArchiveRunResult["retro"];
 }
-export interface RewindRunOptions {
-    to: FlowStage;
-    reason?: string;
-}
-export interface RewindRunResult {
-    rewindId: string;
-    from: FlowStage;
-    to: FlowStage;
-    invalidatedStages: FlowStage[];
-    staleArtifacts: string[];
-    archivePath: string;
-    nextState: FlowState;
-}
 interface EnsureRunSystemOptions {
     createIfMissing?: boolean;
 }
@@ -82,11 +69,6 @@ export declare function writeFlowState(projectRoot: string, state: FlowState, op
 export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
 export declare function listRuns(projectRoot: string): Promise<CclawRunMeta[]>;
 export declare function archiveRun(projectRoot: string, featureName?: string, options?: ArchiveRunOptions): Promise<ArchiveRunResult>;
-export declare function rewindRun(projectRoot: string, options: RewindRunOptions): Promise<RewindRunResult>;
-export declare function acknowledgeStaleStage(projectRoot: string, stage: FlowStage): Promise<{
-    acknowledged: boolean;
-    remaining: FlowStage[];
-}>;
 /**
  * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
  * non-empty line that parses as JSON with the required `type` field belonging to the

package/dist/runs.js

@@ -1,10 +1,9 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { COMMAND_FILE_ORDER, RUNTIME_ROOT } from "./constants.js";
-import { canTransition, createInitialFlowState, isFlowTrack, skippedStagesForTrack, trackStages } from "./flow-state.js";
+import { canTransition, createInitialFlowState, isFlowTrack, skippedStagesForTrack } from "./flow-state.js";
 import { ensureFeatureSystem, readActiveFeature, syncActiveFeatureSnapshot } from "./feature-system.js";
 import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
-import { stageSchema } from "./content/stage-schema.js";
 export class InvalidStageTransitionError extends Error {
     from;
     to;
@@ -36,8 +35,6 @@ const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
 const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
 const STATE_DIR_REL_PATH = `${RUNTIME_ROOT}/state`;
-const REWIND_LOG_REL_PATH = `${RUNTIME_ROOT}/state/rewind-log.jsonl`;
-const REWIND_ARCHIVE_DIR_NAME = "_rewind-archive";
 const FLOW_STAGE_SET = new Set(COMMAND_FILE_ORDER);
 /** State filenames explicitly excluded from the archive snapshot. */
 const STATE_SNAPSHOT_EXCLUDE = new Set([
@@ -59,12 +56,6 @@ function activeArtifactsPath(projectRoot) {
 function stateDirPath(projectRoot) {
     return path.join(projectRoot, STATE_DIR_REL_PATH);
 }
-function rewindLogPath(projectRoot) {
-    return path.join(projectRoot, REWIND_LOG_REL_PATH);
-}
-function rewindArchivePath(projectRoot, rewindId) {
-    return path.join(activeArtifactsPath(projectRoot), REWIND_ARCHIVE_DIR_NAME, rewindId);
-}
 async function snapshotStateDirectory(projectRoot, destinationRoot) {
     const sourceDir = stateDirPath(projectRoot);
     if (!(await exists(sourceDir))) {
@@ -348,23 +339,6 @@ async function uniqueArchiveId(projectRoot, baseId) {
     }
     return candidate;
 }
-function rewindTimestampId(date = new Date()) {
-    return date
-        .toISOString()
-        .replace(/[-:]/gu, "")
-        .replace(/\.\d{3}Z$/u, "Z");
-}
-function staleArtifactFileName(fileName) {
-    const ext = path.extname(fileName);
-    if (!ext) {
-        return `${fileName}.stale`;
-    }
-    const base = fileName.slice(0, -ext.length);
-    return `${base}.stale${ext}`;
-}
-function stageIndexMapForTrack(track) {
-    return new Map(trackStages(track).map((stage, index) => [stage, index]));
-}
 function retroArtifactPath(projectRoot) {
     return path.join(activeArtifactsPath(projectRoot), "09-retro.md");
 }
@@ -620,167 +594,6 @@ export async function archiveRun(projectRoot, featureName, options = {}) {
         retro: retroSummary
     };
 }
-export async function rewindRun(projectRoot, options) {
-    await ensureRunSystem(projectRoot);
-    const state = await readFlowState(projectRoot);
-    const track = state.track ?? "standard";
-    const ordered = trackStages(track);
-    const stageToIndex = stageIndexMapForTrack(track);
-    const toIndex = stageToIndex.get(options.to);
-    const currentIndex = stageToIndex.get(state.currentStage);
-    if (toIndex === undefined) {
-        throw new Error(`Cannot rewind to "${options.to}" because it is outside track "${track}".`);
-    }
-    if (currentIndex === undefined) {
-        throw new Error(`Current stage "${state.currentStage}" is not part of track "${track}".`);
-    }
-    if (toIndex > currentIndex) {
-        throw new Error(`Cannot rewind forward from "${state.currentStage}" to "${options.to}".`);
-    }
-    const reason = options.reason?.trim() && options.reason.trim().length > 0
-        ? options.reason.trim()
-        : "manual_rewind";
-    const nowIso = new Date().toISOString();
-    const rewindId = `rewind-${rewindTimestampId()}`;
-    const invalidatedStages = ordered.filter((stage) => {
-        const idx = stageToIndex.get(stage);
-        if (idx === undefined || idx <= toIndex) {
-            return false;
-        }
-        return state.completedStages.includes(stage) || stage === state.currentStage;
-    });
-    const nextCompletedStages = state.completedStages.filter((stage) => {
-        const idx = stageToIndex.get(stage);
-        return typeof idx === "number" && idx < toIndex;
-    });
-    const freshCatalog = createInitialFlowState({ activeRunId: state.activeRunId, track }).stageGateCatalog;
-    const nextCatalog = { ...state.stageGateCatalog };
-    for (const stage of ordered) {
-        const idx = stageToIndex.get(stage);
-        if (idx === undefined)
-            continue;
-        if (idx >= toIndex) {
-            nextCatalog[stage] = {
-                ...freshCatalog[stage],
-                required: [...freshCatalog[stage].required],
-                recommended: [...freshCatalog[stage].recommended],
-                conditional: [...freshCatalog[stage].conditional],
-                triggered: [],
-                passed: [],
-                blocked: []
-            };
-        }
-    }
-    const nextGuardEvidence = { ...state.guardEvidence };
-    for (const stage of ordered) {
-        const idx = stageToIndex.get(stage);
-        if (idx === undefined || idx < toIndex)
-            continue;
-        const catalog = state.stageGateCatalog[stage];
-        const gateIds = new Set([
-            ...catalog.required,
-            ...catalog.recommended,
-            ...catalog.conditional,
-            ...catalog.triggered,
-            ...catalog.passed,
-            ...catalog.blocked
-        ]);
-        for (const gateId of gateIds) {
-            delete nextGuardEvidence[gateId];
-        }
-    }
-    const nextStale = {};
-    for (const [stage, marker] of Object.entries(state.staleStages)) {
-        if (!marker)
-            continue;
-        const idx = stageToIndex.get(stage);
-        if (idx === undefined || idx <= toIndex) {
-            continue;
-        }
-        nextStale[stage] = marker;
-    }
-    for (const stage of invalidatedStages) {
-        nextStale[stage] = {
-            rewindId,
-            reason,
-            markedAt: nowIso
-        };
-    }
-    const archivePath = rewindArchivePath(projectRoot, rewindId);
-    const staleArtifacts = [];
-    for (const stage of invalidatedStages) {
-        const artifactFile = stageSchema(stage).artifactFile;
-        const artifactPath = path.join(activeArtifactsPath(projectRoot), artifactFile);
-        if (!(await exists(artifactPath))) {
-            continue;
-        }
-        await ensureDir(archivePath);
-        await ensureDir(path.join(archivePath, path.dirname(artifactFile)));
-        await fs.copyFile(artifactPath, path.join(archivePath, artifactFile));
-        const staleName = staleArtifactFileName(artifactFile);
-        const stalePath = path.join(activeArtifactsPath(projectRoot), staleName);
-        await fs.rm(stalePath, { force: true });
-        await fs.rename(artifactPath, stalePath);
-        staleArtifacts.push(staleName);
-    }
-    const rewindRecord = {
-        id: rewindId,
-        fromStage: state.currentStage,
-        toStage: options.to,
-        reason,
-        timestamp: nowIso,
-        invalidatedStages
-    };
-    const nextState = {
-        ...state,
-        currentStage: options.to,
-        completedStages: nextCompletedStages,
-        guardEvidence: nextGuardEvidence,
-        stageGateCatalog: nextCatalog,
-        staleStages: nextStale,
-        rewinds: [...state.rewinds, rewindRecord]
-    };
-    await writeFlowState(projectRoot, nextState, { allowReset: true });
-    const rewindLogEntry = {
-        ...rewindRecord,
-        track,
-        runId: state.activeRunId,
-        staleArtifacts
-    };
-    await ensureDir(path.dirname(rewindLogPath(projectRoot)));
-    await fs.appendFile(rewindLogPath(projectRoot), `${JSON.stringify(rewindLogEntry)}\n`, "utf8");
-    return {
-        rewindId,
-        from: state.currentStage,
-        to: options.to,
-        invalidatedStages,
-        staleArtifacts,
-        archivePath,
-        nextState
-    };
-}
-export async function acknowledgeStaleStage(projectRoot, stage) {
-    await ensureRunSystem(projectRoot);
-    const state = await readFlowState(projectRoot);
-    const marker = state.staleStages[stage];
-    if (!marker) {
-        return {
-            acknowledged: false,
-            remaining: Object.keys(state.staleStages).filter((value) => isFlowStage(value))
-        };
-    }
-    const nextStale = { ...state.staleStages };
-    delete nextStale[stage];
-    const nextState = {
-        ...state,
-        staleStages: nextStale
-    };
-    await writeFlowState(projectRoot, nextState, { allowReset: true });
-    return {
-        acknowledged: true,
-        remaining: Object.keys(nextStale).filter((value) => isFlowStage(value))
-    };
-}
 const KNOWLEDGE_SOFT_THRESHOLD = 50;
 async function readKnowledgeStats(projectRoot) {
     const knowledgePath = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");

package/package.json

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