cclaw-cli 0.49.0 → 0.51.1

package/dist/eval/verifiers/traceability.d.ts

@@ -1,23 +0,0 @@
-/**
- * Cross-stage traceability verifier: extract a set of IDs from a source
- * fixture (e.g. `D-\d+` decisions declared during scope) and assert every
- * ID appears in the artifact-under-test and/or in other linked fixtures.
- *
- * The verifier is intentionally source-agnostic: the caller passes the
- * primary artifact plus a label → text map for any extra fixtures declared
- * on the case. `source` and entries in `requireIn` are either the string
- * `"self"` (the primary artifact) or labels present in the extras map.
- *
- * Result ids follow `traceability:<source>->:<target>:<reason>` so baselines
- * diff at the per-link granularity. A missing link produces one result with
- * a list of missing IDs in its `details` payload.
- */
-import type { TraceabilityExpected, VerifierResult } from "../types.js";
-export declare const SELF_LABEL = "self";
-/**
- * Run traceability checks. Returns `[]` when expectations are undefined.
- * Emits a single "source-missing" result when the declared source fixture
- * has zero IDs (authoring error), and one result per `requireIn` target
- * listing any IDs absent in that fixture.
- */
-export declare function verifyTraceability(primaryArtifact: string, extraFixtures: Record<string, string>, expected: TraceabilityExpected | undefined): VerifierResult[];

package/dist/eval/verifiers/traceability.js

@@ -1,84 +0,0 @@
-import { splitFrontmatter } from "./structural.js";
-export const SELF_LABEL = "self";
-function result(id, ok, message, details) {
-    return {
-        kind: "rules",
-        id,
-        ok,
-        score: ok ? 1 : 0,
-        message,
-        ...(details !== undefined ? { details } : {})
-    };
-}
-function compileIdRegex(expected) {
-    const flags = expected.idFlags ?? "g";
-    const normalized = flags.includes("g") ? flags : `${flags}g`;
-    try {
-        return new RegExp(expected.idPattern, normalized);
-    }
-    catch (err) {
-        throw new Error(`Invalid traceability id_pattern ${JSON.stringify(expected.idPattern)} ` +
-            `(flags=${JSON.stringify(normalized)}): ` +
-            (err instanceof Error ? err.message : String(err)));
-    }
-}
-function bodyOf(text) {
-    return splitFrontmatter(text).body;
-}
-function extractIds(text, regex) {
-    const body = bodyOf(text);
-    const found = new Set();
-    for (const match of body.matchAll(regex)) {
-        found.add(match[0]);
-    }
-    return [...found].sort();
-}
-function resolveFixture(label, primary, extraFixtures) {
-    if (label === SELF_LABEL)
-        return primary;
-    return extraFixtures[label];
-}
-/**
- * Run traceability checks. Returns `[]` when expectations are undefined.
- * Emits a single "source-missing" result when the declared source fixture
- * has zero IDs (authoring error), and one result per `requireIn` target
- * listing any IDs absent in that fixture.
- */
-export function verifyTraceability(primaryArtifact, extraFixtures, expected) {
-    if (!expected)
-        return [];
-    const regex = compileIdRegex(expected);
-    const sourceText = resolveFixture(expected.source, primaryArtifact, extraFixtures);
-    if (sourceText === undefined) {
-        return [
-            result(`traceability:source:${expected.source}:missing`, false, `Traceability source fixture "${expected.source}" not loaded.`, { source: expected.source })
-        ];
-    }
-    const sourceIds = extractIds(sourceText, regex);
-    if (sourceIds.length === 0) {
-        return [
-            result(`traceability:source:${expected.source}:empty`, false, `Source "${expected.source}" yielded zero ids for pattern /${expected.idPattern}/.`, { source: expected.source, pattern: expected.idPattern })
-        ];
-    }
-    const results = [];
-    for (const target of expected.requireIn) {
-        const targetText = resolveFixture(target, primaryArtifact, extraFixtures);
-        if (targetText === undefined) {
-            results.push(result(`traceability:target:${target}:missing`, false, `Traceability target fixture "${target}" not loaded.`, { target }));
-            continue;
-        }
-        const targetBody = bodyOf(targetText);
-        const missing = sourceIds.filter((id) => !targetBody.includes(id));
-        const ok = missing.length === 0;
-        results.push(result(`traceability:${expected.source}->${target}`, ok, ok
-            ? `Every id (${sourceIds.length}) from "${expected.source}" appears in "${target}".`
-            : `Target "${target}" is missing ${missing.length}/${sourceIds.length} id(s): ${missing.join(", ")}.`, {
-            source: expected.source,
-            target,
-            sourceIds,
-            missing,
-            pattern: expected.idPattern
-        }));
-    }
-    return results;
-}

