@interf/compiler 0.1.9 → 0.1.11

package/dist/lib/workflows.js

@@ -1,213 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, relative } from "node:path";
-import { countFilesRecursive, listFilesRecursive } from "./filesystem.js";
-import { createKnowledgeBase as createKnowledgeBaseScaffold, createInterface as createInterfaceScaffold, detectInterf, refreshWorkspaceBootstrapGuidance, readInterfConfig, resolveInterfaceKnowledgeBasePath, resolveKnowledgeBaseSourcePath, syncClaudeBootstrap, } from "./interf.js";
-import { buildSummarizePlan, writeSummarizePlan } from "./summarize-plan.js";
-import { loadState, computeInterfaceHealth, refreshKnowledgeBaseArtifacts, refreshInterfaceArtifacts, } from "./state.js";
-import { buildKnowledgeBaseSummarizeContract, buildStagePrompt, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runtimeRunStdoutContains, runExecutorSummarizeStage, runExecutorStage, validateStageContractAcceptance, } from "./runtime.js";
-import { formatInterfaceWorkflowStageStep, formatKnowledgeBaseWorkflowStageStep, getInterfaceWorkflow, getKnowledgeBaseWorkflow, getWorkflowStagePolicyNotes, resolveInterfaceWorkflowFromConfig, resolveKnowledgeBaseWorkflowFromConfig, } from "./workflow-definitions.js";
+import { createKnowledgeBase as createKnowledgeBaseScaffold, createInterface as createInterfaceScaffold, detectInterf, } from "./interf.js";
 import { validateKnowledgeBaseSummarize, validateKnowledgeBaseCompile, validateInterfaceRetrieve, validateInterfacePlan, } from "./validate.js";
