cclaw-cli 0.1.1 → 0.2.1

package/dist/policy.js

@@ -5,9 +5,11 @@ import { stageSchema, stagePolicyNeedles } from "./content/stage-schema.js";
 import { stageSkillFolder } from "./content/skills.js";
 import { exists } from "./fs-utils.js";
 const POLICY_RULES = [];
-export async function policyChecks(projectRoot) {
+const ALL_HARNESSES = ["claude", "cursor", "opencode", "codex"];
+export async function policyChecks(projectRoot, options = {}) {
     const checks = [];
     const rules = [...POLICY_RULES];
+    const activeHarnesses = new Set(options.harnesses && options.harnesses.length > 0 ? options.harnesses : ALL_HARNESSES);
     for (const stage of COMMAND_FILE_ORDER) {
         const folder = stageSkillFolder(stage);
         const schema = stageSchema(stage);
@@ -92,15 +94,19 @@ export async function policyChecks(projectRoot) {
         { 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" },
+        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:sdd:routing_notes" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:parallel:hard_gate" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Review Army", name: "utility_skill:parallel:review_army" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Reconciliation", name: "utility_skill:parallel:reconciliation" },
+        { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:parallel:routing_notes" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:session:hard_gate" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Start Protocol", name: "utility_skill:session:start" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Stop Protocol", name: "utility_skill:session:stop" },
@@ -110,13 +116,16 @@ export async function policyChecks(projectRoot) {
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Failure Modes", name: "meta_skill:failure_modes" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Contextual Skills", name: "meta_skill:contextual_skills" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Decision Protocol", name: "meta_skill:decision_protocol" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Progressive Disclosure (Depth / See Also)", name: "meta_skill:progressive_disclosure" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Resume Protocol", name: "utility_skill:session:resume" },
+        { file: runtimeFile("skills/brainstorming/SKILL.md"), needle: "## Progressive Disclosure", name: "stage_skill:progressive_disclosure" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:security:hard_gate" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## Checklist", name: "utility_skill:security:checklist" },
         { file: runtimeFile("skills/security/SKILL.md"), needle: "## Severity Classification", name: "utility_skill:security:severity" },
         { file: runtimeFile("skills/debugging/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:debugging:hard_gate" },
         { file: runtimeFile("skills/debugging/SKILL.md"), needle: "## The Protocol", name: "utility_skill:debugging:protocol" },
         { file: runtimeFile("skills/debugging/SKILL.md"), needle: "Step 1 — Reproduce", name: "utility_skill:debugging:reproduce" },
+        { file: runtimeFile("skills/debugging/SKILL.md"), needle: "## Testing-Specific Anti-Patterns", name: "utility_skill:debugging:test_antipatterns" },
         { file: runtimeFile("skills/performance/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:performance:hard_gate" },
         { file: runtimeFile("skills/performance/SKILL.md"), needle: "## Workflow", name: "utility_skill:performance:workflow" },
         { file: runtimeFile("skills/performance/SKILL.md"), needle: "## Core Web Vitals Reference", name: "utility_skill:performance:cwv" },
@@ -126,6 +135,22 @@ export async function policyChecks(projectRoot) {
         { file: runtimeFile("skills/docs/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:docs:hard_gate" },
         { file: runtimeFile("skills/docs/SKILL.md"), needle: "## ADR (Architecture Decision Record)", name: "utility_skill:docs:adr" },
         { file: runtimeFile("skills/docs/SKILL.md"), needle: "## README Guidance", name: "utility_skill:docs:readme" },
+        { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:executing_plans:hard_gate" },
+        { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Execution Protocol", name: "utility_skill:executing_plans:protocol" },
+        { file: runtimeFile("skills/executing-plans/SKILL.md"), needle: "## Wave Checklist", name: "utility_skill:executing_plans:waves" },
+        { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:context_engineering:hard_gate" },
+        { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## Context Modes", name: "utility_skill:context_engineering:modes" },
+        { file: runtimeFile("skills/context-engineering/SKILL.md"), needle: "## Mode Switching Protocol", name: "utility_skill:context_engineering:switch" },
+        { file: runtimeFile("skills/source-driven-development/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:source_driven:hard_gate" },
+        { file: runtimeFile("skills/source-driven-development/SKILL.md"), needle: "## Protocol", name: "utility_skill:source_driven:protocol" },
+        { file: runtimeFile("skills/source-driven-development/SKILL.md"), needle: "## Selection Heuristics", name: "utility_skill:source_driven:heuristics" },
+        { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:frontend_accessibility:hard_gate" },
+        { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## Checklist", name: "utility_skill:frontend_accessibility:checklist" },
+        { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## Anti-Patterns", name: "utility_skill:frontend_accessibility:anti_patterns" },
+        { file: runtimeFile("contexts/default.md"), needle: "Context Mode: default", name: "context_mode:default" },
+        { file: runtimeFile("contexts/execution.md"), needle: "Context Mode: execution", name: "context_mode:execution" },
+        { file: runtimeFile("contexts/review.md"), needle: "Context Mode: review", name: "context_mode:review" },
+        { file: runtimeFile("contexts/incident.md"), needle: "Context Mode: incident", name: "context_mode:incident" },
         { file: runtimeFile("hooks/session-start.sh"), needle: "ACTIVE_RUN=", name: "hooks:session_start:active_run" },
         { file: runtimeFile("hooks/session-start.sh"), needle: "checkpoint.json", name: "hooks:session_start:checkpoint_ref" },
         { file: runtimeFile("hooks/session-start.sh"), needle: "stage-activity.jsonl", name: "hooks:session_start:activity_ref" },
@@ -133,11 +158,37 @@ export async function policyChecks(projectRoot) {
         { file: runtimeFile("hooks/session-start.sh"), needle: "context-warnings.jsonl", name: "hooks:session_start:context_warning_ref" },
         { file: runtimeFile("hooks/stop-checkpoint.sh"), needle: "checkpoint.json", name: "hooks:stop:checkpoint_write" },
         { file: runtimeFile("hooks/prompt-guard.sh"), needle: "write_to_cclaw_runtime", name: "hooks:guard:risky_write_advisory" },
+        { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },
+        { file: runtimeFile("hooks/workflow-guard.sh"), needle: "stage_jump_", name: "hooks:workflow_guard:stage_jump_reason" },
         { file: runtimeFile("hooks/context-monitor.sh"), needle: "remaining is", name: "hooks:context:threshold_warning" },
         { file: runtimeFile("hooks/observe.sh"), needle: "stage-activity.jsonl", name: "hooks:observe:activity_write" },
         { file: runtimeFile("hooks/summarize-observations.mjs"), needle: "frequent-errors-", name: "hooks:summarize:runtime_module" },
         { file: runtimeFile("hooks/opencode-plugin.mjs"), needle: "activeRunId", name: "hooks:opencode:active_run" }
     ];
+    if (activeHarnesses.has("opencode")) {
+        utilitySkillChecks.push({
+            file: ".opencode/plugins/cclaw-plugin.mjs",
+            needle: "\"tool.execute.before\"",
+            name: "hooks:opencode:deployed_tool_hook"
+        });
+        utilitySkillChecks.push({
+            file: ".opencode/plugins/cclaw-plugin.mjs",
+            needle: "workflow-guard.sh",
+            name: "hooks:opencode:deployed_workflow_guard"
+        });
+    }
+    if (activeHarnesses.has("cursor")) {
+        utilitySkillChecks.push({
+            file: ".cursor/rules/cclaw-workflow.mdc",
+            needle: "cclaw-managed-cursor-workflow-rule",
+            name: "rules:cursor:managed_marker"
+        });
+        utilitySkillChecks.push({
+            file: ".cursor/rules/cclaw-workflow.mdc",
+            needle: "/cc-next",
+            name: "rules:cursor:next_command_guidance"
+        });
+    }
     for (const check of utilitySkillChecks) {
         rules.push({
             filePath: check.file,

package/dist/runs.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { COMMAND_FILE_ORDER, RUNTIME_ROOT } from "./constants.js";
 import { ARTIFACT_TEMPLATES } from "./content/templates.js";
 import { createInitialFlowState } from "./flow-state.js";
-import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
+import { ensureDir, exists, withDirectoryLock, writeFileSafe } from "./fs-utils.js";
 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`;
@@ -13,6 +13,9 @@ const FLOW_STAGE_SET = new Set(COMMAND_FILE_ORDER);
 function flowStatePath(projectRoot) {
     return path.join(projectRoot, FLOW_STATE_REL_PATH);
 }
+function flowStateLockPath(projectRoot) {
+    return path.join(projectRoot, RUNTIME_ROOT, "state", ".flow-state.lock");
+}
 function runsRoot(projectRoot) {
     return path.join(projectRoot, RUNS_DIR_REL_PATH);
 }
@@ -231,8 +234,10 @@ export async function readFlowState(projectRoot) {
     return coerceFlowState(parsed);
 }
 export async function writeFlowState(projectRoot, state) {
-    const safe = coerceFlowState({ ...state }, state.activeRunId);
-    await writeFileSafe(flowStatePath(projectRoot), `${JSON.stringify(safe, null, 2)}\n`);
+    await withDirectoryLock(flowStateLockPath(projectRoot), async () => {
+        const safe = coerceFlowState({ ...state }, state.activeRunId);
+        await writeFileSafe(flowStatePath(projectRoot), `${JSON.stringify(safe, null, 2)}\n`);
+    });
 }
 export async function listRuns(projectRoot) {
     const root = runsRoot(projectRoot);

package/dist/trace-matrix.d.ts

@@ -0,0 +1,13 @@
+export interface TraceEntry {
+    criterionId: string;
+    taskIds: string[];
+    testSlices: string[];
+    reviewFindings: string[];
+}
+export interface TraceMatrix {
+    entries: TraceEntry[];
+    orphanedCriteria: string[];
+    orphanedTasks: string[];
+    orphanedTests: string[];
+}
+export declare function buildTraceMatrix(projectRoot: string): Promise<TraceMatrix>;

package/dist/trace-matrix.js

@@ -0,0 +1,182 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { RUNTIME_ROOT } from "./constants.js";
+import { exists } from "./fs-utils.js";
+import { readFlowState } from "./runs.js";
+function activeArtifactPath(projectRoot, name) {
+    return path.join(projectRoot, RUNTIME_ROOT, "artifacts", name);
+}
+function canonicalRunArtifactPath(projectRoot, runId, name) {
+    return path.join(projectRoot, RUNTIME_ROOT, "runs", runId, "artifacts", name);
+}
+async function readArtifact(projectRoot, name, activeRunId) {
+    const runId = activeRunId.trim();
+    const candidates = runId.length > 0
+        ? [canonicalRunArtifactPath(projectRoot, runId, name), activeArtifactPath(projectRoot, name)]
+        : [activeArtifactPath(projectRoot, name)];
+    for (const candidate of candidates) {
+        if (await exists(candidate)) {
+            return fs.readFile(candidate, "utf8");
+        }
+    }
+    return null;
+}
+function uniqPreserve(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        if (!seen.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    }
+    return out;
+}
+function criterionTokens(text) {
+    return text.match(/\bAC-\d+\b/g) ?? [];
+}
+/** AC-1, AC-12, etc. */
+function parseAcceptanceCriterionIds(specMd) {
+    return uniqPreserve(criterionTokens(specMd));
+}
+/** Map task id -> AC ids mentioned on same table row or bullet line as the task. */
+function parsePlanTaskAcLinks(planMd) {
+    const map = new Map();
+    const lines = planMd.split(/\r?\n/);
+    const taskRe = /\b(T-\d+)\b/;
+    const acRe = /\b(AC-\d+)\b/g;
+    for (const line of lines) {
+        const tm = taskRe.exec(line);
+        if (!tm) {
+            continue;
+        }
+        const taskId = tm[1];
+        const acs = [...line.matchAll(acRe)].map((m) => m[0]);
+        if (acs.length === 0) {
+            continue;
+        }
+        const prev = map.get(taskId) ?? [];
+        map.set(taskId, uniqPreserve([...prev, ...acs]));
+    }
+    return map;
+}
+/** All T-N ids appearing in the plan (best-effort). */
+function parsePlanTaskIds(planMd) {
+    const re = /\bT-\d+\b/g;
+    return uniqPreserve(planMd.match(re) ?? []);
+}
+/** Map slice id -> task ids on same line. */
+function parseTddSliceTaskLinks(tddMd) {
+    const map = new Map();
+    const sliceRe = /\b(S-\d+)\b/g;
+    const taskRe = /\b(T-\d+)\b/g;
+    const lines = tddMd.split(/\r?\n/);
+    for (const line of lines) {
+        const slices = [...line.matchAll(sliceRe)].map((m) => m[1]);
+        if (slices.length === 0) {
+            continue;
+        }
+        const tasks = [...line.matchAll(taskRe)].map((m) => m[1]);
+        for (const s of slices) {
+            const prev = map.get(s) ?? [];
+            map.set(s, uniqPreserve([...prev, ...tasks]));
+        }
+    }
+    return map;
+}
+function parseTddSliceIds(tddMd) {
+    return uniqPreserve(tddMd.match(/\bS-\d+\b/g) ?? []);
+}
+/** Body of Layer 1 spec compliance section in 07-review.md */
+function extractLayer1Section(reviewMd) {
+    const lines = reviewMd.split(/\r?\n/);
+    let start = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^##\s+Layer\s*1/i.test(lines[i])) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start < 0) {
+        return "";
+    }
+    const buf = [];
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^##\s+/.test(line)) {
+            break;
+        }
+        buf.push(line);
+    }
+    return buf.join("\n");
+}
+function layer1LinesForCriterion(layer1, criterionId) {
+    const out = [];
+    for (const line of layer1.split(/\r?\n/)) {
+        if (criterionTokens(line).includes(criterionId)) {
+            out.push(line.trim());
+        }
+    }
+    return out;
+}
+export async function buildTraceMatrix(projectRoot) {
+    const { activeRunId } = await readFlowState(projectRoot);
+    const spec = await readArtifact(projectRoot, "04-spec.md", activeRunId);
+    const plan = await readArtifact(projectRoot, "05-plan.md", activeRunId);
+    const tdd = await readArtifact(projectRoot, "06-tdd.md", activeRunId);
+    const review = await readArtifact(projectRoot, "07-review.md", activeRunId);
+    const criterionIds = spec ? parseAcceptanceCriterionIds(spec) : [];
+    const taskToAcs = plan ? parsePlanTaskAcLinks(plan) : new Map();
+    const allTaskIds = plan ? parsePlanTaskIds(plan) : [];
+    const sliceToTasks = tdd ? parseTddSliceTaskLinks(tdd) : new Map();
+    const allSliceIds = tdd ? parseTddSliceIds(tdd) : [];
+    const layer1 = review ? extractLayer1Section(review) : "";
+    const acToTasks = new Map();
+    for (const [task, acs] of taskToAcs) {
+        for (const ac of acs) {
+            const prev = acToTasks.get(ac) ?? [];
+            if (!prev.includes(task)) {
+                acToTasks.set(ac, [...prev, task]);
+            }
+        }
+    }
+    const entries = criterionIds.map((criterionId) => {
+        const taskIds = acToTasks.get(criterionId) ?? [];
+        const testSlices = [];
+        for (const [slice, tasks] of sliceToTasks) {
+            if (tasks.some((t) => taskIds.includes(t))) {
+                testSlices.push(slice);
+            }
+        }
+        return {
+            criterionId,
+            taskIds: uniqPreserve(taskIds),
+            testSlices: uniqPreserve(testSlices),
+            reviewFindings: layer1LinesForCriterion(layer1, criterionId)
+        };
+    });
+    const orphanedCriteria = criterionIds.filter((ac) => (acToTasks.get(ac) ?? []).length === 0);
+    const tasksWithSlice = new Set();
+    for (const tasks of sliceToTasks.values()) {
+        for (const t of tasks) {
+            tasksWithSlice.add(t);
+        }
+    }
+    const orphanedTasks = allTaskIds.filter((t) => !tasksWithSlice.has(t));
+    const orphanedTests = allSliceIds.filter((s) => {
+        const tasks = sliceToTasks.get(s) ?? [];
+        if (tasks.length === 0) {
+            return true;
+        }
+        return tasks.every((t) => {
+            const acs = taskToAcs.get(t);
+            return !acs || acs.length === 0;
+        });
+    });
+    return {
+        entries,
+        orphanedCriteria,
+        orphanedTasks,
+        orphanedTests
+    };
+}

package/dist/types.d.ts

@@ -2,10 +2,20 @@ export declare const FLOW_STAGES: readonly ["brainstorm", "scope", "design", "sp
 export type FlowStage = (typeof FLOW_STAGES)[number];
 export declare const HARNESS_IDS: readonly ["claude", "cursor", "opencode", "codex"];
 export type HarnessId = (typeof HARNESS_IDS)[number];
-export interface CclawConfig {
+export interface VibyConfig {
     version: string;
     flowVersion: string;
     harnesses: HarnessId[];
+    /** When true, stage skills instruct the agent to continue to the following stage after gates pass. */
+    autoAdvance?: boolean;
+    /** Merge project bootstrap learnings with a global learnings file. */
+    globalLearnings?: boolean;
+    /** Optional absolute or project-relative path to global learnings JSONL. */
+    globalLearningsPath?: string;
+    /** Prompt guard behavior for runtime write-risk detection hooks. */
+    promptGuardMode?: "advisory" | "strict";
+    /** When true, cclaw installs managed git pre-commit/pre-push wrappers. */
+    gitHookGuards?: boolean;
 }
 export interface TransitionRule {
     from: FlowStage;

package/package.json

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