package/dist/eval/verifiers/workflow-consistency.d.ts

@@ -1,21 +0,0 @@
-/**
- * Cross-artifact consistency verifier for workflow mode.
- *
- * Operates over a `{ stage → artifact }` map produced by the workflow
- * agent and emits deterministic verifier results for:
- *
- *  - `ids_flow`: every id extracted from `from` must appear in every
- *    `to` stage. Typical use — `D-\d+` from scope must all land in plan.
- *  - `placeholder_free`: none of the listed phrases
- *    (default `TBD`/`TODO`/`placeholder`) appear in any of the named
- *    stages.
- *  - `no_contradictions`: for each entry, if `must` is present in the
- *    declaring stage, `forbid` must not appear in any of the listed
- *    `stages`.
- *
- * Each sub-check contributes zero or more `VerifierResult`s with
- * `kind: "consistency"`. An empty `WorkflowConsistencyExpected` produces
- * zero results so authors can opt in incrementally.
- */
-import type { VerifierResult, WorkflowConsistencyExpected, WorkflowStageName } from "../types.js";
-export declare function verifyWorkflowConsistency(artifacts: Map<WorkflowStageName, string>, expected: WorkflowConsistencyExpected | undefined): VerifierResult[];

package/dist/eval/verifiers/workflow-consistency.js

