@interf/compiler 0.1.10 → 0.1.12

package/dist/lib/interf.js

@@ -1,1104 +1,6 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, copyFileSync, } from "node:fs";
-import { createHash } from "node:crypto";
-import { homedir } from "node:os";
-import { basename, join, resolve, relative } from "node:path";
-import { KNOWLEDGE_BASE_INTERFIGNORE } from "./config.js";
-import { getInterfaceWorkflow, getKnowledgeBaseWorkflow, listInterfaceWorkflowChoices, listKnowledgeBaseInterfaceWorkflowChoices, } from "./workflow-definitions.js";
-import { refreshKnowledgeBaseArtifacts, saveState, initKnowledgeBaseState, initInterfaceState, refreshInterfaceArtifacts, } from "./state.js";
-import { loadUserConfig } from "./user-config.js";
-import { safeReadJsonFile } from "./parse.js";
-import { renderJsonFrontmatter } from "./parse.js";
-import { InterfConfigSchema, } from "./schema.js";
-const INTERF_CONTAINER_NAME = "interf";
-const WORKFLOW_CONTAINER_NAME = "workflows";
-const BENCHMARK_CONTAINER_NAME = "benchmarks";
-const INTERF_CONFIG_FILE = "interf.json";
-const WORKFLOW_PACKAGE_DIR = "workflow";
-const BASE_GRAPH_SETTINGS = {
-    "collapse-filter": true,
-    search: 'path:"summaries" OR path:"knowledge" OR path:"home"',
-    showTags: false,
-    showAttachments: false,
-    hideUnresolved: true,
-    showOrphans: false,
-};
-const INTERFACE_GRAPH_SETTINGS = {
-    "collapse-filter": true,
-    search: 'path:"knowledge" OR path:"briefs" OR path:"summaries" OR path:"home"',
-    showTags: false,
-    showAttachments: false,
-    hideUnresolved: true,
-    showOrphans: false,
-};
-function buildInterfaceStagePolicySection(notes) {
-    if (!notes || notes.length === 0)
-        return [];
-    return [
-        "### Workflow bias",
-        ...notes.map((note) => `- ${note}`),
-        "",
-    ];
-}
-function formatWorkflowStageFolders(stages) {
-    return stages.map((stage) => `\`workflow/compile/stages/${stage.skillDir}/\``).join(", ");
-}
-function formatWorkflowStageSequence(stages) {
-    return stages.map((stage) => stage.label).join(" -> ");
-}
-function buildWorkspaceRuntimeControlLines(workspaceLabel) {
-    return [
-        `- Source folder = CLI control plane and real files. This ${workspaceLabel} = generated workspace.`,
-        `- The source folder normally has no generated \`AGENTS.md\` or \`CLAUDE.md\`. For agents, this ${workspaceLabel} workspace is the bootstrap entrypoint.`,
-        `- \`.interf/run.json\` — current/last deterministic stage run, including executor and timestamps.`,
-        `- \`.interf/stage-contract.json\` — machine-readable contract for the active stage.`,
-        `- Stage instructions are flexible. Interf cares about contract compliance: reads, writes, verifiers, and state transitions.`,
-        `- Local workflow docs customize stage implementation. They do not replace the workflow's stage order, proof rules, or state flow.`,
-    ];
-}
-function buildWorkspaceAgentLayerLines(stageFolders, workspaceLabel) {
-    return [
-        `Treat \`AGENTS.md\` as the directory-level router for navigation, path rules, command usage, and which local workflow docs to read next.`,
-        `Treat local \`workflow/.../SKILL.md\` files as workspace instruction docs. Do not assume they are globally installed slash-command skills; load them because \`AGENTS.md\` or the stage contract points to them.`,
-        `If \`workflow/use/query/\` exists, read it before answering manual questions from this ${workspaceLabel}. For interfaces, that local query doc may send you to the parent knowledge-base \`../../workflow/use/query/SKILL.md\` loop.`,
-        `On the first substantive manual question, run the raw-source gate immediately. For interfaces, verify parent knowledge-base reachability first, then check raw reachability. If the environment asks for permission, request it immediately instead of guessing. After that check, start the answer with exactly one line: \`Raw access: confirmed\` or \`Raw access: unavailable\`. \`confirmed\` means a suggested raw path was actually readable; \`unavailable\` means the raw check failed or permission was denied.`,
-        `If local workflow docs exist under \`workflow/compile/stages/\` (${stageFolders}), read them before running a stage. A doc can declare \`mode: extend\` or \`mode: override\` in JSON frontmatter. Override replaces the bundled workflow instructions for that stage, but Interf still enforces the same proof, schema, verifier, and state-machine rules.`,
-    ];
-}
-function topKnowledgeBaseManualPreflightBlock() {
-    return [
-        "## First question: required preflight",
-        "",
-        "Before describing this workspace or answering from compiled notes:",
-        "",
-        "1. Read `workflow/use/query/SKILL.md` now.",
-        "2. Confirm `home.md`, `knowledge/`, and `summaries/` are reachable.",
-        "3. Inspect `.interf/source-access.json` and try one `suggested_checks` path immediately.",
-        "4. If the environment asks for permission, request it right away instead of guessing.",
-        "5. Start the answer with exactly `Raw access: confirmed` or `Raw access: unavailable`.",
-        "",
-    ];
-}
-function topInterfaceManualPreflightBlock() {
-    return [
-        "## First question: required preflight",
-        "",
-        "Before describing this workspace or answering from compiled notes:",
-        "",
-        "1. Read local `workflow/use/query/SKILL.md` now.",
-        "2. Confirm local interface artifacts are reachable: `home.md`, `knowledge/`, `briefs/`, and local `summaries/`.",
-        "3. Confirm parent KB reachability via `../../AGENTS.md`, `../../home.md`, or `../../summaries/`.",
-        "4. Inspect `../../.interf/source-access.json` and try one `suggested_checks` path immediately.",
-        "5. If the environment asks for permission, request it right away instead of guessing.",
-        "6. Start the answer with exactly `Raw access: confirmed` or `Raw access: unavailable`.",
-        "",
-    ];
-}
-function renderInterfaceCompilePlanStageSection(stage, index, useCase, notes) {
-    const heading = `## Stage ${index + 1} — ${stage.label}`;
-    switch (stage.contractType) {
-        case "interface-retrieval":
-            return [
-                heading,
-                "### Goal",
-                `Retrieve the knowledge-base summaries needed to answer this interface's job: ${useCase}.`,
-                "### Filter criteria",
-                `- prioritize summaries that directly help answer: ${useCase}`,
-                "### Key entities:",
-                "- people, companies, products, systems, decisions, claims, and evidence objects tied to the use case",
-                "### Priority evidence tiers:",
-                "- direct source-backed summaries",
-                "- recent or canonical summaries",
-                "- linked supporting summaries that close coverage gaps",
-                "### Truth modes to prioritize or downweight:",
-                "- prioritize current, observed, and final material",
-                "- downweight speculative, stale, or weakly supported material unless needed for coverage",
-                "### Expected relevant file count:",
-                "- start narrow, then expand until coverage proof is complete",
-                ...buildInterfaceStagePolicySection(notes),
-                "### Method",
-                "- Scan frontmatter for all knowledge-base summaries in `../../summaries/`.",
-                "- Read candidate abstracts before narrowing.",
-                "- Expand through linked summaries when needed to prove coverage.",
-                "- Write `.interf/relevant.json` and `.interf/coverage.json`.",
-                "",
-            ];
-        case "interface-analysis":
-            return [
-                heading,
-                "### Goal",
-                `Extract the interface-specific structure and findings needed for: ${useCase}.`,
-                "### Batching:",
-                "- analyze relevant summaries in bounded batches, then merge local findings",
-                "### Entities:",
-                "- derive the entities, themes, and evidence objects this interface needs",
-                "### Claims:",
-                "- record evidence-backed claims, contradictions, and open questions for the use case",
-                ...buildInterfaceStagePolicySection(notes),
-                "### Method",
-                "- Use `.interf/relevant.json` as the analysis ledger.",
-                "- Refine the local ontology from evidence, not just the initial wording.",
-                "- Write `.interf/analysis.json`.",
-                "",
-            ];
-        case "interface-output":
-            return [
-                heading,
-                "### Goal",
-                "Compile local interface outputs an agent can use immediately.",
-                "### Output files",
-                "- `home.md`",
-                "- `knowledge/`",
-                "- `briefs/`",
-                "- `summaries/` when interface-local summaries are useful",
-                ...buildInterfaceStagePolicySection(notes),
-                "### Method",
-                `- Write local notes and briefs for: ${useCase}.`,
-                "- Keep citations pointing at `../../summaries/...` when using parent knowledge-base evidence.",
-                "- Write `home.md`, `knowledge/`, and `briefs/`, then update `.interf/state.json`.",
-                "",
-            ];
-        default:
-            return [
-                heading,
-                "### Goal",
-                `Complete the ${stage.label} stage for this interface.`,
-                "### Method",
-                "- Follow the active stage contract and write the required artifacts.",
-                ...buildInterfaceStagePolicySection(notes),
-                "",
-            ];
-    }
-}
-function renderInterfaceCompilePlanTemplate(options) {
-    const useCase = options.useCase?.trim() || options.workflowPlaceholder || options.workflowHint;
-    const stageSections = options.stages.flatMap((stage, index) => renderInterfaceCompilePlanStageSection(stage, index, useCase, options.stagePolicyNotes?.[stage.id]));
-    return [
-        "# Compile Plan",
-        "",
-        "## Interface Goal",
-        `- workflow: \`${options.workflowId}\` (${options.workflowLabel})`,
-        `- use case: ${useCase}`,
-        `- method: ${options.workflowHint}`,
-        "",
-        ...stageSections,
-    ].join("\n");
-}
-export function writeInterfaceCompilePlanTemplate(dirPath, options) {
-    const workflow = getInterfaceWorkflow(options.workflowId, {
-        sourcePath: options.sourcePath,
-        workspacePath: dirPath,
-    });
-    const config = readInterfConfig(dirPath);
-    const interfaceName = options.interfaceName ?? config?.name ?? basename(dirPath);
-    const content = renderInterfaceCompilePlanTemplate({
-        interfaceName,
-        workflowId: workflow.id,
-        workflowLabel: workflow.label,
-        workflowHint: workflow.hint,
-        workflowPlaceholder: workflow.placeholder,
-        useCase: options.useCase,
-        stages: workflow.stages,
-        stagePolicyNotes: workflow.stagePolicyNotes,
-    });
-    writeFileSync(join(dirPath, "compile-plan.md"), content);
-}
-export function readInterfConfig(dirPath) {
-    const configPath = join(dirPath, INTERF_CONFIG_FILE);
-    if (!existsSync(configPath))
-        return null;
-    const raw = safeReadJsonFile(configPath, "Interf config");
-    if (!raw)
-        return null;
-    const parsed = InterfConfigSchema.safeParse(raw);
-    return parsed.success ? parsed.data : null;
-}
-export function detectInterf(cwd) {
-    // Check if cwd itself is a knowledge-base (has interf.json)
-    const config = readInterfConfig(cwd);
-    if (config)
-        return { path: cwd, config };
-    const directChildren = listKnowledgeBaseChildren(join(cwd, INTERF_CONTAINER_NAME));
-    if (directChildren.length === 1) {
-        return directChildren[0];
-    }
-    if (basename(cwd) === INTERF_CONTAINER_NAME) {
-        const nestedChildren = listKnowledgeBaseChildren(cwd);
-        if (nestedChildren.length === 1) {
-            return nestedChildren[0];
-        }
-    }
-    return null;
-}
-export function resolveKnowledgeBase(cwd) {
-    const detected = detectInterf(cwd);
-    if (!detected)
-        return null;
-    if (detected.config.type === "knowledge-base") {
-        const sourcePath = resolveKnowledgeBaseSourcePath(detected.path, detected.config);
-        return {
-            sourcePath,
-            knowledgeBasePath: detected.path,
-            config: detected.config,
-        };
-    }
-    return null;
-}
-export function resolveInterfaceKnowledgeBasePath(interfacePath) {
-    const config = readInterfConfig(interfacePath);
-    if (!config || config.type !== "interface")
-        return null;
-    const knowledgeBasePath = config.knowledge_base?.path;
-    if (!knowledgeBasePath)
-        return null;
-    return resolve(interfacePath, knowledgeBasePath);
-}
-export function resolveKnowledgeBaseSourcePath(knowledgeBasePath, config = readInterfConfig(knowledgeBasePath)) {
-    return config?.type === "knowledge-base" && config.source?.path
-        ? resolve(knowledgeBasePath, config.source.path)
-        : resolve(knowledgeBasePath, "..", "..");
-}
-function listKnowledgeBaseChildren(containerPath) {
-    if (!existsSync(containerPath))
-        return [];
-    try {
-        if (!statSync(containerPath).isDirectory())
-            return [];
-    }
-    catch {
-        return [];
-    }
-    return readdirSync(containerPath)
-        .map((entry) => join(containerPath, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    })
-        .map((entryPath) => {
-        const config = readInterfConfig(entryPath);
-        return config?.type === "knowledge-base" ? { path: entryPath, config } : null;
-    })
-        .filter((value) => value !== null);
-}
-export function listKnowledgeBasesForSourceFolder(sourcePath) {
-    return listKnowledgeBaseChildren(join(sourcePath, INTERF_CONTAINER_NAME));
-}
-function assertKnowledgeBaseContainer(sourcePath) {
-    const containerPath = join(sourcePath, INTERF_CONTAINER_NAME);
-    if (!existsSync(containerPath)) {
-        return containerPath;
-    }
-    const stat = statSync(containerPath);
-    if (!stat.isDirectory()) {
-        throw new Error(`Interf container exists and is not a directory: ${containerPath}`);
-    }
-    const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
-        if (entry.startsWith("."))
-            return false;
-        const entryPath = join(containerPath, entry);
-        if (entry === WORKFLOW_CONTAINER_NAME || entry === BENCHMARK_CONTAINER_NAME) {
-            try {
-                return !statSync(entryPath).isDirectory();
-            }
-            catch {
-                return true;
-            }
-        }
-        try {
-            if (!statSync(entryPath).isDirectory())
-                return true;
-        }
-        catch {
-            return true;
-        }
-        const config = readInterfConfig(entryPath);
-        return config?.type !== "knowledge-base";
-    });
-    if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf container contains non-knowledge-base entries: ${containerPath}`);
-    }
-    return containerPath;
-}
-function isInterfaceVaultPath(vaultPath) {
-    const segments = resolve(vaultPath).split(/[\\/]+/).filter(Boolean);
-    const interfIndex = segments.lastIndexOf(INTERF_CONTAINER_NAME);
-    const interfacesIndex = segments.lastIndexOf("interfaces");
-    return interfIndex >= 0 && interfacesIndex > interfIndex && interfacesIndex < segments.length - 1;
-}
-export function cleanupLegacyObsidianInterfaceVaultRegistrations() {
-    const registryPath = getObsidianRegistryPath();
-    if (!registryPath || !existsSync(registryPath))
-        return 0;
-    try {
-        const current = JSON.parse(readFileSync(registryPath, "utf8"));
-        const rawVaults = current && typeof current === "object" && current.vaults && typeof current.vaults === "object"
-            ? { ...current.vaults }
-            : null;
-        if (!rawVaults)
-            return 0;
-        let removed = 0;
-        for (const [key, value] of Object.entries(rawVaults)) {
-            const vaultPath = typeof value?.path === "string" ? resolve(value.path) : null;
-            if (!vaultPath)
-                continue;
-            if (!isInterfaceVaultPath(vaultPath))
-                continue;
-            const config = readInterfConfig(vaultPath);
-            const isLegacyInterfaceVault = !config || config.type === "interface";
-            if (!isLegacyInterfaceVault)
-                continue;
-            delete rawVaults[key];
-            removed += 1;
-        }
-        if (removed === 0)
-            return 0;
-        const next = {
-            ...(current && typeof current === "object" ? current : {}),
-            vaults: rawVaults,
-        };
-        writeFileSync(registryPath, JSON.stringify(next) + "\n");
-        return removed;
-    }
-    catch {
-        return 0;
-    }
-}
-function assertWritableTargetDir(dirPath, label) {
-    if (!existsSync(dirPath))
-        return;
-    const stat = statSync(dirPath);
-    if (!stat.isDirectory()) {
-        throw new Error(`${label} target exists and is not a directory: ${dirPath}`);
-    }
-    if (readdirSync(dirPath).length > 0) {
-        throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
-    }
-}
-function assertWorkspaceName(name, label) {
-    if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
-        throw new Error(`${label} name must be a safe slug with lowercase letters, numbers, and dashes only: ${name}`);
-    }
-}
-function renderClaudeBootstrap(content) {
-    return [
-        "<!-- Generated from AGENTS.md. Edit AGENTS.md; Interf will rewrite this file. -->",
-        "",
-        content.trimEnd(),
-        "",
-    ].join("\n");
-}
-function writeInterfConfigFile(dirPath, config) {
-    writeFileSync(join(dirPath, INTERF_CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`);
-}
-function writeAgentBootstrapFiles(dirPath, content) {
-    writeFileSync(join(dirPath, "AGENTS.md"), content);
-    writeFileSync(join(dirPath, "CLAUDE.md"), renderClaudeBootstrap(content));
-}
-function insertLineAfterFirstMatch(content, predicate, insertedLine) {
-    if (content.includes(insertedLine))
-        return content;
-    const lines = content.split("\n");
-    const index = lines.findIndex(predicate);
-    if (index === -1)
-        return content;
-    lines.splice(index + 1, 0, insertedLine);
-    return lines.join("\n");
-}
-function insertBlockBeforeFirstMatch(content, predicate, blockLines) {
-    const marker = blockLines.find((line) => line.trim().length > 0);
-    if (marker && content.includes(marker))
-        return content;
-    const lines = content.split("\n");
-    const index = lines.findIndex(predicate);
-    if (index === -1)
-        return content;
-    lines.splice(index, 0, ...blockLines);
-    return lines.join("\n");
-}
-function refreshLegacyAgentsBootstrap(content) {
-    const legacyLine = "On the first substantive reply in a manual session, make the raw-access status explicit: confirmed, unverified, or unavailable. Do not trigger a permission prompt just to greet the user; verify raw access only when the user asks about raw files or the answer depends on raw verification.";
-    const previousLine = "On the first substantive reply in a manual session, start with exactly one line: `Raw access: unverified`, `Raw access: confirmed`, or `Raw access: unavailable`. Use `unverified` until you actually run the raw-source gate, `confirmed` only after a suggested raw path is readable, and `unavailable` only after a raw check fails or permission is denied. Do not trigger a permission prompt just to greet the user; verify raw access only when the user asks about raw files or the answer depends on raw verification.";
-    const currentLine = "On the first substantive manual question, run the raw-source gate immediately. For interfaces, verify parent knowledge-base reachability first, then check raw reachability. If the environment asks for permission, request it immediately instead of guessing. After that check, start the answer with exactly one line: `Raw access: confirmed` or `Raw access: unavailable`. `confirmed` means a suggested raw path was actually readable; `unavailable` means the raw check failed or permission was denied.";
-    let replaced = content;
-    if (replaced.includes(legacyLine))
-        replaced = replaced.replace(legacyLine, currentLine);
-    if (replaced.includes(previousLine))
-        replaced = replaced.replace(previousLine, currentLine);
-    let refreshed = insertLineAfterFirstMatch(replaced, (line) => line.startsWith("If `workflow/use/query/` exists, read it before answering manual questions"), currentLine);
-    const block = refreshed.includes("../../.interf/source-access.json")
-        ? topInterfaceManualPreflightBlock()
-        : topKnowledgeBaseManualPreflightBlock();
-    refreshed = insertBlockBeforeFirstMatch(refreshed, (line) => line.startsWith("## How this "), block);
-    return refreshed;
-}
-function refreshLegacyKnowledgeBaseQuerySkill(content) {
-    const legacyBlock = [
-        "First-reply rule:",
-        "- on your first substantive reply, say whether raw access is confirmed, unverified, or unavailable",
-        "- do not trigger a permission prompt just to introduce the workspace",
-        "- if the user asks whether raw files are reachable, perform the raw-source gate immediately and report the result clearly",
-        "",
-    ].join("\n");
-    const currentBlock = [
-        "First-reply rule:",
-        "- on the first substantive manual question, inspect `.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, still prefer compiled knowledge unless the user asks for direct quotes or raw verification",
-        "",
-    ].join("\n");
-    const topBlock = [
-        "## First question: required preflight",
-        "",
-        "Before browsing notes on your own or answering from compiled knowledge:",
-        "",
-        "- inspect `.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "",
-    ];
-    let normalized = content.includes(legacyBlock) ? content.replace(legacyBlock, currentBlock) : content;
-    normalized = insertBlockBeforeFirstMatch(normalized, (line) => line.startsWith("Default loop:"), topBlock);
-    return insertBlockBeforeFirstMatch(normalized, (line) => line.startsWith("You can edit this file to bias manual question-answering behavior"), [
-        "First-reply rule:",
-        "- on the first substantive manual question, inspect `.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, still prefer compiled knowledge unless the user asks for direct quotes or raw verification",
-        "",
-    ]);
-}
-function refreshLegacyInterfaceQuerySkill(content) {
-    const legacyBlock = [
-        "First-reply rule:",
-        "- on your first substantive reply, say whether raw access is confirmed, unverified, or unavailable",
-        "- do not trigger a permission prompt just to introduce the workspace",
-        "- if the user asks whether raw files are reachable, perform the raw-source gate immediately and report the result clearly",
-        "",
-    ].join("\n");
-    const currentBlock = [
-        "First-reply rule:",
-        "- on the first substantive manual question, verify parent KB reachability first, then inspect `../../.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, use local interface artifacts first, then the parent KB loop, and raw files mainly for quotes or verification",
-        "",
-    ].join("\n");
-    const topBlock = [
-        "## First question: required preflight",
-        "",
-        "Before browsing notes on your own or answering from compiled interface outputs:",
-        "",
-        "- verify parent KB reachability first, then inspect `../../.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "",
-    ];
-    let normalized = content.includes(legacyBlock) ? content.replace(legacyBlock, currentBlock) : content;
-    normalized = insertBlockBeforeFirstMatch(normalized, (line) => line.startsWith("Default loop:"), topBlock);
-    return insertBlockBeforeFirstMatch(normalized, (line) => line.startsWith("Keep the interface-specific behavior here."), [
-        "First-reply rule:",
-        "- on the first substantive manual question, verify parent KB reachability first, then inspect `../../.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, use local interface artifacts first, then the parent KB loop, and raw files mainly for quotes or verification",
-        "",
-    ]);
-}
-function writeWorkflowStarterDocs(dirPath, docs) {
-    for (const doc of docs ?? []) {
-        const targetPath = join(dirPath, doc.relativePath);
-        mkdirSync(resolve(targetPath, ".."), { recursive: true });
-        writeFileSync(targetPath, doc.content);
-    }
-}
-function workflowPackagePath(dirPath) {
-    return join(dirPath, WORKFLOW_PACKAGE_DIR);
-}
-function workflowInterfacesPath(knowledgeBasePath) {
-    return join(workflowPackagePath(knowledgeBasePath), "interfaces");
-}
-function writeWorkflowPackageJson(rootPath, targetType, workflow) {
-    writeFileSync(join(rootPath, "workflow.json"), `${JSON.stringify({
-        id: workflow.id,
-        type: targetType,
-        label: workflow.label,
-        hint: workflow.hint,
-        ...(workflow.placeholder ? { placeholder: workflow.placeholder } : {}),
-        stages: workflow.stages.map((stage) => ({
-            id: stage.id,
-            label: stage.label,
-            description: stage.description,
-            contract_type: stage.contractType,
-            skill_dir: stage.skillDir,
-            ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
-        })),
-        ...(workflow.stagePolicyNotes ? { stage_policy_notes: workflow.stagePolicyNotes } : {}),
-    }, null, 2)}\n`);
-}
-function defaultWorkflowReadme(targetType, workflow) {
-    const stageLines = workflow.stages.map((stage) => `- \`${stage.id}\` — ${stage.description} (${stage.contractType})`);
-    return [
-        `# ${workflow.label}`,
-        "",
-        `This is the local ${targetType} workflow package. Interf uses it when you run \`interf compile\`.`,
-        "",
-        "- `workflow.json` defines the stage graph and contract kinds for this workspace.",
-        "- `create/` explains what the scaffold/setup step produces.",
-        "- `compile/stages/` contains one stage folder per compile stage.",
-        "- `use/query/` explains how to use the compiled knowledge base or interface in manual agent sessions.",
-        "",
-        `Workflow id: \`${workflow.id}\``,
-        `Method: ${workflow.hint}`,
-        "",
-        "Compile stages:",
-        ...stageLines,
-        "",
-        "Interf CLI remains the referee for contracts, proofs, validators, and runtime state under `.interf/`.",
-        "",
-    ].join("\n");
-}
-function defaultWorkflowCreateSkill(targetType, workflow) {
-    return [
-        "# Create",
-        "",
-        `This doc explains what Interf scaffolded for the selected ${targetType} workflow.`,
-        "",
-        `- selected workflow: \`${workflow.id}\``,
-        `- method: ${workflow.hint}`,
-        "- the CLI owns create-time validation, folder creation, config writing, and bootstrap docs",
-        "- edit this workflow package after scaffold if you want to refine how later compile/query behavior works",
-        "",
-    ].join("\n");
-}
-function defaultKnowledgeBaseStageSkill(workflow, stage) {
-    const notes = workflow.stagePolicyNotes?.[stage.id] ?? [];
-    return [
-        renderJsonFrontmatter({ mode: "extend" }),
-        `# ${stage.label}`,
-        "",
-        `This workflow stage customizes the built-in ${stage.contractType} contract for the \`${workflow.id}\` knowledge-base workflow.`,
-        "",
-        `- purpose: ${stage.description}`,
-        ...notes.map((note) => `- ${note}`),
-        "",
-        "Interf still enforces the same contract reads, writes, proof rules, validators, and state transitions for this stage.",
-        "",
-    ].join("\n");
-}
-function defaultInterfaceStageSkill(workflow, stage) {
-    const notes = workflow.stagePolicyNotes?.[stage.id] ?? [];
-    return [
-        renderJsonFrontmatter({ mode: "extend" }),
-        `# ${stage.label}`,
-        "",
-        `This workflow stage customizes the built-in ${stage.contractType} contract for the \`${workflow.id}\` interface workflow.`,
-        "",
-        `- purpose: ${stage.description}`,
-        ...notes.map((note) => `- ${note}`),
-        "",
-        "Interf still enforces the same contract reads, writes, coverage proof rules, validators, and state transitions for this stage.",
-        "",
-    ].join("\n");
-}
-function defaultKnowledgeBaseQuerySkill() {
-    return [
-        "# Knowledge Base Query",
-        "",
-        "## First question: required preflight",
-        "",
-        "Before browsing notes on your own or answering from compiled knowledge:",
-        "",
-        "- inspect `.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "",
-        "Use this skill when answering questions from inside this knowledge base in a manual agent session.",
-        "AGENTS.md should route manual questions here before an agent starts browsing notes on its own.",
-        "This is the canonical parent-knowledge-base query loop that attached interfaces can inherit before raw fallback.",
-        "This is a workspace-local query doc, not a required globally installed slash-command skill.",
-        "",
-        "Default loop:",
-        "- start with `AGENTS.md`, then `home.md`",
-        "- browse `knowledge/` indexes, entities, and claims first",
-        "- follow wikilinks and backlinks outward before treating one note as complete",
-        "- use `summaries/` for deeper evidence",
-        "- use raw source files only when needed for verification, direct quotes, ambiguity, or missing context",
-        "",
-        "Raw-source gate:",
-        "- inspect `.interf/source-access.json` before depending on raw files",
-        "- verify one `suggested_checks` path is actually readable from this session",
-        "- if raw files are not reachable, say the answer is based on compiled knowledge and summaries only",
-        "",
-        "First-reply rule:",
-        "- on the first substantive manual question, inspect `.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, still prefer compiled knowledge unless the user asks for direct quotes or raw verification",
-        "",
-        "You can edit this file to bias manual question-answering behavior without changing compile-stage logic.",
-        "",
-    ].join("\n");
-}
-function defaultInterfaceQuerySkill() {
-    return [
-        "# Interface Query",
-        "",
-        "## First question: required preflight",
-        "",
-        "Before browsing notes on your own or answering from compiled interface outputs:",
-        "",
-        "- verify parent KB reachability first, then inspect `../../.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "",
-        "Use this skill when answering questions from inside this interface in a manual agent session.",
-        "AGENTS.md should route manual questions here before an agent starts browsing notes on its own.",
-        "Treat this as the interface-local query layer, not a replacement for the parent knowledge-base query loop.",
-        "This is a workspace-local query doc, not a required globally installed slash-command skill.",
-        "",
-        "Default loop:",
-        "- start with `AGENTS.md`, then `home.md`",
-        "- browse local `knowledge/`, `briefs/`, and local `summaries/` first",
-        "- follow wikilinks and backlinks outward before treating one note as complete",
-        "- if local interface artifacts are insufficient, load and follow the parent knowledge-base query guidance at `../../workflow/use/query/SKILL.md` before going raw",
-        "- use parent knowledge-base artifacts in this order: `../../home.md`, then `../../knowledge/`, then `../../summaries/`",
-        "- use raw source files only when needed for verification, direct quotes, ambiguity, or missing context",
-        "",
-        "Raw-source gate:",
-        "- inspect `../../.interf/source-access.json` before depending on raw files",
-        "- verify one `suggested_checks` path is actually readable from this session",
-        "- if raw files are not reachable, say the answer is based on interface and knowledge-base artifacts only",
-        "",
-        "First-reply rule:",
-        "- on the first substantive manual question, verify parent KB reachability first, then inspect `../../.interf/source-access.json` immediately and try one `suggested_checks` path",
-        "- if the environment asks for permission, request it immediately instead of answering as though raw were missing",
-        "- the first line of the answer must be exactly `Raw access: confirmed` or `Raw access: unavailable`",
-        "- use `Raw access: confirmed` only after a suggested raw path is readable from this session",
-        "- use `Raw access: unavailable` only after a raw check fails or permission is denied",
-        "- after the preflight, use local interface artifacts first, then the parent KB loop, and raw files mainly for quotes or verification",
-        "",
-        "Keep the interface-specific behavior here. Keep the parent knowledge-base-wide retrieval and raw-fallback policy in `../../workflow/use/query/SKILL.md`.",
-        "",
-        "You can edit this file to bias manual question-answering behavior without changing workflow stage logic.",
-        "",
-    ].join("\n");
-}
-function writeKnowledgeBaseWorkflowPackage(knowledgeBasePath, workflow, interfaceTemplates) {
-    const workflowDir = workflowPackagePath(knowledgeBasePath);
-    mkdirSync(join(workflowDir, "create"), { recursive: true });
-    mkdirSync(join(workflowDir, "use", "query"), { recursive: true });
-    mkdirSync(join(workflowDir, "compile", "stages"), { recursive: true });
-    for (const stage of workflow.stages) {
-        mkdirSync(join(workflowDir, "compile", "stages", stage.skillDir), { recursive: true });
-    }
-    writeWorkflowPackageJson(workflowDir, "knowledge-base", workflow);
-    writeFileSync(join(workflowDir, "README.md"), defaultWorkflowReadme("knowledge-base", workflow));
-    writeFileSync(join(workflowDir, "create", "SKILL.md"), defaultWorkflowCreateSkill("knowledge-base", workflow));
-    writeFileSync(join(workflowDir, "use", "query", "SKILL.md"), defaultKnowledgeBaseQuerySkill());
-    for (const stage of workflow.stages) {
-        writeFileSync(join(workflowDir, "compile", "stages", stage.skillDir, "SKILL.md"), defaultKnowledgeBaseStageSkill(workflow, stage));
-    }
-    writeWorkflowStarterDocs(workflowDir, workflow.starterDocs);
-    const interfacesDir = workflowInterfacesPath(knowledgeBasePath);
-    mkdirSync(interfacesDir, { recursive: true });
-    for (const template of interfaceTemplates) {
-        writeInterfaceWorkflowTemplate(join(interfacesDir, template.id), template);
-    }
-}
-function writeInterfaceWorkflowTemplate(targetDir, workflow) {
-    mkdirSync(join(targetDir, "create"), { recursive: true });
-    mkdirSync(join(targetDir, "use", "query"), { recursive: true });
-    mkdirSync(join(targetDir, "compile", "stages"), { recursive: true });
-    for (const stage of workflow.stages) {
-        mkdirSync(join(targetDir, "compile", "stages", stage.skillDir), { recursive: true });
-    }
-    writeWorkflowPackageJson(targetDir, "interface", workflow);
-    writeFileSync(join(targetDir, "README.md"), defaultWorkflowReadme("interface", workflow));
-    writeFileSync(join(targetDir, "create", "SKILL.md"), defaultWorkflowCreateSkill("interface", workflow));
-    writeFileSync(join(targetDir, "use", "query", "SKILL.md"), defaultInterfaceQuerySkill());
-    for (const stage of workflow.stages) {
-        writeFileSync(join(targetDir, "compile", "stages", stage.skillDir, "SKILL.md"), defaultInterfaceStageSkill(workflow, stage));
-    }
-    writeWorkflowStarterDocs(targetDir, workflow.starterDocs);
-}
-function writeInterfaceWorkflowPackage(interfacePath, workflow) {
-    writeInterfaceWorkflowTemplate(workflowPackagePath(interfacePath), workflow);
-}
-export function syncClaudeBootstrap(dirPath) {
-    const agentsPath = join(dirPath, "AGENTS.md");
-    if (!existsSync(agentsPath))
-        return;
-    writeFileSync(join(dirPath, "CLAUDE.md"), renderClaudeBootstrap(readFileSync(agentsPath, "utf8")));
-}
-export function refreshWorkspaceBootstrapGuidance(dirPath) {
-    const config = readInterfConfig(dirPath);
-    if (!config)
-        return false;
-    let changed = false;
-    const agentsPath = join(dirPath, "AGENTS.md");
-    if (existsSync(agentsPath)) {
-        const current = readFileSync(agentsPath, "utf8");
-        const refreshed = refreshLegacyAgentsBootstrap(current);
-        if (refreshed !== current) {
-            writeFileSync(agentsPath, refreshed);
-            changed = true;
-        }
-    }
-    const querySkillPath = join(dirPath, "workflow", "use", "query", "SKILL.md");
-    if (existsSync(querySkillPath)) {
-        const current = readFileSync(querySkillPath, "utf8");
-        const refreshed = config.type === "interface"
-            ? refreshLegacyInterfaceQuerySkill(current)
-            : refreshLegacyKnowledgeBaseQuerySkill(current);
-        if (refreshed !== current) {
-            writeFileSync(querySkillPath, refreshed);
-            changed = true;
-        }
-    }
-    if (changed || existsSync(agentsPath)) {
-        syncClaudeBootstrap(dirPath);
-    }
-    return changed;
-}
-export function createKnowledgeBase(name, sourcePath, workflowId = "interf") {
-    return createKnowledgeBaseWithWorkflow(name, sourcePath, workflowId);
-}
-export function createKnowledgeBaseWithWorkflow(name, sourcePath, workflowId = "interf") {
-    assertWorkspaceName(name, "Knowledge base");
-    const containerPath = assertKnowledgeBaseContainer(sourcePath);
-    mkdirSync(containerPath, { recursive: true });
-    const knowledgeBasePath = join(containerPath, name);
-    assertWritableTargetDir(knowledgeBasePath, "Knowledge base");
-    mkdirSync(knowledgeBasePath, { recursive: true });
-    const selectedWorkflow = getKnowledgeBaseWorkflow(workflowId, { sourcePath });
-    const interfaceTemplates = selectedWorkflow.interfaceTemplates ?? listInterfaceWorkflowChoices(sourcePath);
-    const knowledgeBaseStageFolders = formatWorkflowStageFolders(selectedWorkflow.stages);
-    const knowledgeBaseStageSequence = formatWorkflowStageSequence(selectedWorkflow.stages);
-    writeInterfConfigFile(knowledgeBasePath, {
-        type: "knowledge-base",
-        name,
-        workflow: selectedWorkflow.id,
-        source: {
-            path: "../..",
-        },
-    });
-    // .interfignore
-    if (existsSync(KNOWLEDGE_BASE_INTERFIGNORE)) {
-        copyFileSync(KNOWLEDGE_BASE_INTERFIGNORE, join(knowledgeBasePath, ".interfignore"));
-    }
-    writeKnowledgeBaseWorkflowPackage(knowledgeBasePath, selectedWorkflow, interfaceTemplates);
-    // Agent bootstrap docs
-    writeAgentBootstrapFiles(knowledgeBasePath, [
-        `# ${name}`,
-        ``,
-        ...topKnowledgeBaseManualPreflightBlock(),
-        `This is the main Interf knowledge base — the primary local knowledge layer over the source files in the attached folder above this named folder.`,
-        ``,
-        `## How this knowledge base works`,
-        ``,
-        `- \`interf.json\` — config. Points to the source folder via \`source.path\`.`,
-        `- Workflow: \`${selectedWorkflow.id}\` (${selectedWorkflow.label}). This is the methodology you chose for this knowledge base.`,
-        `- Interf generates a stage contract from that workflow each time you run \`interf compile\`.`,
-        `- \`workflow/\` — the local editable method package for this knowledge base.`,
-        `- \`workflow/workflow.json\` — stage graph and contract kinds for the selected workflow.`,
-        `- \`workflow/create/\` — create-time setup notes for this workflow.`,
-        `- \`workflow/compile/stages/\` — one stage folder per compile stage: ${knowledgeBaseStageFolders}.`,
-        `- \`workflow/use/query/\` — manual-use guidance when an agent is answering questions from this knowledge base.`,
-        `- \`workflow/interfaces/\` — interface workflow templates available on top of this knowledge base.`,
-        `- \`summaries/\` — per-file evidence objects. One per source file.`,
-        `- \`knowledge/\` — the durable cross-file knowledge layer built by compile.`,
-        `- \`home.md\` — start here. Overview of what's been built.`,
-        ...buildWorkspaceRuntimeControlLines("knowledge-base"),
-        `- \`interfaces/\` — focused workspaces for specific jobs or perspectives built on top of this knowledge base.`,
-        `- \`.interf/source-access.json\` — quick raw-file access check for manual agents.`,
-        `- Source files live in the grandparent folder (\`../../\`). They are never modified by interf.`,
-        `- Default agent entrypoint is this knowledge-base workspace.`,
-        `- Automated compile workers run from this workspace and read local \`AGENTS.md\`, \`.interf/stage-contract.json\`, and workflow docs here.`,
-        `- If your coding agent is sandboxed to the current directory tree and raw source access is blocked, relaunch from the source folder or grant the source folder alongside this workspace.`,
-        `- Before relying on raw files directly, inspect \`.interf/source-access.json\` and verify one path from \`suggested_checks\` is readable. These are canonical absolute source-file paths so they still work from nested interfaces. If raw paths are not reachable, fall back to \`summaries/\` and say raw fallback is unavailable.`,
-        ``,
-        `## Manual access checklist`,
-        ``,
-        `Use this checklist on the first substantive manual question so you do not get stuck later in the session:`,
-        ``,
-        `1. Read this \`AGENTS.md\` and then \`workflow/use/query/SKILL.md\`.`,
-        `2. Confirm the compiled knowledge-base surface is reachable: \`home.md\`, \`knowledge/\`, and \`summaries/\`.`,
-        `3. Run the raw-source preflight via \`.interf/source-access.json\` immediately. If the environment asks for permission, request it right away.`,
-        `4. After that preflight, start the answer with exactly \`Raw access: confirmed\` or \`Raw access: unavailable\`.`,
-        ``,
-        `## Preferred operation`,
-        ``,
-        `Use the Interf CLI for normal operations:`,
-        ``,
-        `\`\`\``,
-        `interf compile           compile this knowledge base`,
-        `interf verify summarize  verify summary coverage and quality`,
-        `interf verify compile  verify graph/inventory consistency`,
-        `interf create interface  create an interface`,
-        `interf status            show compile health`,
-        `\`\`\``,
-        ``,
-        `## For agents without the CLI`,
-        ``,
-        `Start with \`workflow/use/query/SKILL.md\`, then \`home.md\`. Browse \`knowledge/\` for entities and claims. Use \`summaries/\` for deeper evidence. Access source files at \`../../\` only when the raw-source gate says they are actually reachable.`,
-        ...buildWorkspaceAgentLayerLines(knowledgeBaseStageFolders, "knowledge base"),
-        `Navigation ladder: \`AGENTS.md\` -> local \`workflow/use/query/SKILL.md\` -> \`home.md\` -> local \`knowledge/\` indexes and notes -> linked \`summaries/\` evidence -> raw source files only when needed and actually reachable.`,
-        `Backlinks and outward wikilinks are part of the interface. If a note links to a summary or another knowledge note, follow that link before guessing from one file in isolation.`,
-        `If a question seems answerable from the current note but confidence is low, expand outward through linked summaries and related notes first. Use raw files mainly for verification, direct quotes, ambiguity, or missing context.`,
-        `Raw-source gate: before giving an answer that depends on original source files, inspect \`.interf/source-access.json\` and verify one path from \`suggested_checks\` is actually readable from this session.`,
-        `If that raw-file check fails or the agent asks for permission and the user has not granted it, do not claim raw-file verification. Say explicitly that raw source access is unavailable in this session and limit the answer to compiled summaries and knowledge artifacts.`,
-        `When answering knowledge-base-wide questions, do not rely on a few hand-picked files. First verify summarize/compile integrity via \`.interf/inventory.json\`, \`.interf/health.json\`, or \`interf verify summarize --json\` and \`interf verify compile --json\`, then drill into the relevant summaries.`,
-        `Treat summary titles as source-grounded descriptions, not absolute truth. Broader semantic claims should come from \`knowledge/\`, not from over-reading a single summary filename.`,
-        ``,
-        `## Obsidian (optional)`,
-        ``,
-        `If Obsidian viewer defaults are enabled, this knowledge base gets minimal graph defaults and Interf attempts to register this named folder with Obsidian.`,
-        `If the running app does not pick it up immediately, reopen Obsidian or add the folder once via Manage vaults.`,
-        ``,
-        `## Rules`,
-        ``,
-        `- Do not modify source files in the grandparent folder.`,
-        `- Follow prose-as-title: summary filenames are claims, not slugs.`,
-        `- Follow wiki-link-as-prose: links read as sentences.`,
-        ``,
-    ].join("\n"));
-    // home.md
-    writeFileSync(join(knowledgeBasePath, "home.md"), `# ${name} — Home\n\nNot yet compiled. Run \`interf compile\` to execute the workflow-defined compile stages for this knowledge base (${knowledgeBaseStageSequence}).\n`);
-    // .gitignore
-    writeFileSync(join(knowledgeBasePath, ".gitignore"), "summaries/\nknowledge/\n.interf/\n.obsidian/\n");
-    // Init state
-    saveState(knowledgeBasePath, initKnowledgeBaseState());
-    refreshKnowledgeBaseArtifacts(knowledgeBasePath, { ensureViewSpec: true });
-    writeObsidianDefaults(knowledgeBasePath, "knowledge-base");
-    return knowledgeBasePath;
-}
-export function createInterface(name, knowledgeBasePath, knowledgeBaseName, workflowId = "briefing") {
-    return createInterfaceWithWorkflow(name, knowledgeBasePath, knowledgeBaseName, workflowId);
-}
-export function createInterfaceWithWorkflow(name, knowledgeBasePath, knowledgeBaseName, workflowId = "briefing") {
-    assertWorkspaceName(name, "Interface");
-    const interfacesDir = join(knowledgeBasePath, "interfaces");
-    mkdirSync(interfacesDir, { recursive: true });
-    const dirPath = resolve(interfacesDir, name);
-    assertWritableTargetDir(dirPath, `Interface "${name}"`);
-    mkdirSync(dirPath, { recursive: true });
-    const knowledgeBaseRelativePath = relative(dirPath, knowledgeBasePath) || ".";
-    const selectedWorkflow = listKnowledgeBaseInterfaceWorkflowChoices(knowledgeBasePath).find((candidate) => candidate.id === workflowId) ?? getInterfaceWorkflow(workflowId, { sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath) });
-    const interfaceStageFolders = formatWorkflowStageFolders(selectedWorkflow.stages);
-    const interfaceStageSequence = formatWorkflowStageSequence(selectedWorkflow.stages);
-    writeInterfConfigFile(dirPath, {
-        type: "interface",
-        name,
-        workflow: selectedWorkflow.id,
-        knowledge_base: {
-            path: knowledgeBaseRelativePath,
-        },
-    });
-    // .gitignore
-    writeFileSync(join(dirPath, ".gitignore"), "knowledge/\nbriefs/\nsummaries/\n.interf/\n.obsidian/\n");
-    writeInterfaceWorkflowPackage(dirPath, selectedWorkflow);
-    // Agent bootstrap docs
-    writeAgentBootstrapFiles(dirPath, [
-        `# ${name}`,
-        ``,
-        ...topInterfaceManualPreflightBlock(),
-        `This is an Interf interface — a focused workspace built on top of the \`${knowledgeBaseName}\` knowledge base for one job, perspective, or workflow.`,
-        ``,
-        `## How this interface works`,
-        ``,
-        `- \`interf.json\` — config. Points to the main knowledge base via \`knowledge_base.path\`.`,
-        `- Workflow: \`${selectedWorkflow.id}\` (${selectedWorkflow.label}). This is the methodology you chose for this interface.`,
-        `- Interf generates a stage contract from that workflow each time you run \`interf compile\`.`,
-        `- \`workflow/\` — the local editable method package for this interface.`,
-        `- \`workflow/workflow.json\` — stage graph and contract kinds for the selected interface workflow.`,
-        `- \`workflow/create/\` — create-time setup notes for this interface workflow.`,
-        `- \`workflow/compile/stages/\` — one stage folder per compile stage: ${interfaceStageFolders}.`,
-        `- \`workflow/use/query/\` — interface-local manual-use guidance.`,
-        `- \`../../workflow/use/query/\` — parent knowledge-base manual-use guidance. Use it when local interface artifacts are insufficient before any raw-source fallback.`,
-        `- \`compile-plan.md\` — interface execution plan for the workflow-defined compile stages (${interfaceStageSequence}). It is the initial runtime hypothesis, not the final word.`,
-        `- \`knowledge/\` — this interface's local entities, claims, and indexes.`,
-        `- \`briefs/\` — hero documents for this use case.`,
-        `- \`summaries/\` — interface-local summaries or periodic summaries when this interface needs them. These are not the main knowledge-base summaries.`,
-        ...buildWorkspaceRuntimeControlLines("interface"),
-        `- \`home.md\` — start here.`,
-        `- Knowledge-base raw-file quick check is at \`../../.interf/source-access.json\`.`,
-        `- Main knowledge base is at \`../../\`. Knowledge-base summaries are at \`../../summaries/\`.`,
-        `- Agent access hierarchy for this interface is: local interface artifacts -> parent knowledge-base artifacts -> raw source files only when needed.`,
-        `- Default agent entrypoint is this interface workspace.`,
-        `- Automated compile workers run from this workspace and start with local \`AGENTS.md\`, then parent knowledge-base entrypoints and workflow docs.`,
-        `- If your coding agent is sandboxed to the current directory tree and raw source access is blocked, relaunch from the source folder or grant access to both the source root and this interface.`,
-        `- Before raw-file fallback, verify that the parent knowledge base is reachable by opening \`../../AGENTS.md\`, \`../../home.md\`, or a summary under \`../../summaries/\`.`,
-        `- Before relying on raw files directly, inspect \`../../.interf/source-access.json\` and verify one path from \`suggested_checks\` is readable. These are canonical absolute source-file paths shared by the parent knowledge base. If raw paths are not reachable, continue from knowledge-base summaries and say raw fallback is unavailable.`,
-        `- In Obsidian, browse this interface from the parent knowledge-base vault so links to knowledge-base summaries and source files remain navigable.`,
-        ``,
-        `## Manual access checklist`,
-        ``,
-        `Use this checklist on the first substantive manual question so you do not get stuck later in the session:`,
-        ``,
-        `1. Read this \`AGENTS.md\` and then local \`workflow/use/query/SKILL.md\`.`,
-        `2. Confirm the local interface surface is reachable: \`home.md\`, \`knowledge/\`, \`briefs/\`, and any local \`summaries/\`.`,
-        `3. Confirm the parent knowledge base is reachable: \`../../AGENTS.md\`, \`../../home.md\`, and parent summaries.`,
-        `4. Run the raw-source preflight through \`../../.interf/source-access.json\` immediately. If the environment asks for permission, request it right away.`,
-        `5. After that preflight, start the answer with exactly \`Raw access: confirmed\` or \`Raw access: unavailable\`.`,
-        ``,
-        `## Preferred operation`,
-        ``,
-        `Use the Interf CLI:`,
-        ``,
-        `\`\`\``,
-        `interf verify interface-plan  verify the scaffold and compile plan`,
-        `interf compile           compile this interface`,
-        `interf verify retrieve   verify retrieval proof before analyze/compile`,
-        `interf status            show compile health`,
-        `\`\`\``,
-        ``,
-        `## For agents without the CLI`,
-        ``,
-        `Read \`compile-plan.md\` for the execution plan. Start with \`workflow/use/query/SKILL.md\`, then \`home.md\`. Browse \`knowledge/\` for local entities, claims, and indexes. Use \`briefs/\` and local \`summaries/\` as high-level entry points. If that is insufficient, load \`../../workflow/use/query/SKILL.md\` and use the parent knowledge-base query loop before any raw fallback.`,
-        ...buildWorkspaceAgentLayerLines(interfaceStageFolders, "interface"),
-        `Navigation ladder: \`AGENTS.md\` -> local \`workflow/use/query/SKILL.md\` -> \`home.md\` -> local \`knowledge/\`, \`briefs/\`, and local \`summaries/\` -> parent \`../../workflow/use/query/SKILL.md\` -> parent \`../../home.md\`, \`../../knowledge/\`, and \`../../summaries/\` -> raw source files only when needed and actually reachable.`,
-        `Knowledge-base gate: before raw fallback, verify that \`../../AGENTS.md\`, \`../../home.md\`, or a parent summary in \`../../summaries/\` is reachable from this session.`,
-        `Backlinks and outward wikilinks are part of the interface. Follow linked claims, entities, briefs, and parent summaries before treating the current note as a complete answer.`,
-        `If a question seems answerable from the current note but confidence is low, expand outward through the parent knowledge-base query loop first. Use raw files mainly for verification, direct quotes, ambiguity, or missing context.`,
-        `Raw-source gate: before giving an answer that depends on original source files, inspect \`../../.interf/source-access.json\` and verify one path from \`suggested_checks\` is actually readable from this session.`,
-        `If that raw-file check fails or the agent asks for permission and the user has not granted it, do not claim raw-file verification. Say explicitly that raw source access is unavailable in this session and limit the answer to compiled knowledge-base and interface artifacts.`,
-        `If you are using Obsidian, open the parent knowledge-base vault rather than this interface folder alone. Standalone interface vaults cannot resolve links into the parent knowledge base.`,
-        `Do not synthesize from the main knowledge base until the interface plan and retrieve coverage are both proved. Check \`compile-plan.md\`, \`.interf/coverage.json\`, \`.interf/relevant.json\`, and \`.interf/health.json\` first.`,
-        `If a stage is active, \`.interf/stage-contract.json\` and \`.interf/run.json\` are the durable source of truth for what the harness expects and which executor is running.`,
-        `Run \`interf verify interface-plan --json\` after creation and \`interf verify retrieve --json\` before analyze/compile if you need deterministic pass/fail checks.`,
-        `For interface questions, the expected loop is: scan summary frontmatter -> review candidate abstracts -> expand through links if needed -> refine the runtime from evidence -> answer with evidence.`,
-        ``,
-        `## Rules`,
-        ``,
-        `- All outputs are local to this interface.`,
-        `- Do not modify the main knowledge base or source files.`,
-        `- Prefer evidence-linked notes over summaries without sources.`,
-        ``,
-    ].join("\n"));
-    // home.md
-    writeFileSync(join(dirPath, "home.md"), `# ${name} — Home\n\nNot yet compiled. Run \`interf compile\` to start interface compilation.\n\nThis interface reads from the parent knowledge base at \`../../\`. In Obsidian, open the parent knowledge-base vault so links to knowledge-base summaries and source files resolve correctly.\n`);
-    writeInterfaceCompilePlanTemplate(dirPath, {
-        workflowId: selectedWorkflow.id,
-        sourcePath: resolveKnowledgeBaseSourcePath(knowledgeBasePath),
-        interfaceName: name,
-    });
-    // Init state
-    saveState(dirPath, initInterfaceState());
-    refreshInterfaceArtifacts(dirPath, { ensureViewSpec: true });
-    writeObsidianDefaults(dirPath, "interface", { registerVault: false });
-    return dirPath;
-}
-function writeObsidianDefaults(dirPath, type, options = {}) {
-    const viewer = loadUserConfig()?.viewer ?? "plain";
-    if (viewer !== "obsidian")
-        return;
-    const obsidianDir = join(dirPath, ".obsidian");
-    mkdirSync(obsidianDir, { recursive: true });
-    const graphSettings = type === "knowledge-base" ? BASE_GRAPH_SETTINGS : INTERFACE_GRAPH_SETTINGS;
-    writeFileSync(join(obsidianDir, "graph.json"), JSON.stringify(graphSettings, null, 2) + "\n");
-    if (process.env.INTERF_DISABLE_VIEWER_OPEN === "1")
-        return;
-    if (options.registerVault === false) {
-        removeObsidianVaultRegistration(resolve(dirPath));
-        return;
-    }
-    ensureObsidianVaultRegistered(resolve(dirPath));
-}
-function ensureObsidianVaultRegistered(dirPath) {
-    const registryPath = getObsidianRegistryPath();
-    if (!registryPath)
-        return false;
-    try {
-        mkdirSync(resolve(registryPath, ".."), { recursive: true });
-        const current = existsSync(registryPath)
-            ? JSON.parse(readFileSync(registryPath, "utf8"))
-            : {};
-        const vaults = current && typeof current === "object" && current.vaults && typeof current.vaults === "object"
-            ? current.vaults
-            : {};
-        for (const [key, value] of Object.entries(vaults)) {
-            if (typeof value?.path === "string" && resolve(value.path) === dirPath && key !== getObsidianVaultId(dirPath)) {
-                delete vaults[key];
-            }
-        }
-        const vaultId = getObsidianVaultId(dirPath);
-        const existing = vaults[vaultId];
-        vaults[vaultId] = {
-            ...(existing ?? {}),
-            path: dirPath,
-            ts: Date.now(),
-        };
-        const next = {
-            ...(current && typeof current === "object" ? current : {}),
-            vaults,
-        };
-        writeFileSync(registryPath, JSON.stringify(next) + "\n");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function removeObsidianVaultRegistration(dirPath) {
-    const registryPath = getObsidianRegistryPath();
-    if (!registryPath || !existsSync(registryPath))
-        return false;
-    try {
-        const current = JSON.parse(readFileSync(registryPath, "utf8"));
-        const vaults = current && typeof current === "object" && current.vaults && typeof current.vaults === "object"
-            ? { ...current.vaults }
-            : null;
-        if (!vaults)
-            return false;
-        let changed = false;
-        for (const [key, value] of Object.entries(vaults)) {
-            if (typeof value?.path === "string" && resolve(value.path) === dirPath) {
-                delete vaults[key];
-                changed = true;
-            }
-        }
-        if (!changed)
-            return false;
-        const next = {
-            ...(current && typeof current === "object" ? current : {}),
-            vaults,
-        };
-        writeFileSync(registryPath, JSON.stringify(next) + "\n");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function getObsidianRegistryPath() {
-    if (process.env.INTERF_OBSIDIAN_CONFIG_DIR) {
-        return join(process.env.INTERF_OBSIDIAN_CONFIG_DIR, "obsidian.json");
-    }
-    if (process.platform === "darwin") {
-        return join(homedir(), "Library", "Application Support", "obsidian", "obsidian.json");
-    }
-    if (process.platform === "win32") {
-        const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
-        return join(appData, "obsidian", "obsidian.json");
-    }
-    const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-    return join(xdgConfig, "obsidian", "obsidian.json");
-}
-function getObsidianVaultId(dirPath) {
-    return createHash("md5").update(dirPath).digest("hex").slice(0, 16);
-}
+// Barrel — re-exports from the three focused sub-modules.
+// Every symbol previously exported from this file is still importable here.
+export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, BENCHMARK_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveKnowledgeBase, resolveInterfaceKnowledgeBasePath, resolveKnowledgeBaseSourcePath, listKnowledgeBasesForSourceFolder, assertKnowledgeBaseContainer, assertWritableTargetDir, assertWorkspaceName, } from "./interf-detect.js";
+export { syncClaudeBootstrap, refreshWorkspaceBootstrapGuidance, refreshLegacyAgentsBootstrap, refreshLegacyKnowledgeBaseQuerySkill, refreshLegacyInterfaceQuerySkill, insertLineAfterFirstMatch, insertBlockBeforeFirstMatch, renderClaudeBootstrap, topKnowledgeBaseManualPreflightBlock, topInterfaceManualPreflightBlock, buildWorkspaceRuntimeControlLines, buildWorkspaceAgentLayerLines, } from "./interf-bootstrap.js";
+export { buildInterfaceStagePolicySection, formatWorkflowStageFolders, formatWorkflowStageSequence, writeInterfaceCompilePlanTemplate, createKnowledgeBase, createKnowledgeBaseWithWorkflow, createInterface, createInterfaceWithWorkflow, } from "./interf-scaffold.js";
 //# sourceMappingURL=interf.js.map