cclaw-cli 0.1.1 → 0.2.1

package/dist/artifact-linter.d.ts

@@ -0,0 +1,20 @@
+import type { FlowStage } from "./types.js";
+export interface LintFinding {
+    section: string;
+    required: boolean;
+    rule: string;
+    found: boolean;
+    details: string;
+}
+export interface LintResult {
+    stage: string;
+    file: string;
+    passed: boolean;
+    findings: LintFinding[];
+}
+export declare function lintArtifact(projectRoot: string, stage: FlowStage): Promise<LintResult>;
+export declare function lintAllArtifacts(projectRoot: string): Promise<LintResult[]>;
+export declare function validateReviewArmy(projectRoot: string): Promise<{
+    valid: boolean;
+    errors: string[];
+}>;

package/dist/artifact-linter.js

@@ -0,0 +1,368 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { RUNTIME_ROOT } from "./constants.js";
+import { exists } from "./fs-utils.js";
+import { orderedStageSchemas, stageSchema } from "./content/stage-schema.js";
+import { readFlowState } from "./runs.js";
+async function resolveArtifactPath(projectRoot, fileName) {
+    const fallbackRelPath = path.join(RUNTIME_ROOT, "artifacts", fileName);
+    const fallbackAbsPath = path.join(projectRoot, fallbackRelPath);
+    const { activeRunId } = await readFlowState(projectRoot);
+    const runId = activeRunId.trim();
+    if (runId.length > 0) {
+        const canonicalRelPath = path.join(RUNTIME_ROOT, "runs", runId, "artifacts", fileName);
+        const canonicalAbsPath = path.join(projectRoot, canonicalRelPath);
+        if (await exists(canonicalAbsPath)) {
+            return { absPath: canonicalAbsPath, relPath: canonicalRelPath };
+        }
+    }
+    return { absPath: fallbackAbsPath, relPath: fallbackRelPath };
+}
+function normalizeHeadingTitle(title) {
+    return title.trim().replace(/\s+/g, " ");
+}
+/** Collect H2 sections and body content (`## Section Name`). */
+function extractH2Sections(markdown) {
+    const sections = new Map();
+    const lines = markdown.split(/\r?\n/);
+    let currentHeading = null;
+    let buffer = [];
+    const flush = () => {
+        if (currentHeading === null)
+            return;
+        sections.set(currentHeading, buffer.join("\n"));
+    };
+    for (const line of lines) {
+        const match = /^##\s+(.+)$/u.exec(line);
+        if (match) {
+            flush();
+            currentHeading = normalizeHeadingTitle(match[1] ?? "");
+            buffer = [];
+            continue;
+        }
+        if (currentHeading !== null) {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function headingPresent(sections, section) {
+    const want = normalizeHeadingTitle(section).toLowerCase();
+    for (const h of sections.keys()) {
+        if (h.toLowerCase() === want) {
+            return true;
+        }
+    }
+    return false;
+}
+function sectionBodyByName(sections, section) {
+    const want = normalizeHeadingTitle(section).toLowerCase();
+    for (const [heading, body] of sections.entries()) {
+        if (heading.toLowerCase() === want) {
+            return body;
+        }
+    }
+    return null;
+}
+function meaningfulLineCount(sectionBody) {
+    return sectionBody
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !line.startsWith("<!--"))
+        .filter((line) => !/^[-:| ]+$/u.test(line))
+        .filter((line) => /[A-Za-z0-9]/u.test(line))
+        .length;
+}
+function lineHasToken(line, token) {
+    return new RegExp(`\\b${token}\\b`, "u").test(line);
+}
+function countListItems(sectionBody) {
+    const lines = sectionBody.split(/\r?\n/).map((line) => line.trim());
+    const bullets = lines.filter((line) => /^[-*]\s+\S+/u.test(line)).length;
+    const tableRows = lines.filter((line) => /^\|.*\|$/u.test(line) && !/^\|[-:| ]+\|$/u.test(line));
+    const tableDataRows = tableRows.length > 0 ? Math.max(0, tableRows.length - 1) : 0;
+    return Math.max(bullets, tableDataRows);
+}
+function extractMinItemsFromRule(rule) {
+    const match = /at least\s+(\d+)/iu.exec(rule);
+    if (!match)
+        return null;
+    const parsed = Number.parseInt(match[1] ?? "", 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function tokensFromRule(rule) {
+    const allCaps = rule.match(/\b[A-Z][A-Z0-9_]{2,}\b/g) ?? [];
+    if (allCaps.length > 0) {
+        return [...new Set(allCaps)];
+    }
+    if (/finalization enum token/iu.test(rule)) {
+        return [
+            "FINALIZE_MERGE_LOCAL",
+            "FINALIZE_OPEN_PR",
+            "FINALIZE_KEEP_BRANCH",
+            "FINALIZE_DISCARD_BRANCH"
+        ];
+    }
+    if (/final verdict/iu.test(rule)) {
+        return ["APPROVED", "APPROVED_WITH_CONCERNS", "BLOCKED"];
+    }
+    return [];
+}
+function validateSectionBody(sectionBody, rule) {
+    const bodyLines = sectionBody.split(/\r?\n/).map((line) => line.trim());
+    const meaningful = meaningfulLineCount(sectionBody);
+    if (meaningful === 0) {
+        return {
+            ok: false,
+            details: "Section exists but has no meaningful content yet."
+        };
+    }
+    const minItems = extractMinItemsFromRule(rule);
+    if (minItems !== null) {
+        const count = countListItems(sectionBody);
+        if (count < minItems) {
+            return {
+                ok: false,
+                details: `Rule expects at least ${minItems} item(s), found ${count}.`
+            };
+        }
+    }
+    if (/exactly one/iu.test(rule)) {
+        const tokens = tokensFromRule(rule);
+        if (tokens.length > 0) {
+            const selected = new Set();
+            const tokenLines = [];
+            for (const line of bodyLines) {
+                if (!line)
+                    continue;
+                for (const token of tokens) {
+                    if (!lineHasToken(line, token))
+                        continue;
+                    tokenLines.push({ line, token });
+                    if (/\[x\]/iu.test(line) || /selected|verdict|enum|execution result|status/iu.test(line)) {
+                        selected.add(token);
+                    }
+                }
+            }
+            if (selected.size === 0 && tokenLines.length === 1 && !tokenLines[0].line.includes("|")) {
+                selected.add(tokenLines[0].token);
+            }
+            if (selected.size !== 1) {
+                return {
+                    ok: false,
+                    details: `Rule expects exactly one selected token (${tokens.join(", ")}); found ${selected.size}.`
+                };
+            }
+        }
+    }
+    return {
+        ok: true,
+        details: "Section heading and content satisfy lint heuristics."
+    };
+}
+export async function lintArtifact(projectRoot, stage) {
+    const schema = stageSchema(stage);
+    const { absPath: absFile, relPath: relFile } = await resolveArtifactPath(projectRoot, schema.artifactFile);
+    const findings = [];
+    if (!(await exists(absFile))) {
+        for (const v of schema.artifactValidation) {
+            findings.push({
+                section: v.section,
+                required: v.required,
+                rule: v.validationRule,
+                found: false,
+                details: `Artifact file missing: ${relFile}`
+            });
+        }
+        return {
+            stage,
+            file: relFile,
+            passed: schema.artifactValidation.every((v) => !v.required),
+            findings
+        };
+    }
+    const raw = await fs.readFile(absFile, "utf8");
+    const sections = extractH2Sections(raw);
+    for (const v of schema.artifactValidation) {
+        const hasHeading = headingPresent(sections, v.section);
+        const body = hasHeading ? sectionBodyByName(sections, v.section) : null;
+        const validation = body === null
+            ? { ok: false, details: `No ## heading matching required section "${v.section}".` }
+            : validateSectionBody(body, v.validationRule);
+        const found = hasHeading && validation.ok;
+        findings.push({
+            section: v.section,
+            required: v.required,
+            rule: v.validationRule,
+            found,
+            details: found
+                ? validation.details
+                : validation.details
+        });
+    }
+    const passed = findings.every((f) => !f.required || f.found);
+    return { stage, file: relFile, passed, findings };
+}
+export async function lintAllArtifacts(projectRoot) {
+    const out = [];
+    for (const schema of orderedStageSchemas()) {
+        out.push(await lintArtifact(projectRoot, schema.stage));
+    }
+    return out;
+}
+function isNonEmptyString(v) {
+    return typeof v === "string" && v.length > 0;
+}
+function isFiniteNumber(v) {
+    return typeof v === "number" && Number.isFinite(v);
+}
+function isNonNegativeInteger(v) {
+    return Number.isInteger(v) && v >= 0;
+}
+function isStringArray(v) {
+    return Array.isArray(v) && v.every((item) => typeof item === "string");
+}
+export async function validateReviewArmy(projectRoot) {
+    const errors = [];
+    const { absPath, relPath } = await resolveArtifactPath(projectRoot, "07-review-army.json");
+    if (!(await exists(absPath))) {
+        return { valid: false, errors: [`Missing file: ${relPath}`] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await fs.readFile(absPath, "utf8"));
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { valid: false, errors: [`Invalid JSON: ${msg}`] };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { valid: false, errors: ["Root value must be a JSON object."] };
+    }
+    const root = parsed;
+    if (!("version" in root) || !isFiniteNumber(root.version) || root.version < 1) {
+        errors.push('Field "version" must be a finite number >= 1.');
+    }
+    if (!isNonEmptyString(root.generatedAt)) {
+        errors.push('Field "generatedAt" must be a non-empty string.');
+    }
+    if (!("scope" in root) || root.scope === null || typeof root.scope !== "object" || Array.isArray(root.scope)) {
+        errors.push('Field "scope" must be an object.');
+    }
+    else {
+        const scope = root.scope;
+        if (!isNonEmptyString(scope.base)) {
+            errors.push("scope.base must be a non-empty string.");
+        }
+        if (!isNonEmptyString(scope.head)) {
+            errors.push("scope.head must be a non-empty string.");
+        }
+        if (!isStringArray(scope.files)) {
+            errors.push("scope.files must be an array of strings.");
+        }
+    }
+    const severitySet = new Set(["Critical", "Important", "Suggestion"]);
+    const statusSet = new Set(["open", "accepted", "resolved"]);
+    const findingIds = new Set();
+    const openCriticalIds = new Set();
+    if (!Array.isArray(root.findings)) {
+        errors.push('Field "findings" must be an array.');
+    }
+    else {
+        root.findings.forEach((f, i) => {
+            if (f === null || typeof f !== "object" || Array.isArray(f)) {
+                errors.push(`findings[${i}] must be an object.`);
+                return;
+            }
+            const o = f;
+            if (!isNonEmptyString(o.id)) {
+                errors.push(`findings[${i}].id must be a non-empty string.`);
+            }
+            else if (findingIds.has(o.id)) {
+                errors.push(`findings[${i}].id must be unique.`);
+            }
+            else {
+                findingIds.add(o.id);
+            }
+            if (!isNonEmptyString(o.severity) || !severitySet.has(o.severity)) {
+                errors.push(`findings[${i}].severity must be one of: Critical, Important, Suggestion.`);
+            }
+            if (!isNonEmptyString(o.status) || !statusSet.has(o.status)) {
+                errors.push(`findings[${i}].status must be one of: open, accepted, resolved.`);
+            }
+            if (!isNonEmptyString(o.fingerprint)) {
+                errors.push(`findings[${i}].fingerprint must be a non-empty string.`);
+            }
+            if (!isFiniteNumber(o.confidence) || o.confidence < 1 || o.confidence > 10) {
+                errors.push(`findings[${i}].confidence must be a number in [1,10].`);
+            }
+            if (!isStringArray(o.reportedBy) || o.reportedBy.length === 0) {
+                errors.push(`findings[${i}].reportedBy must be a non-empty string array.`);
+            }
+            if (o.location !== undefined) {
+                if (o.location === null || typeof o.location !== "object" || Array.isArray(o.location)) {
+                    errors.push(`findings[${i}].location must be an object when present.`);
+                }
+                else {
+                    const loc = o.location;
+                    if (!isNonEmptyString(loc.file)) {
+                        errors.push(`findings[${i}].location.file must be a non-empty string.`);
+                    }
+                    if (!isFiniteNumber(loc.line) || loc.line < 1) {
+                        errors.push(`findings[${i}].location.line must be a positive number.`);
+                    }
+                }
+            }
+            if (o.recommendation !== undefined && !isNonEmptyString(o.recommendation)) {
+                errors.push(`findings[${i}].recommendation must be a non-empty string when present.`);
+            }
+            if (o.severity === "Critical" && o.status === "open" && !isNonEmptyString(o.recommendation)) {
+                errors.push(`findings[${i}] open Critical finding must include recommendation.`);
+            }
+            if (o.id && o.severity === "Critical" && o.status === "open" && typeof o.id === "string") {
+                openCriticalIds.add(o.id);
+            }
+        });
+    }
+    if (!("reconciliation" in root) || root.reconciliation === null || typeof root.reconciliation !== "object") {
+        errors.push('Field "reconciliation" must be an object.');
+    }
+    else {
+        const rec = root.reconciliation;
+        if (!isNonNegativeInteger(rec.duplicatesCollapsed)) {
+            errors.push("reconciliation.duplicatesCollapsed must be a non-negative integer.");
+        }
+        if (!Array.isArray(rec.conflicts)) {
+            errors.push("reconciliation.conflicts must be an array.");
+        }
+        if (!isStringArray(rec.multiSpecialistConfirmed)) {
+            errors.push("reconciliation.multiSpecialistConfirmed must be an array of finding ids.");
+        }
+        if (!isStringArray(rec.shipBlockers)) {
+            errors.push("reconciliation.shipBlockers must be an array of finding ids.");
+        }
+        else {
+            const blockers = new Set(rec.shipBlockers);
+            for (const id of rec.shipBlockers) {
+                if (!findingIds.has(id)) {
+                    errors.push(`reconciliation.shipBlockers references unknown finding id "${id}".`);
+                }
+            }
+            for (const criticalId of openCriticalIds) {
+                if (!blockers.has(criticalId)) {
+                    errors.push(`reconciliation.shipBlockers must include open Critical finding "${criticalId}".`);
+                }
+            }
+        }
+        if (isStringArray(rec.multiSpecialistConfirmed)) {
+            for (const id of rec.multiSpecialistConfirmed) {
+                if (!findingIds.has(id)) {
+                    errors.push(`reconciliation.multiSpecialistConfirmed references unknown finding id "${id}".`);
+                }
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}

package/dist/cli.d.ts

@@ -4,6 +4,7 @@ type CommandName = "init" | "sync" | "doctor" | "upgrade" | "uninstall";
 interface ParsedArgs {
     command?: CommandName;
     harnesses?: HarnessId[];
+    reconcileGates?: boolean;
 }
 declare function parseHarnesses(raw: string): HarnessId[];
 declare function parseArgs(argv: string[]): ParsedArgs;

package/dist/cli.js

@@ -14,7 +14,7 @@ function usage() {
 Usage:
   cclaw init [--harnesses=claude,cursor,opencode,codex]
   cclaw sync
-  cclaw doctor
+  cclaw doctor [--reconcile-gates]
   cclaw upgrade
   cclaw uninstall
 `;
@@ -39,6 +39,10 @@ function parseArgs(argv) {
     for (const flag of flags) {
         if (flag.startsWith("--harnesses=")) {
             parsed.harnesses = parseHarnesses(flag.replace("--harnesses=", ""));
+            continue;
+        }
+        if (flag === "--reconcile-gates") {
+            parsed.reconcileGates = true;
         }
     }
     return parsed;
@@ -63,7 +67,9 @@ async function runCommand(parsed, ctx) {
         return 0;
     }
     if (command === "doctor") {
-        const checks = await doctorChecks(ctx.cwd);
+        const checks = await doctorChecks(ctx.cwd, {
+            reconcileCurrentStageGates: parsed.reconcileGates === true
+        });
         for (const check of checks) {
             ctx.stdout.write(`${check.ok ? "PASS" : "FAIL"} ${check.name} :: ${check.details}\n`);
         }

package/dist/config.d.ts

@@ -1,5 +1,5 @@
-import type { HarnessId, CclawConfig } from "./types.js";
+import type { HarnessId, VibyConfig } from "./types.js";
 export declare function configPath(projectRoot: string): string;
-export declare function createDefaultConfig(harnesses?: HarnessId[]): CclawConfig;
-export declare function readConfig(projectRoot: string): Promise<CclawConfig>;
-export declare function writeConfig(projectRoot: string, config: CclawConfig): Promise<void>;
+export declare function createDefaultConfig(harnesses?: HarnessId[]): VibyConfig;
+export declare function readConfig(projectRoot: string): Promise<VibyConfig>;
+export declare function writeConfig(projectRoot: string, config: VibyConfig): Promise<void>;

package/dist/config.js

@@ -1,17 +1,26 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { parse, stringify } from "yaml";
-import { DEFAULT_HARNESSES, FLOW_VERSION, RUNTIME_ROOT, CCLAW_VERSION } from "./constants.js";
+import { CCLAW_VERSION, DEFAULT_HARNESSES, FLOW_VERSION, RUNTIME_ROOT } from "./constants.js";
 import { exists, writeFileSafe } from "./fs-utils.js";
 import { HARNESS_IDS } from "./types.js";
 const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
 const HARNESS_ID_SET = new Set(HARNESS_IDS);
 const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
+const ALLOWED_CONFIG_KEYS = new Set([
+    "version",
+    "flowVersion",
+    "harnesses",
+    "autoAdvance",
+    "globalLearnings",
+    "globalLearningsPath",
+    "promptGuardMode",
+    "gitHookGuards"
+]);
 function configFixExample() {
     return `harnesses:
   - claude
-  - cursor
-`;
+  - cursor`;
 }
 function configValidationError(configFilePath, reason) {
     return new Error(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
@@ -26,7 +35,11 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES) {
     return {
         version: CCLAW_VERSION,
         flowVersion: FLOW_VERSION,
-        harnesses
+        harnesses,
+        autoAdvance: false,
+        globalLearnings: false,
+        promptGuardMode: "advisory",
+        gitHookGuards: false
     };
 }
 export async function readConfig(projectRoot) {
@@ -44,6 +57,10 @@ export async function readConfig(projectRoot) {
     const parsed = (parsedUnknown && typeof parsedUnknown === "object"
         ? parsedUnknown
         : {});
+    const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
+    if (unknownKeys.length > 0) {
+        throw configValidationError(fullPath, `unknown top-level key(s): ${unknownKeys.join(", ")}`);
+    }
     const hasHarnessesField = Object.prototype.hasOwnProperty.call(parsed, "harnesses");
     if (hasHarnessesField && !Array.isArray(parsed.harnesses)) {
         throw configValidationError(fullPath, `"harnesses" must be an array`);
@@ -60,10 +77,44 @@ export async function readConfig(projectRoot) {
     const harnesses = hasHarnessesField
         ? [...new Set(validatedHarnesses)]
         : DEFAULT_HARNESSES;
+    const autoAdvanceRaw = parsed.autoAdvance;
+    const autoAdvance = typeof autoAdvanceRaw === "boolean" ? autoAdvanceRaw : false;
+    const globalLearningsRaw = parsed.globalLearnings;
+    if (Object.prototype.hasOwnProperty.call(parsed, "globalLearnings") &&
+        typeof globalLearningsRaw !== "boolean") {
+        throw configValidationError(fullPath, `"globalLearnings" must be a boolean`);
+    }
+    const globalLearnings = typeof globalLearningsRaw === "boolean" ? globalLearningsRaw : false;
+    const globalLearningsPathRaw = parsed.globalLearningsPath;
+    if (Object.prototype.hasOwnProperty.call(parsed, "globalLearningsPath") &&
+        typeof globalLearningsPathRaw !== "string") {
+        throw configValidationError(fullPath, `"globalLearningsPath" must be a string`);
+    }
+    const globalLearningsPath = typeof globalLearningsPathRaw === "string" && globalLearningsPathRaw.trim().length > 0
+        ? globalLearningsPathRaw.trim()
+        : undefined;
+    const promptGuardModeRaw = parsed.promptGuardMode;
+    if (Object.prototype.hasOwnProperty.call(parsed, "promptGuardMode") &&
+        promptGuardModeRaw !== "advisory" &&
+        promptGuardModeRaw !== "strict") {
+        throw configValidationError(fullPath, `"promptGuardMode" must be "advisory" or "strict"`);
+    }
+    const promptGuardMode = promptGuardModeRaw === "strict" ? "strict" : "advisory";
+    const gitHookGuardsRaw = parsed.gitHookGuards;
+    if (Object.prototype.hasOwnProperty.call(parsed, "gitHookGuards") &&
+        typeof gitHookGuardsRaw !== "boolean") {
+        throw configValidationError(fullPath, `"gitHookGuards" must be a boolean`);
+    }
+    const gitHookGuards = typeof gitHookGuardsRaw === "boolean" ? gitHookGuardsRaw : false;
     return {
         version: parsed.version ?? CCLAW_VERSION,
         flowVersion: parsed.flowVersion ?? FLOW_VERSION,
-        harnesses
+        harnesses,
+        autoAdvance,
+        globalLearnings,
+        globalLearningsPath,
+        promptGuardMode,
+        gitHookGuards
     };
 }
 export async function writeConfig(projectRoot, config) {

package/dist/constants.d.ts

@@ -1,12 +1,12 @@
 import type { FlowStage, HarnessId } from "./types.js";
 /** Hidden runtime directory at project root (dot-prefixed). */
 export declare const RUNTIME_ROOT = ".cclaw";
-export declare const CCLAW_VERSION = "0.1.0";
+export declare const CCLAW_VERSION = "0.1.1";
 export declare const FLOW_VERSION = "1.0.0";
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks"];
-export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".cursor/commands/cc-*.md", ".opencode/commands/cc-*.md", ".codex/commands/cc-*.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks"];
+export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".cursor/commands/cc-*.md", ".opencode/commands/cc-*.md", ".codex/commands/cc-*.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
-export declare const UTILITY_COMMANDS: readonly ["learn", "autoplan"];
+export declare const UTILITY_COMMANDS: readonly ["learn", "autoplan", "next"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
 export type UtilityCommand = (typeof UTILITY_COMMANDS)[number];

package/dist/constants.js

@@ -1,6 +1,6 @@
 /** Hidden runtime directory at project root (dot-prefixed). */
 export const RUNTIME_ROOT = ".cclaw";
-export const CCLAW_VERSION = "0.1.0";
+export const CCLAW_VERSION = "0.1.1";
 export const FLOW_VERSION = "1.0.0";
 export const DEFAULT_HARNESSES = [
     "claude",
@@ -12,6 +12,7 @@ export const REQUIRED_DIRS = [
     RUNTIME_ROOT,
     `${RUNTIME_ROOT}/commands`,
     `${RUNTIME_ROOT}/skills`,
+    `${RUNTIME_ROOT}/contexts`,
     `${RUNTIME_ROOT}/templates`,
     `${RUNTIME_ROOT}/artifacts`,
     `${RUNTIME_ROOT}/state`,
@@ -30,7 +31,9 @@ export const REQUIRED_GITIGNORE_PATTERNS = [
     ".codex/commands/cc-*.md",
     ".claude/hooks/hooks.json",
     ".cursor/hooks.json",
-    ".codex/hooks.json"
+    ".codex/hooks.json",
+    ".opencode/plugins/cclaw-plugin.mjs",
+    ".cursor/rules/cclaw-workflow.mdc"
 ];
 export const COMMAND_FILE_ORDER = [
     "brainstorm",
@@ -43,7 +46,7 @@ export const COMMAND_FILE_ORDER = [
     "review",
     "ship"
 ];
-export const UTILITY_COMMANDS = ["learn", "autoplan"];
+export const UTILITY_COMMANDS = ["learn", "autoplan", "next"];
 export const SUBAGENT_SKILL_FOLDERS = [
     "subagent-dev",
     "parallel-dispatch"