@@ -1,225 +0,0 @@
-const DEFAULT_PLACEHOLDERS = ["TBD", "TODO", "placeholder"];
-export function verifyWorkflowConsistency(artifacts, expected) {
-    if (!expected)
-        return [];
-    const out = [];
-    if (expected.idsFlow) {
-        for (const rule of expected.idsFlow) {
-            out.push(...checkIdsFlow(artifacts, rule));
-        }
-    }
-    if (expected.placeholderFree) {
-        out.push(...checkPlaceholderFree(artifacts, expected.placeholderFree.stages, expected.placeholderFree.phrases && expected.placeholderFree.phrases.length > 0
-            ? expected.placeholderFree.phrases
-            : DEFAULT_PLACEHOLDERS));
-    }
-    if (expected.noContradictions) {
-        for (const rule of expected.noContradictions) {
-            out.push(...checkNoContradiction(artifacts, rule));
-        }
-    }
-    return out;
-}
-function slug(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 48);
-}
-function missingStage(artifacts, stage, verifierId, label) {
-    if (artifacts.has(stage))
-        return undefined;
-    return {
-        kind: "consistency",
-        id: verifierId,
-        ok: false,
-        score: 0,
-        message: `Workflow artifact for stage "${stage}" is missing (${label}).`,
-        details: { stage, missing: true }
-    };
-}
-function extractIds(text, pattern, flags) {
-    const normalized = flags.includes("g") ? flags : `${flags}g`;
-    const regex = new RegExp(pattern, normalized);
-    const hits = new Set();
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        hits.add(match[0]);
-        if (regex.lastIndex === match.index)
-            regex.lastIndex += 1;
-    }
-    return [...hits].sort((a, b) => a.localeCompare(b));
-}
-function checkIdsFlow(artifacts, rule) {
-    const idTag = slug(rule.idPattern);
-    const baseId = `consistency:ids-flow:${rule.from}:${idTag}`;
-    const results = [];
-    const missingFrom = missingStage(artifacts, rule.from, `${baseId}:source-missing`, "ids-flow source");
-    if (missingFrom) {
-        results.push(missingFrom);
-        return results;
-    }
-    const source = artifacts.get(rule.from);
-    let sourceIds;
-    try {
-        sourceIds = extractIds(source, rule.idPattern, rule.idFlags ?? "g");
-    }
-    catch (err) {
-        results.push({
-            kind: "consistency",
-            id: `${baseId}:regex`,
-            ok: false,
-            score: 0,
-            message: `Invalid id regex "${rule.idPattern}": ${err instanceof Error ? err.message : String(err)}`,
-            details: { from: rule.from }
-        });
-        return results;
-    }
-    if (sourceIds.length === 0) {
-        results.push({
-            kind: "consistency",
-            id: `${baseId}:source-empty`,
-            ok: false,
-            score: 0,
-            message: `No ids matched "${rule.idPattern}" in stage "${rule.from}".`,
-            details: { from: rule.from, pattern: rule.idPattern }
-        });
-        return results;
-    }
-    for (const target of rule.to) {
-        const missingTarget = missingStage(artifacts, target, `${baseId}:${target}:target-missing`, "ids-flow target");
-        if (missingTarget) {
-            results.push(missingTarget);
-            continue;
-        }
-        const body = artifacts.get(target);
-        const missing = sourceIds.filter((id) => !body.includes(id));
-        const verifierId = `${baseId}:${target}`;
-        if (missing.length === 0) {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: true,
-                score: 1,
-                message: `All ${sourceIds.length} id(s) from "${rule.from}" appear in "${target}".`,
-                details: { from: rule.from, to: target, ids: sourceIds }
-            });
-        }
-        else {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: false,
-                score: 0,
-                message: `Missing in "${target}": ${missing.slice(0, 5).join(", ")}` +
-                    (missing.length > 5 ? ` (+${missing.length - 5} more)` : ""),
-                details: {
-                    from: rule.from,
-                    to: target,
-                    ids: sourceIds,
-                    missing
-                }
-            });
-        }
-    }
-    return results;
-}
-function checkPlaceholderFree(artifacts, stages, phrases) {
-    const results = [];
-    for (const stage of stages) {
-        const verifierId = `consistency:placeholder-free:${stage}`;
-        const missing = missingStage(artifacts, stage, verifierId, "placeholder-free");
-        if (missing) {
-            results.push(missing);
-            continue;
-        }
-        const body = artifacts.get(stage);
-        const lower = body.toLowerCase();
-        const hits = phrases.filter((p) => lower.includes(p.toLowerCase()));
-        if (hits.length === 0) {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: true,
-                score: 1,
-                message: `No placeholder phrases found in "${stage}".`,
-                details: { stage, phrases }
-            });
-        }
-        else {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: false,
-                score: 0,
-                message: `Placeholder phrases in "${stage}": ${hits.join(", ")}.`,
-                details: { stage, phrases, hits }
-            });
-        }
-    }
-    return results;
-}
-function checkNoContradiction(artifacts, rule) {
-    const tag = `${slug(rule.must)}-vs-${slug(rule.forbid)}`;
-    const baseId = `consistency:no-contradiction:${rule.stage}:${tag}`;
-    const results = [];
-    const missingAnchor = missingStage(artifacts, rule.stage, `${baseId}:anchor-missing`, "no-contradiction anchor");
-    if (missingAnchor) {
-        results.push(missingAnchor);
-        return results;
-    }
-    const anchorText = artifacts.get(rule.stage);
-    if (!anchorText.toLowerCase().includes(rule.must.toLowerCase())) {
-        // The declaring stage doesn't actually assert `must`, so the rule is vacuously satisfied.
-        results.push({
-            kind: "consistency",
-            id: `${baseId}:anchor-inactive`,
-            ok: true,
-            score: 1,
-            message: `Anchor "${rule.must}" not present in "${rule.stage}"; contradiction check skipped.`,
-            details: { stage: rule.stage, anchor: rule.must, skipped: true }
-        });
-        return results;
-    }
-    for (const target of rule.stages) {
-        const verifierId = `${baseId}:${target}`;
-        const missingTarget = missingStage(artifacts, target, `${verifierId}:target-missing`, "no-contradiction target");
-        if (missingTarget) {
-            results.push(missingTarget);
-            continue;
-        }
-        const body = artifacts.get(target);
-        if (body.toLowerCase().includes(rule.forbid.toLowerCase())) {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: false,
-                score: 0,
-                message: `"${rule.stage}" asserts "${rule.must}" but "${target}" contains "${rule.forbid}".`,
-                details: {
-                    stage: rule.stage,
-                    anchor: rule.must,
-                    forbid: rule.forbid,
-                    target
-                }
-            });
-        }
-        else {
-            results.push({
-                kind: "consistency",
-                id: verifierId,
-                ok: true,
-                score: 1,
-                message: `"${target}" does not contradict "${rule.stage}" on "${rule.must}".`,
-                details: {
-                    stage: rule.stage,
-                    anchor: rule.must,
-                    forbid: rule.forbid,
-                    target
-                }
-            });
-        }
-    }
-    return results;
-}

