cclaw-cli 7.7.1 → 8.1.1

package/dist/compound.js

@@ -0,0 +1,96 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ARTIFACT_FILE_NAMES, activeArtifactDir, activeArtifactPath, shippedArtifactDir, shippedArtifactPath } from "./artifact-paths.js";
+import { FLOWS_ROOT } from "./constants.js";
+import { exists, ensureDir, removePath, writeFileSafe } from "./fs-utils.js";
+import { readFlowState, resetFlowState, writeFlowState } from "./run-persistence.js";
+import { manifestTemplate, templateBody } from "./content/artifact-templates.js";
+import { appendKnowledgeEntry } from "./knowledge-store.js";
+export class CompoundError extends Error {
+}
+export function shouldCaptureLearning(signals) {
+    if (signals.userRequestedCapture)
+        return true;
+    if (signals.hasArchitectDecision)
+        return true;
+    if (signals.reviewIterations >= 3)
+        return true;
+    if (signals.securityFlag)
+        return true;
+    return false;
+}
+function pendingAc(ac) {
+    return ac.filter((item) => item.status !== "committed");
+}
+async function moveIfExists(source, destination) {
+    if (!(await exists(source)))
+        return false;
+    await ensureDir(path.dirname(destination));
+    await fs.rename(source, destination);
+    return true;
+}
+function renderManifest(slug, shipCommit, shippedAt, ac, moved, refines) {
+    const base = manifestTemplate(slug, shipCommit, shippedAt);
+    const acLines = ac
+        .map((item) => `- ${item.id}: ${item.text}${item.commit ? ` (commit ${item.commit})` : ""}`)
+        .join("\n");
+    const movedLines = moved.map((stage) => `- ${ARTIFACT_FILE_NAMES[stage]}`).join("\n");
+    const refinesBlock = refines
+        ? `## Refines\n\nThis run refines [${refines}](../${refines}/manifest.md).\n`
+        : "";
+    return base
+        .replace(/## Acceptance Criteria[\s\S]*?(?=\n## Artifacts)/u, `## Acceptance Criteria\n\n${acLines}\n\n`)
+        .replace(/## Artifacts[\s\S]*?(?=\n## Refines)/u, `## Artifacts\n\n${movedLines}\n\n`)
+        .replace(/## Refines[\s\S]*?(?=\n## Knowledge index)/u, refinesBlock || `## Refines\n\n_None._\n\n`);
+}
+export async function runCompoundAndShip(projectRoot, options) {
+    const state = await readFlowState(projectRoot);
+    if (!state.currentSlug)
+        throw new CompoundError("No active slug; cannot ship.");
+    const slug = state.currentSlug;
+    const pending = pendingAc(state.ac);
+    if (pending.length > 0) {
+        throw new CompoundError(`Cannot ship ${slug}: AC traceability gate failed. Pending AC: ${pending.map((item) => item.id).join(", ")}.`);
+    }
+    const shippedAt = new Date().toISOString();
+    const learningCaptured = shouldCaptureLearning(options.signals);
+    let knowledgeEntry;
+    if (learningCaptured) {
+        const learningPath = activeArtifactPath(projectRoot, "learnings", slug);
+        if (!(await exists(learningPath))) {
+            await writeFileSafe(learningPath, templateBody("learnings", { "SLUG-PLACEHOLDER": slug }));
+        }
+        knowledgeEntry = {
+            slug,
+            ship_commit: options.shipCommit,
+            shipped_at: shippedAt,
+            signals: { ...options.signals },
+            refines: options.refines ?? null,
+            notes: options.notes
+        };
+        await appendKnowledgeEntry(projectRoot, knowledgeEntry);
+    }
+    await writeFlowState(projectRoot, { ...state, currentStage: "ship" });
+    const shippedDir = shippedArtifactDir(projectRoot, slug);
+    await ensureDir(shippedDir);
+    const moved = [];
+    const allStages = ["plan", "build", "review", "ship", "decisions", "learnings"];
+    for (const stage of allStages) {
+        const source = activeArtifactPath(projectRoot, stage, slug);
+        const destination = shippedArtifactPath(projectRoot, slug, stage);
+        if (await moveIfExists(source, destination))
+            moved.push(stage);
+    }
+    await writeFileSafe(path.join(shippedDir, "manifest.md"), renderManifest(slug, options.shipCommit, shippedAt, state.ac, moved, options.refines));
+    const activeDir = activeArtifactDir(projectRoot, slug);
+    if (await exists(activeDir)) {
+        const remaining = await fs.readdir(activeDir);
+        if (remaining.length === 0)
+            await removePath(activeDir);
+    }
+    await resetFlowState(projectRoot);
+    return { slug, shippedDir, learningCaptured, movedArtifacts: moved, knowledgeEntry };
+}
+export async function defaultPathsToCheck(projectRoot) {
+    return [path.join(projectRoot, FLOWS_ROOT)];
+}

package/dist/config.d.ts

@@ -1,51 +1,14 @@
-import type { CclawConfig, ExecutionStrictnessProfile, ExecutionTopology, FlowTrack, HarnessId, LanguageRulePack, LockfileTwinPolicy, PlanMicroTaskPolicy, PlanSliceGranularity, TddCommitMode, TddIsolationMode } from "./types.js";
-export declare const TDD_COMMIT_MODES: readonly ["managed-per-slice", "agent-required", "checkpoint-only", "off"];
-export declare const DEFAULT_TDD_COMMIT_MODE: TddCommitMode;
-export declare const TDD_ISOLATION_MODES: readonly ["worktree", "in-place", "auto"];
-export declare const DEFAULT_TDD_ISOLATION_MODE: TddIsolationMode;
-export declare const DEFAULT_TDD_WORKTREE_ROOT = ".cclaw/worktrees";
-export declare const LOCKFILE_TWIN_POLICIES: readonly ["auto-include", "auto-revert", "strict-fence"];
-export declare const DEFAULT_LOCKFILE_TWIN_POLICY: LockfileTwinPolicy;
-export declare const EXECUTION_TOPOLOGIES: readonly ["auto", "inline", "single-builder", "parallel-builders", "strict-micro"];
-export declare const DEFAULT_EXECUTION_TOPOLOGY: ExecutionTopology;
-export declare const EXECUTION_STRICTNESS_PROFILES: readonly ["fast", "balanced", "strict"];
-export declare const DEFAULT_EXECUTION_STRICTNESS: ExecutionStrictnessProfile;
-export declare const DEFAULT_MAX_BUILDERS = 5;
-export declare const PLAN_SLICE_GRANULARITIES: readonly ["feature-atomic", "strict-micro"];
-export declare const DEFAULT_PLAN_SLICE_GRANULARITY: PlanSliceGranularity;
-export declare const PLAN_MICRO_TASK_POLICIES: readonly ["advisory", "strict"];
-export declare const DEFAULT_PLAN_MICRO_TASK_POLICY: PlanMicroTaskPolicy;
-export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
-export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
-export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
-export declare const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
-export declare const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
-export interface ConfigWarningState {
-    emitted: Set<string>;
-}
-export interface ReadConfigOptions {
-    warningState?: ConfigWarningState;
-}
-export declare function createConfigWarningState(): ConfigWarningState;
-export declare class InvalidConfigError extends Error {
-    constructor(message: string);
-}
-export declare function configPath(projectRoot: string): string;
-export declare function createDefaultConfig(harnesses?: HarnessId[], _defaultTrack?: FlowTrack): CclawConfig;
-export declare function resolveTddCommitMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddCommitMode;
-export declare function resolveTddIsolationMode(config: Pick<CclawConfig, "tdd"> | null | undefined): TddIsolationMode;
-export declare function resolveTddWorktreeRoot(config: Pick<CclawConfig, "tdd"> | null | undefined): string;
-export declare function resolveLockfileTwinPolicy(config: Pick<CclawConfig, "tdd"> | null | undefined): LockfileTwinPolicy;
-export declare function resolveExecutionTopology(config: Pick<CclawConfig, "execution"> | null | undefined): ExecutionTopology;
-export declare function resolveExecutionStrictness(config: Pick<CclawConfig, "execution"> | null | undefined): ExecutionStrictnessProfile;
-export declare function resolveMaxBuilders(config: Pick<CclawConfig, "execution"> | null | undefined): number;
-export declare function resolvePlanSliceGranularity(config: Pick<CclawConfig, "plan"> | null | undefined): PlanSliceGranularity;
-export declare function resolvePlanMicroTaskPolicy(config: Pick<CclawConfig, "plan"> | null | undefined): PlanMicroTaskPolicy;
-export declare function detectLanguageRulePacks(_projectRoot: string): Promise<LanguageRulePack[]>;
-export declare function readConfig(projectRoot: string, _options?: ReadConfigOptions): Promise<CclawConfig>;
-export interface WriteConfigOptions {
-    mode?: "full" | "minimal";
-    advancedKeysPresent?: ReadonlySet<never>;
-}
-export declare function writeConfig(projectRoot: string, config: CclawConfig, _options?: WriteConfigOptions): Promise<void>;
-export declare function detectAdvancedKeys(_projectRoot: string): Promise<ReadonlySet<never>>;
+import { type HarnessId } from "./types.js";
+export type HookProfile = "minimal" | "strict";
+export interface CclawConfig {
+    version: string;
+    flowVersion: "8";
+    harnesses: HarnessId[];
+    hooks: {
+        profile: HookProfile;
+    };
+}
+export declare function createDefaultConfig(harnesses?: HarnessId[]): CclawConfig;
+export declare function validateHarnesses(value: string[]): HarnessId[];
+export declare function renderConfig(config: CclawConfig): string;
+export declare function readConfig(projectRoot: string): Promise<CclawConfig | null>;

package/dist/config.js

@@ -1,374 +1,38 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { parse, stringify } from "yaml";
-import { CCLAW_VERSION, DEFAULT_HARNESSES, FLOW_VERSION, RUNTIME_ROOT } from "./constants.js";
-import { exists, writeFileSafe } from "./fs-utils.js";
+import YAML from "yaml";
+import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
 import { HARNESS_IDS } from "./types.js";
-const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
-const HARNESS_ID_SET = new Set(HARNESS_IDS);
-const ALLOWED_CONFIG_KEYS = new Set([
-    "version",
-    "flowVersion",
-    "harnesses",
-    "tdd",
-    "execution",
-    "plan"
-]);
-const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
-export const TDD_COMMIT_MODES = [
-    "managed-per-slice",
-    "agent-required",
-    "checkpoint-only",
-    "off"
-];
-const TDD_COMMIT_MODE_SET = new Set(TDD_COMMIT_MODES);
-export const DEFAULT_TDD_COMMIT_MODE = "managed-per-slice";
-export const TDD_ISOLATION_MODES = ["worktree", "in-place", "auto"];
-const TDD_ISOLATION_MODE_SET = new Set(TDD_ISOLATION_MODES);
-export const DEFAULT_TDD_ISOLATION_MODE = "worktree";
-export const DEFAULT_TDD_WORKTREE_ROOT = `${RUNTIME_ROOT}/worktrees`;
-export const LOCKFILE_TWIN_POLICIES = ["auto-include", "auto-revert", "strict-fence"];
-const LOCKFILE_TWIN_POLICY_SET = new Set(LOCKFILE_TWIN_POLICIES);
-export const DEFAULT_LOCKFILE_TWIN_POLICY = "auto-include";
-export const EXECUTION_TOPOLOGIES = [
-    "auto",
-    "inline",
-    "single-builder",
-    "parallel-builders",
-    "strict-micro"
-];
-const EXECUTION_TOPOLOGY_SET = new Set(EXECUTION_TOPOLOGIES);
-export const DEFAULT_EXECUTION_TOPOLOGY = "auto";
-export const EXECUTION_STRICTNESS_PROFILES = ["fast", "balanced", "strict"];
-const EXECUTION_STRICTNESS_PROFILE_SET = new Set(EXECUTION_STRICTNESS_PROFILES);
-export const DEFAULT_EXECUTION_STRICTNESS = "balanced";
-export const DEFAULT_MAX_BUILDERS = 5;
-export const PLAN_SLICE_GRANULARITIES = ["feature-atomic", "strict-micro"];
-const PLAN_SLICE_GRANULARITY_SET = new Set(PLAN_SLICE_GRANULARITIES);
-export const DEFAULT_PLAN_SLICE_GRANULARITY = "feature-atomic";
-export const PLAN_MICRO_TASK_POLICIES = ["advisory", "strict"];
-const PLAN_MICRO_TASK_POLICY_SET = new Set(PLAN_MICRO_TASK_POLICIES);
-export const DEFAULT_PLAN_MICRO_TASK_POLICY = "advisory";
-// Kept for runtime modules that use these defaults directly.
-export const DEFAULT_TDD_TEST_PATH_PATTERNS = [
-    "**/*.test.*",
-    "**/tests/**",
-    "**/__tests__/**"
-];
-export const DEFAULT_TDD_TEST_GLOBS = [...DEFAULT_TDD_TEST_PATH_PATTERNS];
-export const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS = [];
-export const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
-export const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
-export function createConfigWarningState() {
-    return { emitted: new Set() };
-}
-export class InvalidConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "InvalidConfigError";
-    }
-}
-function configFixExample() {
-    return `harnesses:
-  - claude
-  - cursor
-tdd:
-  commitMode: managed-per-slice
-  isolationMode: worktree
-  worktreeRoot: .cclaw/worktrees
-execution:
-  topology: auto
-  strictness: balanced
-  maxBuilders: 5
-plan:
-  sliceGranularity: feature-atomic
-  microTaskPolicy: advisory`;
-}
-function configValidationError(configFilePath, reason) {
-    return new InvalidConfigError(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
-        `Supported harnesses: ${SUPPORTED_HARNESSES_TEXT}\n` +
-        `Example config:\n${configFixExample()}\n` +
-        `After fixing, run: cclaw sync`);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function configPath(projectRoot) {
-    return path.join(projectRoot, CONFIG_PATH);
-}
-export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, _defaultTrack = "standard") {
+export function createDefaultConfig(harnesses = ["cursor"]) {
     return {
         version: CCLAW_VERSION,
-        flowVersion: FLOW_VERSION,
-        harnesses: [...new Set(harnesses)],
-        tdd: {
-            commitMode: DEFAULT_TDD_COMMIT_MODE,
-            isolationMode: DEFAULT_TDD_ISOLATION_MODE,
-            worktreeRoot: DEFAULT_TDD_WORKTREE_ROOT,
-            lockfileTwinPolicy: DEFAULT_LOCKFILE_TWIN_POLICY
-        },
-        execution: {
-            topology: DEFAULT_EXECUTION_TOPOLOGY,
-            strictness: DEFAULT_EXECUTION_STRICTNESS,
-            maxBuilders: DEFAULT_MAX_BUILDERS
-        },
-        plan: {
-            sliceGranularity: DEFAULT_PLAN_SLICE_GRANULARITY,
-            microTaskPolicy: DEFAULT_PLAN_MICRO_TASK_POLICY
-        }
+        flowVersion: "8",
+        harnesses,
+        hooks: { profile: "minimal" }
     };
 }
-export function resolveTddCommitMode(config) {
-    const raw = config?.tdd?.commitMode;
-    if (typeof raw === "string" && TDD_COMMIT_MODE_SET.has(raw)) {
-        return raw;
-    }
-    return DEFAULT_TDD_COMMIT_MODE;
-}
-export function resolveTddIsolationMode(config) {
-    const raw = config?.tdd?.isolationMode;
-    if (typeof raw === "string" && TDD_ISOLATION_MODE_SET.has(raw)) {
-        return raw;
+export function validateHarnesses(value) {
+    if (value.length === 0) {
+        throw new Error("At least one harness must be selected.");
     }
-    return DEFAULT_TDD_ISOLATION_MODE;
-}
-export function resolveTddWorktreeRoot(config) {
-    const raw = config?.tdd?.worktreeRoot;
-    if (typeof raw === "string" && raw.trim().length > 0) {
-        return raw.trim();
-    }
-    return DEFAULT_TDD_WORKTREE_ROOT;
-}
-export function resolveLockfileTwinPolicy(config) {
-    const raw = config?.tdd?.lockfileTwinPolicy;
-    if (typeof raw === "string" && LOCKFILE_TWIN_POLICY_SET.has(raw)) {
-        return raw;
+    const invalid = value.filter((item) => !HARNESS_IDS.includes(item));
+    if (invalid.length > 0) {
+        throw new Error(`Unknown harnesses: ${invalid.join(", ")}. Supported: ${HARNESS_IDS.join(", ")}`);
     }
-    return DEFAULT_LOCKFILE_TWIN_POLICY;
-}
-export function resolveExecutionTopology(config) {
-    const raw = config?.execution?.topology;
-    if (typeof raw === "string" && EXECUTION_TOPOLOGY_SET.has(raw)) {
-        return raw;
-    }
-    return DEFAULT_EXECUTION_TOPOLOGY;
-}
-export function resolveExecutionStrictness(config) {
-    const raw = config?.execution?.strictness;
-    if (typeof raw === "string" && EXECUTION_STRICTNESS_PROFILE_SET.has(raw)) {
-        return raw;
-    }
-    return DEFAULT_EXECUTION_STRICTNESS;
-}
-export function resolveMaxBuilders(config) {
-    const raw = config?.execution?.maxBuilders;
-    if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1) {
-        return raw;
-    }
-    return DEFAULT_MAX_BUILDERS;
-}
-export function resolvePlanSliceGranularity(config) {
-    const raw = config?.plan?.sliceGranularity;
-    if (typeof raw === "string" && PLAN_SLICE_GRANULARITY_SET.has(raw)) {
-        return raw;
-    }
-    return DEFAULT_PLAN_SLICE_GRANULARITY;
-}
-export function resolvePlanMicroTaskPolicy(config) {
-    const raw = config?.plan?.microTaskPolicy;
-    if (typeof raw === "string" && PLAN_MICRO_TASK_POLICY_SET.has(raw)) {
-        return raw;
-    }
-    return DEFAULT_PLAN_MICRO_TASK_POLICY;
-}
-function assertOnlySupportedKeys(parsed, fullPath) {
-    const unknownKeys = Object.keys(parsed).filter((key) => !ALLOWED_CONFIG_KEYS.has(key));
-    if (unknownKeys.length === 0)
-        return;
-    const keyList = unknownKeys.join(", ");
-    throw configValidationError(fullPath, `key(s) ${keyList} are no longer supported in cclaw 3.0.0; see CHANGELOG.md`);
+    return value;
 }
-export async function detectLanguageRulePacks(_projectRoot) {
-    // Harness-only config. Language packs are no longer configurable.
-    return [];
+export function renderConfig(config) {
+    return YAML.stringify(config);
 }
-export async function readConfig(projectRoot, _options = {}) {
-    const fullPath = configPath(projectRoot);
-    if (!(await exists(fullPath))) {
-        return createDefaultConfig();
-    }
-    let parsedUnknown;
+export async function readConfig(projectRoot) {
+    const configPath = path.join(projectRoot, RUNTIME_ROOT, "config.yaml");
     try {
-        parsedUnknown = parse(await fs.readFile(fullPath, "utf8"));
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : "unknown parse error";
-        throw configValidationError(fullPath, `failed to parse YAML (${reason})`);
-    }
-    if (parsedUnknown !== null && parsedUnknown !== undefined && !isRecord(parsedUnknown)) {
-        throw configValidationError(fullPath, "top-level config must be a YAML mapping/object");
-    }
-    const parsed = (isRecord(parsedUnknown) ? parsedUnknown : {});
-    assertOnlySupportedKeys(parsed, fullPath);
-    if (Object.prototype.hasOwnProperty.call(parsed, "harnesses") &&
-        !Array.isArray(parsed.harnesses)) {
-        throw configValidationError(fullPath, `"harnesses" must be an array`);
-    }
-    if (Object.prototype.hasOwnProperty.call(parsed, "tdd") &&
-        !isRecord(parsed.tdd)) {
-        throw configValidationError(fullPath, `"tdd" must be an object when provided`);
-    }
-    if (Object.prototype.hasOwnProperty.call(parsed, "execution") &&
-        !isRecord(parsed.execution)) {
-        throw configValidationError(fullPath, `"execution" must be an object when provided`);
-    }
-    if (Object.prototype.hasOwnProperty.call(parsed, "plan") &&
-        !isRecord(parsed.plan)) {
-        throw configValidationError(fullPath, `"plan" must be an object when provided`);
-    }
-    const rawHarnesses = Array.isArray(parsed.harnesses) ? parsed.harnesses : DEFAULT_HARNESSES;
-    const normalizedHarnesses = [];
-    for (const harness of rawHarnesses) {
-        if (typeof harness !== "string" || !HARNESS_ID_SET.has(harness)) {
-            throw configValidationError(fullPath, `unknown harness id "${String(harness)}"`);
-        }
-        if (!normalizedHarnesses.includes(harness)) {
-            normalizedHarnesses.push(harness);
-        }
-    }
-    if (normalizedHarnesses.length === 0) {
-        throw configValidationError(fullPath, `"harnesses" must include at least one harness`);
-    }
-    const version = typeof parsed.version === "string" && parsed.version.trim().length > 0
-        ? parsed.version
-        : CCLAW_VERSION;
-    const flowVersion = typeof parsed.flowVersion === "string" && parsed.flowVersion.trim().length > 0
-        ? parsed.flowVersion
-        : FLOW_VERSION;
-    const parsedTdd = isRecord(parsed.tdd) ? parsed.tdd : {};
-    const rawCommitMode = parsedTdd.commitMode;
-    const rawIsolationMode = parsedTdd.isolationMode;
-    const rawWorktreeRoot = parsedTdd.worktreeRoot;
-    const rawLockfileTwinPolicy = parsedTdd.lockfileTwinPolicy;
-    const parsedExecution = isRecord(parsed.execution) ? parsed.execution : {};
-    const rawExecutionTopology = parsedExecution.topology;
-    const rawExecutionStrictness = parsedExecution.strictness;
-    const rawMaxBuilders = parsedExecution.maxBuilders;
-    const parsedPlan = isRecord(parsed.plan) ? parsed.plan : {};
-    const rawPlanSliceGranularity = parsedPlan.sliceGranularity;
-    const rawPlanMicroTaskPolicy = parsedPlan.microTaskPolicy;
-    if (rawCommitMode !== undefined &&
-        (typeof rawCommitMode !== "string" || !TDD_COMMIT_MODE_SET.has(rawCommitMode))) {
-        throw configValidationError(fullPath, `"tdd.commitMode" must be one of: ${TDD_COMMIT_MODES.join(", ")}`);
-    }
-    if (rawIsolationMode !== undefined &&
-        (typeof rawIsolationMode !== "string" || !TDD_ISOLATION_MODE_SET.has(rawIsolationMode))) {
-        throw configValidationError(fullPath, `"tdd.isolationMode" must be one of: ${TDD_ISOLATION_MODES.join(", ")}`);
+        const raw = await fs.readFile(configPath, "utf8");
+        return YAML.parse(raw);
     }
-    if (rawWorktreeRoot !== undefined &&
-        (typeof rawWorktreeRoot !== "string" || rawWorktreeRoot.trim().length === 0)) {
-        throw configValidationError(fullPath, `"tdd.worktreeRoot" must be a non-empty string when provided`);
+    catch (err) {
+        if (err instanceof Error && "code" in err && err.code === "ENOENT")
+            return null;
+        throw err;
     }
-    if (rawLockfileTwinPolicy !== undefined &&
-        (typeof rawLockfileTwinPolicy !== "string" || !LOCKFILE_TWIN_POLICY_SET.has(rawLockfileTwinPolicy))) {
-        throw configValidationError(fullPath, `"tdd.lockfileTwinPolicy" must be one of: ${LOCKFILE_TWIN_POLICIES.join(", ")}`);
-    }
-    if (rawExecutionTopology !== undefined &&
-        (typeof rawExecutionTopology !== "string" || !EXECUTION_TOPOLOGY_SET.has(rawExecutionTopology))) {
-        throw configValidationError(fullPath, `"execution.topology" must be one of: ${EXECUTION_TOPOLOGIES.join(", ")}`);
-    }
-    if (rawExecutionStrictness !== undefined &&
-        (typeof rawExecutionStrictness !== "string" ||
-            !EXECUTION_STRICTNESS_PROFILE_SET.has(rawExecutionStrictness))) {
-        throw configValidationError(fullPath, `"execution.strictness" must be one of: ${EXECUTION_STRICTNESS_PROFILES.join(", ")}`);
-    }
-    if (rawMaxBuilders !== undefined &&
-        (!Number.isInteger(rawMaxBuilders) || rawMaxBuilders < 1)) {
-        throw configValidationError(fullPath, `"execution.maxBuilders" must be an integer >= 1 when provided`);
-    }
-    if (rawPlanSliceGranularity !== undefined &&
-        (typeof rawPlanSliceGranularity !== "string" ||
-            !PLAN_SLICE_GRANULARITY_SET.has(rawPlanSliceGranularity))) {
-        throw configValidationError(fullPath, `"plan.sliceGranularity" must be one of: ${PLAN_SLICE_GRANULARITIES.join(", ")}`);
-    }
-    if (rawPlanMicroTaskPolicy !== undefined &&
-        (typeof rawPlanMicroTaskPolicy !== "string" ||
-            !PLAN_MICRO_TASK_POLICY_SET.has(rawPlanMicroTaskPolicy))) {
-        throw configValidationError(fullPath, `"plan.microTaskPolicy" must be one of: ${PLAN_MICRO_TASK_POLICIES.join(", ")}`);
-    }
-    const commitMode = typeof rawCommitMode === "string"
-        ? rawCommitMode
-        : DEFAULT_TDD_COMMIT_MODE;
-    const isolationMode = typeof rawIsolationMode === "string"
-        ? rawIsolationMode
-        : DEFAULT_TDD_ISOLATION_MODE;
-    const worktreeRoot = typeof rawWorktreeRoot === "string" && rawWorktreeRoot.trim().length > 0
-        ? rawWorktreeRoot.trim()
-        : DEFAULT_TDD_WORKTREE_ROOT;
-    const lockfileTwinPolicy = typeof rawLockfileTwinPolicy === "string"
-        ? rawLockfileTwinPolicy
-        : DEFAULT_LOCKFILE_TWIN_POLICY;
-    const executionTopology = typeof rawExecutionTopology === "string"
-        ? rawExecutionTopology
-        : DEFAULT_EXECUTION_TOPOLOGY;
-    const executionStrictness = typeof rawExecutionStrictness === "string"
-        ? rawExecutionStrictness
-        : DEFAULT_EXECUTION_STRICTNESS;
-    const maxBuilders = typeof rawMaxBuilders === "number" &&
-        Number.isInteger(rawMaxBuilders) &&
-        rawMaxBuilders >= 1
-        ? rawMaxBuilders
-        : DEFAULT_MAX_BUILDERS;
-    const planSliceGranularity = typeof rawPlanSliceGranularity === "string"
-        ? rawPlanSliceGranularity
-        : DEFAULT_PLAN_SLICE_GRANULARITY;
-    const planMicroTaskPolicy = typeof rawPlanMicroTaskPolicy === "string"
-        ? rawPlanMicroTaskPolicy
-        : DEFAULT_PLAN_MICRO_TASK_POLICY;
-    return {
-        version,
-        flowVersion,
-        harnesses: normalizedHarnesses,
-        tdd: {
-            commitMode,
-            isolationMode,
-            worktreeRoot,
-            lockfileTwinPolicy
-        },
-        execution: {
-            topology: executionTopology,
-            strictness: executionStrictness,
-            maxBuilders
-        },
-        plan: {
-            sliceGranularity: planSliceGranularity,
-            microTaskPolicy: planMicroTaskPolicy
-        }
-    };
-}
-export async function writeConfig(projectRoot, config, _options = {}) {
-    const serialisable = {
-        version: config.version,
-        flowVersion: config.flowVersion,
-        harnesses: config.harnesses,
-        tdd: {
-            commitMode: resolveTddCommitMode(config),
-            isolationMode: resolveTddIsolationMode(config),
-            worktreeRoot: resolveTddWorktreeRoot(config),
-            lockfileTwinPolicy: resolveLockfileTwinPolicy(config)
-        },
-        execution: {
-            topology: resolveExecutionTopology(config),
-            strictness: resolveExecutionStrictness(config),
-            maxBuilders: resolveMaxBuilders(config)
-        },
-        plan: {
-            sliceGranularity: resolvePlanSliceGranularity(config),
-            microTaskPolicy: resolvePlanMicroTaskPolicy(config)
-        }
-    };
-    await writeFileSafe(configPath(projectRoot), stringify(serialisable));
-}
-export async function detectAdvancedKeys(_projectRoot) {
-    return new Set();
 }

package/dist/constants.d.ts

@@ -1,19 +1,12 @@
-import type { FlowStage, HarnessId } from "./types.js";
-/** Hidden runtime directory at project root (dot-prefixed). */
+export declare const CCLAW_VERSION = "8.1.1";
 export declare const RUNTIME_ROOT = ".cclaw";
-export declare const CCLAW_VERSION: string;
-export declare const FLOW_VERSION = "1.0.0";
-/**
- * Canonical ship finalization enums used across stage schema, linting, and
- * runtime gate evidence checks.
- */
-export declare const SHIP_FINALIZATION_MODES: readonly ["FINALIZE_MERGE_LOCAL", "FINALIZE_OPEN_PR", "FINALIZE_KEEP_BRANCH", "FINALIZE_DISCARD_BRANCH", "FINALIZE_NO_VCS"];
-export type ShipFinalizationMode = (typeof SHIP_FINALIZATION_MODES)[number];
-export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/templates", ".cclaw/templates/state-contracts", ".cclaw/artifacts", ".cclaw/wave-plans", ".cclaw/archive", ".cclaw/worktrees", ".cclaw/state", ".cclaw/rules", ".cclaw/agents", ".cclaw/hooks", ".cclaw/skills/review-prompts"];
-export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".agents/skills/cc/SKILL.md", ".agents/skills/cc-*/SKILL.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
-/**
- * Canonical stage -> skill folder mapping.
- */
-export declare const STAGE_TO_SKILL_FOLDER: Record<FlowStage, string>;
-export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
+export declare const STATE_REL_PATH = ".cclaw/state";
+export declare const HOOKS_REL_PATH = ".cclaw/hooks";
+export declare const FLOWS_ROOT = ".cclaw/flows";
+export declare const LIB_ROOT = ".cclaw/lib";
+export declare const FLOW_STATE_REL_PATH = ".cclaw/state/flow-state.json";
+export declare const KNOWLEDGE_LOG_REL_PATH = ".cclaw/knowledge.jsonl";
+export declare const IDEAS_REL_PATH = ".cclaw/ideas.md";
+export declare const SHIPPED_DIR_REL_PATH = ".cclaw/flows/shipped";
+export declare const CANCELLED_DIR_REL_PATH = ".cclaw/flows/cancelled";
+export declare const LIB_DIRS: readonly ["agents", "skills", "templates", "runbooks", "patterns", "research", "recovery", "examples"];