-import { parseJsonFrontmatter } from "./parse.js";
-const LOCAL_SKILL_READ_LIMIT = 50;
-function isMarkdownDoc(filePath) {
-    return filePath.toLowerCase().endsWith(".md");
-}
-function workflowCreateDirectory() {
-    return "workflow/create";
-}
-function workflowQueryDirectory() {
-    return "workflow/use/query";
-}
-function workflowCompileStageDirectory(stageDir) {
-    return `workflow/compile/stages/${stageDir}`;
-}
-function emptyLocalSkillContractExtension() {
-    return {
-        reads: [],
-        count: 0,
-        notes: [],
-        localMode: null,
-        effectiveMode: "builtin",
-        modeSources: [],
-    };
-}
-function readLocalInstructionMode(filePath) {
-    try {
-        const parsed = parseJsonFrontmatter(readFileSync(filePath, "utf8"));
-        const mode = parsed?.frontmatter.mode;
-        return mode === "extend" || mode === "override" ? mode : null;
-    }
-    catch {
-        return null;
-    }
-}
-function collectLocalSkillDocs(rootPath, directories) {
-    return collectLocalSkillDocsRelativeTo(rootPath, rootPath, directories);
-}
-function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
-    const docs = new Map();
-    const rootReadme = join(rootPath, "workflow", "README.md");
-    if (existsSync(rootReadme)) {
-        const read = relative(relativeToPath, rootReadme);
-        docs.set(read, {
-            read,
-            absolutePath: rootReadme,
-            mode: readLocalInstructionMode(rootReadme),
-        });
-    }
-    for (const directory of directories) {
-        for (const filePath of listFilesRecursive(join(rootPath, directory), isMarkdownDoc)) {
-            const read = relative(relativeToPath, filePath);
-            docs.set(read, {
-                read,
-                absolutePath: filePath,
-                mode: readLocalInstructionMode(filePath),
-            });
-        }
-    }
-    return Array.from(docs.values())
-        .sort((a, b) => a.read.localeCompare(b.read))
-        .slice(0, LOCAL_SKILL_READ_LIMIT);
-}
-function buildLocalSkillContractExtension(rootPath, directories, purpose) {
-    const docs = collectLocalSkillDocs(rootPath, directories);
-    const reads = docs.map((doc) => doc.read);
-    const modeSources = docs.filter((doc) => doc.mode !== null).map((doc) => doc.read);
-    const localMode = docs.some((doc) => doc.mode === "override")
-        ? "override"
-        : docs.some((doc) => doc.mode === "extend")
-            ? "extend"
-            : null;
-    if (docs.length === 0) {
-        return emptyLocalSkillContractExtension();
-    }
-    return {
-        reads,
-        count: reads.length,
-        notes: [
-            `Read any local instruction docs listed under ${directories.join(", ")} before executing the core stage.`,
-            localMode === "override"
-                ? `${purpose} One or more local docs declare \`mode: override\`, so their workflow instructions replace Interf's bundled stage instructions for this run. They still do not bypass coverage proof, evidence weighting, required writes, or deterministic state transitions.`
-                : `${purpose} These local workflow docs can refine the stage, but they do not bypass coverage proof, evidence weighting, required writes, or deterministic state transitions.`,
-        ],
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
-function buildLocalSkillContractExtensionRelativeTo(rootPath, relativeToPath, directories, purpose) {
-    const docs = collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories);
-    const reads = docs.map((doc) => doc.read);
-    const modeSources = docs.filter((doc) => doc.mode !== null).map((doc) => doc.read);
-    const localMode = docs.some((doc) => doc.mode === "override")
-        ? "override"
-        : docs.some((doc) => doc.mode === "extend")
-            ? "extend"
-            : null;
-    if (docs.length === 0) {
-        return emptyLocalSkillContractExtension();
-    }
-    return {
-        reads,
-        count: reads.length,
-        notes: [
-            `Read any local instruction docs listed under ${directories.join(", ")} before executing the core stage.`,
-            localMode === "override"
-                ? `${purpose} One or more local docs declare \`mode: override\`, so their workflow instructions replace Interf's bundled stage instructions for this run. They still do not bypass coverage proof, evidence weighting, required writes, or deterministic state transitions.`
-                : `${purpose} These local workflow docs can refine the stage, but they do not bypass coverage proof, evidence weighting, required writes, or deterministic state transitions.`,
-        ],
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
-function mergeLocalSkillContractExtensions(extensions) {
-    const reads = Array.from(new Set(extensions.flatMap((extension) => extension.reads)));
-    const notes = Array.from(new Set(extensions.flatMap((extension) => extension.notes)));
-    const modeSources = Array.from(new Set(extensions.flatMap((extension) => extension.modeSources)));
-    const localMode = extensions.some((extension) => extension.localMode === "override")
-        ? "override"
-        : extensions.some((extension) => extension.localMode === "extend")
-            ? "extend"
-            : null;
-    return {
-        reads,
-        count: reads.length,
-        notes,
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
-function buildStageInstructions(bundledSkill, localSkills) {
-    return {
-        bundled_skill: bundledSkill,
-        effective_mode: localSkills.effectiveMode,
-        local_mode: localSkills.localMode,
-        local_docs: localSkills.reads,
-        mode_sources: localSkills.modeSources,
-    };
-}
-function reportLine(reporter, message) {
-    reporter?.line?.(message);
-}
-function reportBlankLine(reporter) {
-    reporter?.blankLine?.();
-}
-function reportValidationFailure(reporter, summary) {
-    reportBlankLine(reporter);
-    reportLine(reporter, summary);
-}
-function isRetrieveStageComplete(dirPath) {
-    const validation = validateInterfaceRetrieve(dirPath);
-    return validation.required && validation.ok;
-}
-function resolveKnowledgeBaseContext(knowledgeBasePath) {
-    const config = readInterfConfig(knowledgeBasePath);
-    const workflowId = resolveKnowledgeBaseWorkflowFromConfig(config);
-    return {
-        knowledgeBaseName: config?.name ?? "knowledge-base",
-        sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath, config),
-        workflowId,
-    };
-}
-function resolveInterfaceContext(knowledgeBasePath) {
-    const config = readInterfConfig(knowledgeBasePath);
-    const workflowId = resolveInterfaceWorkflowFromConfig(config);
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(knowledgeBasePath);
-    return {
-        knowledgeBaseName: config?.name ?? "interface",
-        connectedKnowledgeBasePath,
-        sourcePath: connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : null,
-        workflowId,
-    };
-}
-function knowledgeBaseExecutionStages(workflowId, knowledgeBasePath) {
-    return getKnowledgeBaseWorkflow(workflowId, { workspacePath: knowledgeBasePath }).stages;
-}
-function interfaceExecutionStages(workflowId, interfacePath) {
-    return getInterfaceWorkflow(workflowId, { workspacePath: interfacePath }).stages;
-}
-function bundledSkillForContractType(contractType) {
-    switch (contractType) {
-        case "kb-file-evidence":
-            return "knowledge-base/summarize";
-        case "kb-knowledge-layer":
-            return "knowledge-base/compile";
-        case "interface-plan":
-            return "interface/create";
-        case "interface-retrieval":
-            return "interface/retrieve";
-        case "interface-analysis":
-            return "interface/analyze";
-        case "interface-output":
-            return "interface/compile";
-        default: {
-            const exhaustiveContractType = contractType;
-            throw new Error(`Unsupported contract type: ${exhaustiveContractType}`);
-        }
-    }
-}
+// ---------------------------------------------------------------------------
+// Helper re-exports (so workflows-kb / workflows-interface can stay on "./workflow-helpers.js"
+// but legacy imports from "./workflows.js" keep working)
+// ---------------------------------------------------------------------------
+export { workflowCreateDirectory, workflowQueryDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
 export function detectKnowledgeBase(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
@@ -241,867 +38,12 @@ export function verifyInterfCheck(check, knowledgeBasePath) {
         }
     }
 }
-function resolveStageAcceptance(targetType, workflowId, stageId, sourcePath, workspacePath) {
-    const workflow = targetType === "knowledge-base"
-        ? getKnowledgeBaseWorkflow(workflowId, {
-            ...(sourcePath ? { sourcePath } : {}),
-            ...(workspacePath ? { workspacePath } : {}),
-        })
-        : getInterfaceWorkflow(workflowId, {
-            ...(sourcePath ? { sourcePath } : {}),
-            ...(workspacePath ? { workspacePath } : {}),
-        });
-    return workflow.stages.find((stage) => stage.id === stageId)?.acceptance;
-}
-function validateStageOutcome(dirPath, validation) {
-    if (!validation.ok)
-        return validation;
-    const acceptance = validateStageContractAcceptance(dirPath);
-    if (!acceptance.ok) {
-        return {
-            ok: false,
-            summary: acceptance.summary,
-        };
-    }
-    return validation;
-}
-export async function planInterface(options) {
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(options.knowledgeBasePath);
-    const interfaceWorkflow = resolveInterfaceWorkflowFromConfig(readInterfConfig(options.knowledgeBasePath));
-    const instructions = buildStageInstructions("interface/create", mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, options.knowledgeBasePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level guidance only if they materially improve the interface scaffold.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCreateDirectory()], "Use the interface workflow's local create docs as scaffolding heuristics only if they materially improve the interface setup."),
-    ]));
-    const code = await runExecutorStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "interface",
-        knowledgeBaseName: options.name,
-        workflow: interfaceWorkflow,
-        workflowSourcePath: connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : undefined,
-        stage: "create-interface",
-        stageLabel: "Create Interface",
-        contractType: "interface-plan",
-        summary: `Designing the initial runtime hypothesis for the ${options.name} interface.`,
-        contract: buildInterfaceCreateContract({
-            name: options.name,
-            workflow: options.workflow,
-            useCase: options.useCase,
-            knowledgeBaseName: options.knowledgeBaseName,
-            knowledgeBasePath: options.knowledgeBasePath,
-            instructions,
-        }),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            "Emit exactly one startup line: STATUS: loaded interface creation contract.",
-            "Emit STATUS: analyzed knowledge-base when the scaffold inputs and knowledge-base evidence have been reviewed.",
-            "Emit STATUS: wrote compile plan after interf.json and compile-plan.md are updated and AGENTS.md still preserves the scaffold router/checklist.",
-            "Emit DONE: interface create complete when the scaffold is ready for `interf compile`.",
-        ]),
-    });
-    syncClaudeBootstrap(options.knowledgeBasePath);
-    const validation = validateInterfacePlan(options.knowledgeBasePath);
-    const emittedDone = runtimeRunStdoutContains(options.knowledgeBasePath, "DONE: interface create complete");
-    if (validation.ok && (code === 0 || emittedDone)) {
-        if (code !== 0) {
-            markRuntimeRunSucceededAfterValidation(options.knowledgeBasePath, "create-interface completed successfully.");
-        }
-        return {
-            ok: true,
-            code: 0,
-            summary: validation.summary,
-        };
-    }
-    if (!validation.ok) {
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, validation.summary);
-    }
-    return {
-        ok: false,
-        code,
-        summary: validation.summary,
-    };
-}
-export async function runKnowledgeBaseSummarize(options) {
-    const context = resolveKnowledgeBaseContext(options.knowledgeBasePath);
-    const sourcePath = options.sourcePath ?? context.sourcePath;
-    const workflowId = context.workflowId;
-    const stageDefinition = options.stageDefinition ?? knowledgeBaseExecutionStages(workflowId, options.knowledgeBasePath)[0];
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const plan = buildSummarizePlan(sourcePath, options.knowledgeBasePath, options.fullPass ? "all" : "pending");
-    const planPath = writeSummarizePlan(options.knowledgeBasePath, plan);
-    const localSkills = buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine summary structure, evidence grouping, and summarization heuristics.");
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), localSkills);
-    if (options.reportSummary !== false) {
-        reportLine(options.reporter, `${plan.sourceCount} source files, ${plan.summaryCount} summarized, ${plan.targetCount} to summarize`);
-    }
-    if (plan.targetCount === 0) {
-        refreshKnowledgeBaseArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-        const validation = validateKnowledgeBaseSummarize(options.knowledgeBasePath);
-        if (options.reportStep !== false) {
-            reportLine(options.reporter, `${formatKnowledgeBaseWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath })} skipped (no work required)`);
-        }
-        if (!validation.ok) {
-            reportValidationFailure(options.reporter, validation.summary);
-        }
-        return {
-            ok: validation.ok,
-            code: validation.ok ? 0 : 1,
-            skipped: true,
-            plan,
-        };
-    }
-    if (options.reportStep !== false) {
-        reportLine(options.reporter, `${formatKnowledgeBaseWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath })} (${plan.targetCount} files)`);
-    }
-    const code = await runExecutorSummarizeStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "knowledge-base",
-        knowledgeBaseName: context.knowledgeBaseName,
-        workflow: workflowId,
-        workflowSourcePath: sourcePath,
-        stage: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        contractType: stageDefinition.contractType,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${plan.targetCount} source files.`,
-        contract: buildKnowledgeBaseSummarizeContract({
-            knowledgeBaseName: context.knowledgeBaseName,
-            targetCount: plan.targetCount,
-            sourcePath,
-            planPath,
-            workflowNotes: getWorkflowStagePolicyNotes("knowledge-base", workflowId, stageDefinition.id, sourcePath, options.knowledgeBasePath),
-            localSkillDocs: localSkills.reads,
-            instructions,
-            acceptance: resolveStageAcceptance("knowledge-base", workflowId, stageDefinition.id, sourcePath, options.knowledgeBasePath),
-        }),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${plan.targetCount} files.`,
-            "The CLI owns live file-count progress. Do not emit per-file progress.",
-            "Emit STATUS: batch committed after a completed batch has been merged into summaries/ and inventory.",
-            `Emit DONE: ${stageStatusLabel} complete ${plan.targetCount}/${plan.targetCount} when finished.`,
-        ]),
-        completionCheck: () => validateKnowledgeBaseSummarize(options.knowledgeBasePath).ok &&
-            validateStageContractAcceptance(options.knowledgeBasePath).ok,
-        startingSummaryCount: plan.summaryCount,
-        targetCount: plan.targetCount,
-    });
-    if (code !== 0) {
-        return {
-            ok: false,
-            code,
-            skipped: false,
-            plan,
-        };
-    }
-    refreshKnowledgeBaseArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-    const validation = validateStageOutcome(options.knowledgeBasePath, validateKnowledgeBaseSummarize(options.knowledgeBasePath));
-    if (!validation.ok) {
-        reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, validation.summary);
-    }
-    return {
-        ok: validation.ok,
-        code: validation.ok ? 0 : 1,
-        skipped: false,
-        plan,
-    };
-}
-export async function runKnowledgeBaseCompile(options) {
-    const knowledgeBaseConfig = readInterfConfig(options.knowledgeBasePath);
-    const knowledgeBaseName = knowledgeBaseConfig?.name ?? "knowledge-base";
-    const workflowId = resolveKnowledgeBaseWorkflowFromConfig(knowledgeBaseConfig);
-    const sourcePath = options.sourcePath ?? resolveKnowledgeBaseSourcePath(options.knowledgeBasePath, knowledgeBaseConfig);
-    const stageDefinition = options.stageDefinition ?? knowledgeBaseExecutionStages(workflowId, options.knowledgeBasePath).find((stage) => stage.contractType === "kb-knowledge-layer");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const summaryCount = countFilesRecursive(join(options.knowledgeBasePath, "summaries"));
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatKnowledgeBaseWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath })} (building graph)`);
-    }
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine knowledge-base compile behavior, entity/claim extraction, and retrieval structure."));
-    const code = await runExecutorStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "knowledge-base",
-        knowledgeBaseName,
-        workflow: workflowId,
-        workflowSourcePath: sourcePath,
-        stage: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        contractType: stageDefinition.contractType,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${summaryCount} summary files.`,
-        contract: buildKnowledgeBaseCompileContract(options.knowledgeBasePath, workflowId, summaryCount, instructions, stageDefinition.id, stageDefinition.skillDir),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${summaryCount} summary files.`,
-            `Emit STATUS: inventoried ${summaryCount}/${summaryCount} after the inventory pass completes.`,
-            `Emit STATUS: read X/${summaryCount} after each deep-read batch or every 25 files, whichever comes first.`,
-            `Emit STATUS: wrote ${stageStatusLabel} outputs after knowledge/ and home.md are updated.`,
-            `Emit DONE: ${stageStatusLabel} complete ${summaryCount}/${summaryCount} when state and navigation are updated.`,
-        ]),
-        completionCheck: () => validateKnowledgeBaseCompile(options.knowledgeBasePath).ok &&
-            validateStageContractAcceptance(options.knowledgeBasePath).ok,
-    });
-    if (code !== 0) {
-        return { ok: false, code };
-    }
-    refreshKnowledgeBaseArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-    const validation = validateStageOutcome(options.knowledgeBasePath, validateKnowledgeBaseCompile(options.knowledgeBasePath));
-    if (!validation.ok) {
-        reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, validation.summary);
-    }
-    return {
-        ok: validation.ok,
-        code: validation.ok ? 0 : 1,
-    };
-}
-export async function compileKnowledgeBase(options) {
-    refreshWorkspaceBootstrapGuidance(options.knowledgeBasePath);
-    const { sourcePath, workflowId } = resolveKnowledgeBaseContext(options.knowledgeBasePath);
-    const stages = knowledgeBaseExecutionStages(workflowId, options.knowledgeBasePath);
-    let summarize = {
-        ok: true,
-        code: 0,
-        skipped: true,
-        plan: buildSummarizePlan(sourcePath, options.knowledgeBasePath),
-    };
-    let compile = null;
-    let evidencePassCount = 0;
-    for (const stageDefinition of stages) {
-        if (stageDefinition.contractType === "kb-file-evidence") {
-            summarize = await runKnowledgeBaseSummarize({
-                executor: options.executor,
-                knowledgeBasePath: options.knowledgeBasePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportSummary: evidencePassCount === 0,
-                reportStep: true,
-                stageDefinition,
-                fullPass: evidencePassCount > 0,
-            });
-            evidencePassCount += 1;
-            if (!summarize.ok) {
-                return {
-                    ok: false,
-                    summarize,
-                    compile: null,
-                    failedStage: stageDefinition.id,
-                };
-            }
-            continue;
-        }
-        compile = await runKnowledgeBaseCompile({
-            executor: options.executor,
-            knowledgeBasePath: options.knowledgeBasePath,
-            sourcePath,
-            reporter: options.reporter,
-            reportStep: true,
-            stageDefinition,
-        });
-        if (!compile.ok) {
-            return {
-                ok: false,
-                summarize,
-                compile,
-                failedStage: stageDefinition.id,
-            };
-        }
-    }
-    return {
-        ok: compile?.ok ?? summarize.ok,
-        summarize,
-        compile,
-        failedStage: null,
-    };
-}
-export async function runInterfaceRetrieve(options) {
-    const context = resolveInterfaceContext(options.knowledgeBasePath);
-    const sourcePath = options.sourcePath ?? context.sourcePath ?? resolveKnowledgeBaseSourcePath(resolveInterfaceKnowledgeBasePath(options.knowledgeBasePath) ?? options.knowledgeBasePath);
-    const workflowId = context.workflowId;
-    const connectedKnowledgeBasePath = context.connectedKnowledgeBasePath;
-    const stageDefinition = options.stageDefinition ?? interfaceExecutionStages(workflowId, options.knowledgeBasePath).find((stage) => stage.contractType === "interface-retrieval");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const knowledgeBaseSummaryTotal = connectedKnowledgeBasePath ? countFilesRecursive(join(connectedKnowledgeBasePath, "summaries")) : 0;
-    if (options.reportStep !== false) {
-        reportLine(options.reporter, formatInterfaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath }));
-    }
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, options.knowledgeBasePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local retrieve rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use interface-local docs to refine filters, expansion heuristics, ranking, and ontology hints."),
-    ]));
-    const code = await runExecutorStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "interface",
-        knowledgeBaseName: context.knowledgeBaseName,
-        workflow: workflowId,
-        workflowSourcePath: sourcePath,
-        stage: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        contractType: stageDefinition.contractType,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} across ${knowledgeBaseSummaryTotal} knowledge-base summaries.`,
-        contract: buildInterfaceRetrieveContract(options.knowledgeBasePath, workflowId, knowledgeBaseSummaryTotal, instructions, stageDefinition.id, stageDefinition.skillDir),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${knowledgeBaseSummaryTotal} summary files.`,
-            `Emit STATUS: scanned X/${knowledgeBaseSummaryTotal} after each scan batch or every 250 files, whichever comes first.`,
-            "Emit STATUS: reviewed A abstracts, P expansion passes after the candidate-review phase is complete.",
-            "Emit STATUS: selected R relevant, J rejected, D delta after filters are applied and the retrieved set is finalized.",
-            `Emit DONE: ${stageStatusLabel} complete when \`.interf/relevant.json\`, \`.interf/coverage.json\`, and \`.interf/state.json\` are updated.`,
-        ]),
-        completionCheck: () => isRetrieveStageComplete(options.knowledgeBasePath) &&
-            validateStageContractAcceptance(options.knowledgeBasePath).ok,
-    });
-    if (code !== 0) {
-        return {
-            ok: false,
-            code,
-            knowledgeBaseSummaryTotal,
-            relevantCount: 0,
-            deltaCount: 0,
-            analyzeCount: 0,
-        };
-    }
-    refreshInterfaceArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-    const validation = validateStageOutcome(options.knowledgeBasePath, validateInterfaceRetrieve(options.knowledgeBasePath));
-    if (!validation.ok) {
-        reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, validation.summary);
-    }
-    const queryState = loadState(options.knowledgeBasePath);
-    const relevantCount = queryState?.relevant_count ?? 0;
-    const deltaCount = queryState?.delta_count ?? relevantCount;
-    const analyzeCount = deltaCount > 0 ? deltaCount : relevantCount;
-    return {
-        ok: validation.ok,
-        code: validation.ok ? 0 : 1,
-        knowledgeBaseSummaryTotal,
-        relevantCount,
-        deltaCount,
-        analyzeCount,
-    };
-}
-export async function runInterfaceAnalyze(options) {
-    const interfaceConfig = readInterfConfig(options.knowledgeBasePath);
-    const knowledgeBaseName = interfaceConfig?.name ?? "interface";
-    const workflowId = resolveInterfaceWorkflowFromConfig(interfaceConfig);
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(options.knowledgeBasePath);
-    const sourcePath = options.sourcePath ?? (connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : options.knowledgeBasePath);
-    const stageDefinition = options.stageDefinition ?? interfaceExecutionStages(workflowId, options.knowledgeBasePath).find((stage) => stage.contractType === "interface-analysis");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const queryState = loadState(options.knowledgeBasePath);
-    const relevantCount = queryState?.relevant_count ?? 0;
-    const deltaCount = queryState?.delta_count ?? relevantCount;
-    const analyzeCount = deltaCount > 0 ? deltaCount : relevantCount;
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatInterfaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath })}${analyzeCount > 0 ? ` (${analyzeCount} files)` : ""}`);
-    }
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, options.knowledgeBasePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local analyze rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use interface-local docs to refine the interface ontology, extraction schema, and evidence grouping."),
-    ]));
-    const code = await runExecutorStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "interface",
-        knowledgeBaseName,
-        workflow: workflowId,
-        workflowSourcePath: sourcePath,
-        stage: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        contractType: stageDefinition.contractType,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} for ${analyzeCount} interface summaries.`,
-        contract: buildInterfaceAnalyzeContract(options.knowledgeBasePath, workflowId, analyzeCount, instructions, stageDefinition.id, stageDefinition.skillDir),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${analyzeCount} files.`,
-            `Emit STATUS: analyzed X/${analyzeCount} after each batch or every 25 files, whichever comes first.`,
-            `Emit STATUS: wrote ${stageStatusLabel} outputs after \`.interf/analysis.json\` is updated.`,
-            `Emit DONE: ${stageStatusLabel} complete when state reflects the finished extraction pass.`,
-        ]),
-        completionCheck: () => {
-            const state = loadState(options.knowledgeBasePath);
-            return Boolean(state?.analyze_complete &&
-                existsSync(join(options.knowledgeBasePath, ".interf", "analysis.json")) &&
-                validateStageContractAcceptance(options.knowledgeBasePath).ok);
-        },
-    });
-    if (code === 0) {
-        refreshInterfaceArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-    }
-    const acceptance = code === 0
-        ? validateStageContractAcceptance(options.knowledgeBasePath)
-        : { ok: false, summary: "Stage execution failed before acceptance validation." };
-    if (code === 0 && !acceptance.ok) {
-        reportValidationFailure(options.reporter, acceptance.summary);
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, acceptance.summary);
-    }
-    return {
-        ok: code === 0 && acceptance.ok,
-        code: code === 0 && acceptance.ok ? 0 : 1,
-        relevantCount,
-        deltaCount,
-        analyzeCount,
-    };
-}
-export async function runInterfaceCompileStage(options) {
-    const interfaceConfig = readInterfConfig(options.knowledgeBasePath);
-    const knowledgeBaseName = interfaceConfig?.name ?? "interface";
-    const workflowId = resolveInterfaceWorkflowFromConfig(interfaceConfig);
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(options.knowledgeBasePath);
-    const sourcePath = options.sourcePath ?? (connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : options.knowledgeBasePath);
-    const stageDefinition = options.stageDefinition ?? interfaceExecutionStages(workflowId, options.knowledgeBasePath).find((stage) => stage.contractType === "interface-output");
-    const stageStatusLabel = stageDefinition.label.toLowerCase();
-    const relevantCount = loadState(options.knowledgeBasePath)?.relevant_count ?? 0;
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, formatInterfaceWorkflowStageStep(workflowId, stageDefinition.id, { sourcePath }));
-    }
-    const instructions = buildStageInstructions(bundledSkillForContractType(stageDefinition.contractType), mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, options.knowledgeBasePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local compile rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use interface-local docs to refine the output inventory, navigation, canvases, and final interface shape."),
-    ]));
-    const code = await runExecutorStage({
-        executor: options.executor,
-        knowledgeBasePath: options.knowledgeBasePath,
-        targetType: "interface",
-        knowledgeBaseName,
-        workflow: workflowId,
-        workflowSourcePath: sourcePath,
-        stage: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        contractType: stageDefinition.contractType,
-        summary: `Preparing ${stageDefinition.label.toLowerCase()} from ${relevantCount} relevant files.`,
-        contract: buildInterfaceCompileContract(options.knowledgeBasePath, workflowId, relevantCount, instructions, stageDefinition.id, stageDefinition.skillDir),
-        buildPrompt: (contractPath) => buildStagePrompt(instructions, contractPath, [
-            `Emit exactly one startup line: STATUS: loaded ${stageStatusLabel} plan ${relevantCount} relevant files.`,
-            "Emit STATUS: wrote entities X after the entity pass completes.",
-            "Emit STATUS: wrote claims Y after the claim pass completes.",
-            `Emit STATUS: wrote ${stageStatusLabel} outputs after local notes and home.md are updated.`,
-            `Emit DONE: ${stageStatusLabel} complete when state is updated and temporary analysis artifacts are cleaned up.`,
-        ]),
-        completionCheck: () => computeInterfaceHealth(options.knowledgeBasePath).status === "compiled" &&
-            validateStageContractAcceptance(options.knowledgeBasePath).ok,
-    });
-    if (code === 0) {
-        refreshInterfaceArtifacts(options.knowledgeBasePath, { ensureViewSpec: true });
-    }
-    const acceptance = code === 0
-        ? validateStageContractAcceptance(options.knowledgeBasePath)
-        : { ok: false, summary: "Stage execution failed before acceptance validation." };
-    if (code === 0 && !acceptance.ok) {
-        reportValidationFailure(options.reporter, acceptance.summary);
-        markRuntimeRunFailedAfterValidation(options.knowledgeBasePath, acceptance.summary);
-    }
-    return {
-        ok: code === 0 && acceptance.ok,
-        code: code === 0 && acceptance.ok ? 0 : 1,
-        relevantCount,
-    };
-}
-export async function compileInterface(options) {
-    refreshWorkspaceBootstrapGuidance(options.knowledgeBasePath);
-    const context = resolveInterfaceContext(options.knowledgeBasePath);
-    const sourcePath = context.sourcePath ?? (context.connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(context.connectedKnowledgeBasePath) : options.knowledgeBasePath);
-    const stages = interfaceExecutionStages(context.workflowId, options.knowledgeBasePath);
-    let retrieve = {
-        ok: true,
-        code: 0,
-        knowledgeBaseSummaryTotal: 0,
-        relevantCount: 0,
-        deltaCount: 0,
-        analyzeCount: 0,
-    };
-    let analyze = null;
-    let compile = null;
-    for (const stageDefinition of stages) {
-        if (stageDefinition.contractType === "interface-retrieval") {
-            retrieve = await runInterfaceRetrieve({
-                executor: options.executor,
-                knowledgeBasePath: options.knowledgeBasePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportStep: true,
-                stageDefinition,
-            });
-            if (!retrieve.ok) {
-                return {
-                    ok: false,
-                    retrieve,
-                    analyze: null,
-                    compile: null,
-                    failedStage: stageDefinition.id,
-                };
-            }
-            continue;
-        }
-        if (stageDefinition.contractType === "interface-analysis") {
-            analyze = await runInterfaceAnalyze({
-                executor: options.executor,
-                knowledgeBasePath: options.knowledgeBasePath,
-                sourcePath,
-                reporter: options.reporter,
-                reportStep: true,
-                stageDefinition,
-            });
-            if (!analyze.ok) {
-                return {
-                    ok: false,
-                    retrieve,
-                    analyze,
-                    compile: null,
-                    failedStage: stageDefinition.id,
-                };
-            }
-            continue;
-        }
-        compile = await runInterfaceCompileStage({
-            executor: options.executor,
-            knowledgeBasePath: options.knowledgeBasePath,
-            sourcePath,
-            reporter: options.reporter,
-            reportStep: true,
-            stageDefinition,
-        });
-        if (!compile.ok) {
-            return {
-                ok: false,
-                retrieve,
-                analyze,
-                compile,
-                failedStage: stageDefinition.id,
-            };
-        }
-    }
-    return {
-        ok: compile?.ok ?? analyze?.ok ?? retrieve.ok,
-        retrieve,
-        analyze,
-        compile,
-        failedStage: null,
-    };
-}
-function buildInterfaceCreateContract(options) {
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(options.knowledgeBasePath);
-    const workflowSourcePath = connectedKnowledgeBasePath
-        ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath)
-        : undefined;
-    const workflow = getInterfaceWorkflow(options.workflow, {
-        sourcePath: workflowSourcePath,
-        workspacePath: options.knowledgeBasePath,
-    });
-    const localSkills = mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, options.knowledgeBasePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance only if they materially improve the interface scaffold.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(options.knowledgeBasePath, [workflowCreateDirectory()], "Use the interface workflow's local create docs as scaffolding heuristics only if they materially improve the interface setup."),
-    ]);
-    return {
-        instructions: options.instructions,
-        counts: {
-            workflow_selected: 1,
-            local_skill_docs: localSkills.count,
-        },
-        artifacts: {
-            reads: [
-                "AGENTS.md",
-                "home.md",
-                "../../AGENTS.md",
-                "../../interf.json",
-                "../../home.md",
-                "../../knowledge/",
-                "../../summaries/",
-                ...localSkills.reads,
-            ],
-            writes: [
-                "interf.json",
-                "compile-plan.md",
-                "AGENTS.md",
-                "CLAUDE.md",
-            ],
-            verifies: [
-                "interf verify interface-plan --json",
-            ],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                `Interface name: ${options.name}.`,
-                `Selected workflow: ${workflow.id} (${workflow.label}).`,
-                `Workflow stages: ${workflow.stages.map((stage) => `${stage.label} [${stage.id}]`).join(" -> ")}.`,
-                `Use case: ${options.useCase}.`,
-                `Connected knowledge-base: ${options.knowledgeBaseName} at ${connectedKnowledgeBasePath ?? "unknown"}.`,
-                "The scaffold already exists with home.md, AGENTS.md, CLAUDE.md, interf.json, and the .interf runtime artifacts.",
-                "Read the current local AGENTS.md and home.md first. They are the interface workspace bootstrap you are updating.",
-                "Then consult ../../AGENTS.md and ../../home.md for parent knowledge-base navigation and evidence structure.",
-                "This interface lives inside the parent knowledgeBase. Do not assume it will be opened as a standalone Obsidian vault.",
-                "Do not recreate the vault or ask follow-up questions.",
-                "Use the selected workflow as the starting point, then adapt it to the knowledge-base data and the use case.",
-                "Edit the existing compile-plan.md scaffold in place. Preserve the stage headings and required subsection labels from the starter plan; refine the bullets and narrative instead of replacing the structure.",
-                "Preserve the existing AGENTS.md scaffold sections, especially the manual access checklist, raw-source gate, and navigation/router guidance. Update only the interface-specific description and lines that must reflect the use case.",
-                "Do not replace AGENTS.md with a shorter template.",
-                "Analyze the knowledge-base and update only the interface definition files in this vault: interf.json, compile-plan.md, and AGENTS.md. CLAUDE.md is a generated mirror of AGENTS.md and will be rewritten by the harness.",
-                ...localSkills.notes,
-            ],
-        },
-    };
-}
-function buildKnowledgeBaseCompileContract(knowledgeBasePath, workflowId, summaryCount, instructions, stageId = "compile", stageSkillDir = "compile") {
-    const sourcePath = resolveKnowledgeBaseSourcePath(knowledgeBasePath);
-    const acceptance = resolveStageAcceptance("knowledge-base", workflowId, stageId, sourcePath, knowledgeBasePath);
-    const localSkills = buildLocalSkillContractExtension(knowledgeBasePath, [workflowCompileStageDirectory(stageSkillDir)], "Use them to refine knowledge-base compile behavior, entity/claim extraction, and retrieval structure.");
-    return {
-        instructions,
-        counts: {
-            summary_total: summaryCount,
-            local_skill_docs: localSkills.count,
-        },
-        ...(acceptance ? { acceptance } : {}),
-        artifacts: {
-            reads: [
-                "AGENTS.md",
-                "home.md",
-                "interf.json",
-                ".interf/state.json",
-                "summaries/",
-                ...localSkills.reads,
-            ],
-            writes: [
-                ".interf/inventory.json",
-                "knowledge/entities/",
-                "knowledge/claims/",
-                "knowledge/indexes/",
-                "home.md",
-                ".interf/state.json",
-                ".interf/health.json",
-            ],
-            verifies: [
-                "interf verify compile --json",
-            ],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                "Read `AGENTS.md` first for workspace navigation, evidence expectations, and command usage.",
-                "Build or refresh `.interf/inventory.json` first, then use it as the progress ledger for the rest of the run.",
-                "This stage is the knowledge-base compile pass. Treat synthesis outputs as evidence objects, not final truth.",
-                "Use a multi-pass approach: inventory -> local evidence reading -> canonicalization -> retrieval optimization.",
-                "Build retrieval-oriented outputs: canonical entities, cross-file claims, timelines, themes, and navigation indexes that make interface retrieval easier later.",
-                "Write structured knowledge outputs under `knowledge/entities/`, `knowledge/claims/`, and `knowledge/indexes/`.",
-                "Do not collapse the knowledge-base knowledge layer into flat files like `knowledge/entities.md` or `knowledge/claims.md`.",
-                ...getWorkflowStagePolicyNotes("knowledge-base", workflowId, stageId, sourcePath, knowledgeBasePath),
-                ...localSkills.notes,
-            ],
-            evidence_weighting: {
-                required_fields: ["source_kind", "evidence_tier", "truth_mode", "state"],
-                preserve_tiers: true,
-            },
-            working_set: {
-                target_context_fraction: 0.4,
-                strategy: "Batch summary reads into bounded working sets, then canonicalize and optimize retrieval in multiple passes.",
-            },
-        },
-    };
-}
-function buildInterfaceRetrieveContract(interfacePath, workflowId, summaryCount, instructions, stageId = "retrieve", stageSkillDir = "retrieve") {
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(interfacePath);
-    const sourcePath = connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : undefined;
-    const acceptance = resolveStageAcceptance("interface", workflowId, stageId, sourcePath, interfacePath);
-    const localSkills = mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, interfacePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local retrieve rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(interfacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use interface-local docs to refine filters, expansion heuristics, ranking, and ontology hints."),
-    ]);
-    return {
-        instructions,
-        counts: {
-            knowledge_base_summary_total: summaryCount,
-            local_skill_docs: localSkills.count,
-        },
-        ...(acceptance ? { acceptance } : {}),
-        artifacts: {
-            reads: [
-                "AGENTS.md",
-                "home.md",
-                "../../AGENTS.md",
-                "../../home.md",
-                "interf.json",
-                "compile-plan.md",
-                "../../.interf/source-access.json",
-                "../../summaries/",
-                ".interf/state.json",
-                ...localSkills.reads,
-            ],
-            writes: [
-                ".interf/relevant.json",
-                ".interf/coverage.json",
-                ".interf/state.json",
-                ".interf/health.json",
-            ],
-            verifies: [
-                "interf verify retrieve --json",
-            ],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                "Read local `AGENTS.md` first, then consult parent knowledge-base `../../AGENTS.md` and `../../home.md` before considering raw-source fallback.",
-                "Access hierarchy for this stage is: local interface artifacts -> parent knowledge-base artifacts -> raw source files only when needed.",
-                "Treat the interface runtime in compile-plan.md as an initial hypothesis, not a final truth.",
-                "Scan ALL knowledge-base summaries frontmatter before making any selection.",
-                "Review abstracts for the candidate set, expand through linked summaries when needed, and stop only when the retrieved set is coverage-complete for this interface.",
-                "Selection quality is judged by the proof of reviewed, retrieved, and excluded files, not by superficial brevity.",
-                "If you need raw-file fallback, inspect `../../.interf/source-access.json` first and verify one suggested path is readable. These are canonical absolute source-file paths shared by the parent knowledge base. If they are not reachable, continue from knowledge-base summaries and report that raw fallback was unavailable.",
-                ...getWorkflowStagePolicyNotes("interface", workflowId, stageId, sourcePath, interfacePath),
-                ...localSkills.notes,
-            ],
-            evidence_weighting: {
-                required_fields: ["source_kind", "evidence_tier", "truth_mode", "state"],
-                preserve_tiers: true,
-            },
-            working_set: {
-                target_context_fraction: 0.15,
-                strategy: "Frontmatter scan first, then abstract review, then linked expansion only where coverage proof requires it.",
-            },
-        },
-    };
-}
-function buildInterfaceAnalyzeContract(interfacePath, workflowId, analyzeCount, instructions, stageId = "analyze", stageSkillDir = "analyze") {
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(interfacePath);
-    const sourcePath = connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : undefined;
-    const acceptance = resolveStageAcceptance("interface", workflowId, stageId, sourcePath, interfacePath);
-    const localSkills = mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, interfacePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local analyze rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(interfacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use interface-local docs to refine the interface ontology, extraction schema, and evidence grouping."),
-    ]);
-    return {
-        instructions,
-        counts: {
-            relevant_total: analyzeCount,
-            local_skill_docs: localSkills.count,
-        },
-        ...(acceptance ? { acceptance } : {}),
-        artifacts: {
-            reads: [
-                "AGENTS.md",
-                "home.md",
-                "../../AGENTS.md",
-                "../../home.md",
-                "interf.json",
-                "compile-plan.md",
-                ".interf/relevant.json",
-                "../../.interf/source-access.json",
-                "../../summaries/",
-                ".interf/state.json",
-                ...localSkills.reads,
-            ],
-            writes: [
-                ".interf/analysis.json",
-                ".interf/state.json",
-                ".interf/health.json",
-            ],
-            verifies: [],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                "Read local `AGENTS.md` first, then consult parent knowledge-base `../../AGENTS.md` and `../../home.md` before considering raw-source fallback.",
-                "Access hierarchy for this stage is: local interface artifacts -> parent knowledge-base artifacts -> raw source files only when needed.",
-                "This is the deep extraction pass over the relevant set selected by retrieve.",
-                "Refine the interface runtime from evidence when the knowledge base clearly demands it.",
-                "Keep extraction local to the interface ontology and output goals.",
-                "If you need raw-file fallback, inspect `../../.interf/source-access.json` first and verify one suggested path is readable. These are canonical absolute source-file paths shared by the parent knowledge base. If they are not reachable, continue from knowledge-base summaries and report that raw fallback was unavailable.",
-                ...getWorkflowStagePolicyNotes("interface", workflowId, stageId, sourcePath, interfacePath),
-                ...localSkills.notes,
-            ],
-            evidence_weighting: {
-                required_fields: ["source_kind", "evidence_tier", "truth_mode", "state"],
-                preserve_tiers: true,
-            },
-            working_set: {
-                target_context_fraction: 0.3,
-                strategy: "Batch relevant summaries into bounded sets, derive local entities/claims, then merge before writing analysis artifacts.",
-            },
-        },
-    };
-}
-function buildInterfaceCompileContract(interfacePath, workflowId, relevantCount, instructions, stageId = "compile", stageSkillDir = "compile") {
-    const connectedKnowledgeBasePath = resolveInterfaceKnowledgeBasePath(interfacePath);
-    const sourcePath = connectedKnowledgeBasePath ? resolveKnowledgeBaseSourcePath(connectedKnowledgeBasePath) : undefined;
-    const acceptance = resolveStageAcceptance("interface", workflowId, stageId, sourcePath, interfacePath);
-    const localSkills = mergeLocalSkillContractExtensions([
-        connectedKnowledgeBasePath
-            ? buildLocalSkillContractExtensionRelativeTo(connectedKnowledgeBasePath, interfacePath, [workflowQueryDirectory()], "Use the connected knowledge-base workflow docs as higher-level knowledge-base guidance before applying interface-local compile rules.")
-            : emptyLocalSkillContractExtension(),
-        buildLocalSkillContractExtension(interfacePath, [workflowCompileStageDirectory(stageSkillDir)], "Use interface-local docs to refine the output inventory, navigation, canvases, and final interface shape."),
-    ]);
-    return {
-        instructions,
-        counts: {
-            relevant_total: relevantCount,
-            local_skill_docs: localSkills.count,
-        },
-        ...(acceptance ? { acceptance } : {}),
-        artifacts: {
-            reads: [
-                "AGENTS.md",
-                "home.md",
-                "../../AGENTS.md",
-                "../../home.md",
-                "interf.json",
-                "compile-plan.md",
-                ".interf/analysis.json",
-                ".interf/relevant.json",
-                "../../.interf/source-access.json",
-                "../../summaries/",
-                ...localSkills.reads,
-            ],
-            writes: [
-                "knowledge/",
-                "briefs/",
-                "summaries/",
-                "home.md",
-                ".interf/state.json",
-                ".interf/health.json",
-            ],
-            verifies: [],
-        },
-        policies: {
-            execution_mode: "deterministic",
-            status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
-            notes: [
-                "Read local `AGENTS.md` first, then consult parent knowledge-base `../../AGENTS.md` and `../../home.md` before considering raw-source fallback.",
-                "Access hierarchy for this stage is: local interface artifacts -> parent knowledge-base artifacts -> raw source files only when needed.",
-                "The interface is a local context shell for agents. Build it so an agent can navigate AGENTS.md -> home.md -> local knowledge/briefs/summaries -> knowledge-base summaries -> raw only when needed.",
-                "When local outputs cite knowledge-base evidence, point to the parent knowledge-base summary path `../../summaries/...`, not the interface-local `summaries/` folder.",
-                "Prefer durable local notes and indexes over monolithic summaries.",
-                "Delete stale analysis handoff artifacts once durable outputs and state have been written.",
-                "If you need raw-file fallback, inspect `../../.interf/source-access.json` first and verify one suggested path is readable. These are canonical absolute source-file paths shared by the parent knowledge base. If they are not reachable, continue from knowledge-base summaries and report that raw fallback was unavailable.",
-                ...getWorkflowStagePolicyNotes("interface", workflowId, stageId, sourcePath, interfacePath),
-                ...localSkills.notes,
-            ],
-            evidence_weighting: {
-                required_fields: ["source_kind", "evidence_tier", "truth_mode", "state"],
-                preserve_tiers: true,
-            },
-            working_set: {
-                target_context_fraction: 0.25,
-                strategy: "Use analysis artifacts as the compile ledger, then write entities, claims, briefs, and navigation in separate local passes.",
-            },
-        },
-    };
-}
+// ---------------------------------------------------------------------------
+// Re-exports — KB orchestration
+// ---------------------------------------------------------------------------
+export { runKnowledgeBaseSummarize, runKnowledgeBaseCompile, compileKnowledgeBase, } from "./workflows-kb.js";
+// ---------------------------------------------------------------------------
+// Re-exports — Interface orchestration
+// ---------------------------------------------------------------------------
+export { planInterface, runInterfaceRetrieve, runInterfaceAnalyze, runInterfaceCompileStage, compileInterface, } from "./workflows-interface.js";
 //# sourceMappingURL=workflows.js.map