package/dist/eval/workflow-corpus.d.ts

@@ -1,7 +0,0 @@
-import type { WorkflowCase } from "./types.js";
-/**
- * Load every workflow-mode case under
- * `.cclaw/evals/corpus/workflows/*.yaml`. Returns an empty array when the
- * directory is missing — a fresh `cclaw init` has no workflow corpus yet.
- */
-export declare function loadWorkflowCorpus(projectRoot: string): Promise<WorkflowCase[]>;

package/dist/eval/workflow-corpus.js

@@ -1,207 +0,0 @@
-/**
- * Workflow corpus loader (workflow mode).
- *
- * Workflow-mode cases live under `.cclaw/evals/corpus/workflows/<id>.yaml` and
- * describe a multi-stage run that chains the with-tools agent across
- * `brainstorm → scope → design → spec → plan`. Unlike single-stage
- * cases (which are keyed by stage folder), workflow cases ship as a
- * single YAML that embeds each stage's prompt + expectations.
- *
- * The loader is intentionally separate from `loadCorpus` so the
- * structural / rules CI paths never walk the workflow directory — those
- * paths are single-stage only.
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import { parse } from "yaml";
-import { EVALS_ROOT } from "../constants.js";
-import { exists } from "../fs-utils.js";
-import { WORKFLOW_STAGES } from "./types.js";
-const WORKFLOW_STAGE_SET = new Set(WORKFLOW_STAGES);
-function workflowCorpusError(filePath, reason) {
-    return new Error(`Invalid workflow case at ${filePath}: ${reason}\n` +
-        `Supported workflow stages: ${WORKFLOW_STAGES.join(", ")}`);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readStringArray(filePath, context, value) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-        throw workflowCorpusError(filePath, `"${context}" must be an array of strings`);
-    }
-    return value;
-}
-function parseStageName(filePath, context, value) {
-    if (typeof value !== "string" || !WORKFLOW_STAGE_SET.has(value)) {
-        throw workflowCorpusError(filePath, `"${context}" must be one of: ${WORKFLOW_STAGES.join(", ")}`);
-    }
-    return value;
-}
-function parseStageArray(filePath, context, value) {
-    if (!Array.isArray(value) || value.length === 0) {
-        throw workflowCorpusError(filePath, `"${context}" must be a non-empty array of stage names`);
-    }
-    return value.map((entry, index) => parseStageName(filePath, `${context}[${index}]`, entry));
-}
-function parseStageStep(filePath, index, raw) {
-    if (!isRecord(raw)) {
-        throw workflowCorpusError(filePath, `stages[${index}] must be a mapping`);
-    }
-    const name = parseStageName(filePath, `stages[${index}].name`, raw.name);
-    const inputPrompt = raw.input_prompt ?? raw.inputPrompt;
-    if (typeof inputPrompt !== "string" || inputPrompt.trim().length === 0) {
-        throw workflowCorpusError(filePath, `stages[${index}].input_prompt must be a non-empty string`);
-    }
-    const step = { name, inputPrompt: inputPrompt.trim() };
-    if (raw.rubric !== undefined) {
-        if (typeof raw.rubric !== "string" || raw.rubric.trim().length === 0) {
-            throw workflowCorpusError(filePath, `stages[${index}].rubric must be a non-empty string`);
-        }
-        step.rubric = raw.rubric.trim();
-    }
-    const requiredChecks = readStringArray(filePath, `stages[${index}].required_checks`, raw.required_checks ?? raw.requiredChecks);
-    if (requiredChecks)
-        step.requiredChecks = requiredChecks;
-    const minScoresRaw = raw.minimum_scores ?? raw.minimumScores;
-    if (minScoresRaw !== undefined) {
-        if (!isRecord(minScoresRaw)) {
-            throw workflowCorpusError(filePath, `stages[${index}].minimum_scores must be a mapping of check id → number`);
-        }
-        const minimumScores = {};
-        for (const [key, val] of Object.entries(minScoresRaw)) {
-            if (typeof val !== "number" || !Number.isFinite(val) || val < 1 || val > 5) {
-                throw workflowCorpusError(filePath, `stages[${index}].minimum_scores.${key} must be a number in [1,5]`);
-            }
-            minimumScores[key] = val;
-        }
-        step.minimumScores = minimumScores;
-    }
-    return step;
-}
-function parseConsistency(filePath, raw) {
-    if (raw === undefined)
-        return undefined;
-    if (!isRecord(raw)) {
-        throw workflowCorpusError(filePath, `"consistency" must be a mapping`);
-    }
-    const out = {};
-    const idsFlowRaw = raw.ids_flow ?? raw.idsFlow;
-    if (idsFlowRaw !== undefined) {
-        if (!Array.isArray(idsFlowRaw)) {
-            throw workflowCorpusError(filePath, `"consistency.ids_flow" must be an array`);
-        }
-        out.idsFlow = idsFlowRaw.map((entry, index) => {
-            if (!isRecord(entry)) {
-                throw workflowCorpusError(filePath, `consistency.ids_flow[${index}] must be a mapping`);
-            }
-            const idPattern = entry.id_pattern ?? entry.idPattern;
-            if (typeof idPattern !== "string" || idPattern.length === 0) {
-                throw workflowCorpusError(filePath, `consistency.ids_flow[${index}].id_pattern must be a non-empty regex source`);
-            }
-            const idFlags = entry.id_flags ?? entry.idFlags;
-            if (idFlags !== undefined && typeof idFlags !== "string") {
-                throw workflowCorpusError(filePath, `consistency.ids_flow[${index}].id_flags must be a string`);
-            }
-            const from = parseStageName(filePath, `consistency.ids_flow[${index}].from`, entry.from);
-            const to = parseStageArray(filePath, `consistency.ids_flow[${index}].to`, entry.to);
-            const result = { idPattern, from, to };
-            if (idFlags !== undefined)
-                result.idFlags = idFlags;
-            return result;
-        });
-    }
-    const placeholderRaw = raw.placeholder_free ?? raw.placeholderFree;
-    if (placeholderRaw !== undefined) {
-        if (!isRecord(placeholderRaw)) {
-            throw workflowCorpusError(filePath, `"consistency.placeholder_free" must be a mapping`);
-        }
-        const stages = parseStageArray(filePath, "consistency.placeholder_free.stages", placeholderRaw.stages);
-        const phrases = readStringArray(filePath, "consistency.placeholder_free.phrases", placeholderRaw.phrases);
-        const block = { stages };
-        if (phrases)
-            block.phrases = phrases;
-        out.placeholderFree = block;
-    }
-    const noContradictionsRaw = raw.no_contradictions ?? raw.noContradictions;
-    if (noContradictionsRaw !== undefined) {
-        if (!Array.isArray(noContradictionsRaw)) {
-            throw workflowCorpusError(filePath, `"consistency.no_contradictions" must be an array`);
-        }
-        out.noContradictions = noContradictionsRaw.map((entry, index) => {
-            if (!isRecord(entry)) {
-                throw workflowCorpusError(filePath, `consistency.no_contradictions[${index}] must be a mapping`);
-            }
-            const stage = parseStageName(filePath, `consistency.no_contradictions[${index}].stage`, entry.stage);
-            if (typeof entry.must !== "string" || entry.must.length === 0) {
-                throw workflowCorpusError(filePath, `consistency.no_contradictions[${index}].must must be a non-empty string`);
-            }
-            if (typeof entry.forbid !== "string" || entry.forbid.length === 0) {
-                throw workflowCorpusError(filePath, `consistency.no_contradictions[${index}].forbid must be a non-empty string`);
-            }
-            const stages = parseStageArray(filePath, `consistency.no_contradictions[${index}].stages`, entry.stages);
-            return {
-                stage,
-                must: entry.must,
-                forbid: entry.forbid,
-                stages
-            };
-        });
-    }
-    return Object.keys(out).length === 0 ? undefined : out;
-}
-function validateWorkflowCase(filePath, raw) {
-    if (!isRecord(raw)) {
-        throw workflowCorpusError(filePath, `top-level value must be a mapping`);
-    }
-    const id = raw.id;
-    if (typeof id !== "string" || id.trim().length === 0) {
-        throw workflowCorpusError(filePath, `"id" must be a non-empty string`);
-    }
-    const stagesRaw = raw.stages;
-    if (!Array.isArray(stagesRaw) || stagesRaw.length === 0) {
-        throw workflowCorpusError(filePath, `"stages" must be a non-empty array`);
-    }
-    const stages = stagesRaw.map((entry, index) => parseStageStep(filePath, index, entry));
-    const contextFiles = readStringArray(filePath, "context_files", raw.context_files ?? raw.contextFiles);
-    const consistency = parseConsistency(filePath, raw.consistency);
-    const description = typeof raw.description === "string" ? raw.description.trim() : undefined;
-    const out = { id: id.trim(), stages };
-    if (description)
-        out.description = description;
-    if (contextFiles)
-        out.contextFiles = contextFiles;
-    if (consistency)
-        out.consistency = consistency;
-    return out;
-}
-/**
- * Load every workflow-mode case under
- * `.cclaw/evals/corpus/workflows/*.yaml`. Returns an empty array when the
- * directory is missing — a fresh `cclaw init` has no workflow corpus yet.
- */
-export async function loadWorkflowCorpus(projectRoot) {
-    const dir = path.join(projectRoot, EVALS_ROOT, "corpus", "workflows");
-    if (!(await exists(dir)))
-        return [];
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    const out = [];
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        if (!entry.name.endsWith(".yaml") && !entry.name.endsWith(".yml"))
-            continue;
-        const filePath = path.join(dir, entry.name);
-        let parsed;
-        try {
-            parsed = parse(await fs.readFile(filePath, "utf8"));
-        }
-        catch (err) {
-            throw workflowCorpusError(filePath, err instanceof Error ? err.message : String(err));
-        }
-        out.push(validateWorkflowCase(filePath, parsed));
-    }
-    out.sort((a, b) => a.id.localeCompare(b.id));
-    return out;
-}

package/dist/feature-system.d.ts

@@ -1,42 +0,0 @@
-export interface ActiveFeatureMeta {
-    activeFeature: string;
-    updatedAt: string;
-}
-export type FeatureWorkspaceSource = "git-worktree" | "workspace" | "legacy-snapshot";
-export interface FeatureWorkspaceEntry {
-    featureId: string;
-    branch: string;
-    path: string;
-    source: FeatureWorkspaceSource;
-    createdAt: string;
-}
-export interface FeatureWorktreeRegistry {
-    schemaVersion: 1;
-    updatedAt: string;
-    entries: FeatureWorkspaceEntry[];
-}
-export interface CreateFeatureOptions {
-    cloneActive?: boolean;
-    switchTo?: boolean;
-}
-export interface FeatureSystemAccessOptions {
-    /**
-     * When false, read metadata without auto-repair writes. Useful for pure
-     * diagnostics (doctor) that should not mutate state as a side effect.
-     */
-    repair?: boolean;
-}
-export declare function activeFeatureMetaPath(projectRoot: string): string;
-export declare function worktreeRegistryPath(projectRoot: string): string;
-export declare function featureRootPath(projectRoot: string, featureId: string): string;
-export declare function featureArtifactsPath(projectRoot: string, featureId: string): string;
-export declare function featureStatePath(projectRoot: string, featureId: string): string;
-export declare function resolveFeatureWorkspacePath(projectRoot: string, entry: FeatureWorkspaceEntry): string;
-export declare function ensureFeatureSystem(projectRoot: string, options?: FeatureSystemAccessOptions): Promise<ActiveFeatureMeta>;
-export declare function readFeatureWorktreeRegistry(projectRoot: string, options?: FeatureSystemAccessOptions): Promise<FeatureWorktreeRegistry>;
-export declare function readActiveFeature(projectRoot: string, options?: FeatureSystemAccessOptions): Promise<string>;
-export declare function listFeatures(projectRoot: string, options?: FeatureSystemAccessOptions): Promise<string[]>;
-export declare function syncActiveFeatureSnapshot(projectRoot: string): Promise<void>;
-export declare function switchActiveFeature(projectRoot: string, featureId: string): Promise<ActiveFeatureMeta>;
-export declare function createFeature(projectRoot: string, rawFeatureId: string, options?: CreateFeatureOptions): Promise<string>;
-export declare function activeFeatureWorkspacePath(projectRoot: string): Promise<string>;