@interf/compiler 0.5.1 → 0.6.1

package/dist/lib/builtin-compiled-workflow.js

@@ -1,23 +1,9 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { PACKAGE_ROOT } from "./config.js";
+import { readJsonFileWithSchema } from "./parse.js";
+import { WorkflowCompiledSchemaSchema } from "./schema.js";
 import { COMPILED_ZONE_KINDS } from "./workflow-primitives.js";
-export const COMPILED_CONTRACT_TYPES = [
-    "compiled-file-evidence",
-    "compiled-knowledge-structure",
-    "compiled-query-shape",
-];
-export const COMPILED_CONTRACT_FAMILY_METADATA = {
-    "compiled-file-evidence": {
-        order: 0,
-        bundledSkill: "compile/stages/summarize",
-    },
-    "compiled-knowledge-structure": {
-        order: 1,
-        bundledSkill: "compile/stages/structure",
-    },
-    "compiled-query-shape": {
-        order: 2,
-        bundledSkill: "compile/stages/shape",
-    },
-};
 export const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",
     STRUCTURE: "structure",
@@ -32,115 +18,70 @@ export const BUILTIN_COMPILED_ZONE_IDS = {
     HOME: "home",
     RUNTIME: "runtime",
 };
-export const BUILTIN_COMPILED_ZONE_SPECS = [
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.RAW,
-        path: "raw",
-        kind: "directory",
-        required: true,
-        description: "Compiled-local raw snapshot copied from the dataset for direct evidence and verification.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
-        path: "summaries",
-        kind: "directory",
-        required: true,
-        description: "Per-file evidence notes produced by file-evidence stages.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
-        path: "knowledge/entities",
-        kind: "directory",
-        required: true,
-        description: "Canonical entity notes produced by knowledge-structure stages.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
-        path: "knowledge/claims",
-        kind: "directory",
-        required: true,
-        description: "Claim notes produced by knowledge-structure stages.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
-        path: "knowledge/indexes",
-        kind: "directory",
-        required: true,
-        description: "Retrieval indexes and navigation notes produced by structure and shape stages.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.HOME,
-        path: "home.md",
-        kind: "file",
-        required: true,
-        description: "Primary entrypoint note for agents using the compiled dataset.",
-    },
-    {
-        id: BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
-        path: ".interf/runtime",
-        kind: "runtime",
-        required: true,
-        description: "CLI-owned runtime state, health, stage contracts, and proof artifacts.",
-    },
-];
-export const BUILTIN_COMPILED_STAGE_ACCESS_PATTERNS = [
-    {
-        id: BUILTIN_COMPILED_STAGE_IDS.SUMMARIZE,
-        label: "Summarize",
-        description: "Turn source files into per-file summaries.",
-        contractType: "compiled-file-evidence",
-        skillDir: "summarize",
-        reads: [
-            BUILTIN_COMPILED_ZONE_IDS.RAW,
-            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
-        ],
-    },
-    {
-        id: BUILTIN_COMPILED_STAGE_IDS.STRUCTURE,
-        label: "Structure",
-        description: "Build the cross-file knowledge structure from the summaries.",
-        contractType: "compiled-knowledge-structure",
-        skillDir: "structure",
-        reads: [
-            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
-            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
-        ],
-    },
-    {
-        id: BUILTIN_COMPILED_STAGE_IDS.SHAPE,
-        label: "Shape",
-        description: "Shape the final compiled around the saved focus and truth checks.",
-        contractType: "compiled-query-shape",
-        skillDir: "shape",
-        reads: [
-            BUILTIN_COMPILED_ZONE_IDS.RAW,
-            BUILTIN_COMPILED_ZONE_IDS.SUMMARIES,
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES,
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS,
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_COMPILED_ZONE_IDS.RUNTIME,
-        ],
-        writes: [
-            BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES,
-            BUILTIN_COMPILED_ZONE_IDS.HOME,
-        ],
-    },
-];
+const BUILTIN_ZONE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ZONE_IDS));
+const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
+const BuiltinWorkflowStageSchema = z.object({
+    id: z.string(),
+    contract_type: z.string(),
+    reads: z.array(z.string()).min(1),
+    writes: z.array(z.string()).min(1),
+});
+const BuiltinWorkflowPackageSchema = z.object({
+    stages: z.array(BuiltinWorkflowStageSchema).min(1),
+});
+let builtinCompiledContractCache = null;
+function builtinWorkflowRootPath() {
+    return join(PACKAGE_ROOT, "builtin-workflows", "interf");
+}
+function builtinWorkflowPath(relativePath) {
+    return join(builtinWorkflowRootPath(), relativePath);
+}
+function assertBuiltinZoneId(value) {
+    if (!BUILTIN_ZONE_ID_SET.has(value)) {
+        throw new Error(`Built-in Interf workflow schema declares unsupported zone id "${value}".`);
+    }
+    return value;
+}
+function assertBuiltinStageId(value) {
+    if (!BUILTIN_STAGE_ID_SET.has(value)) {
+        throw new Error(`Built-in Interf workflow package declares unsupported stage id "${value}".`);
+    }
+    return value;
+}
+function loadBuiltinCompiledContract() {
+    if (builtinCompiledContractCache)
+        return builtinCompiledContractCache;
+    const schema = readJsonFileWithSchema(builtinWorkflowPath("workflow.schema.json"), "built-in Interf workflow schema", WorkflowCompiledSchemaSchema);
+    if (!schema) {
+        throw new Error(`Missing or invalid built-in workflow schema at ${builtinWorkflowPath("workflow.schema.json")}.`);
+    }
+    const workflow = readJsonFileWithSchema(builtinWorkflowPath("workflow.json"), "built-in Interf workflow package", BuiltinWorkflowPackageSchema);
+    if (!workflow) {
+        throw new Error(`Missing or invalid built-in workflow package at ${builtinWorkflowPath("workflow.json")}.`);
+    }
+    const zones = schema.zones.map((zone) => ({
+        id: assertBuiltinZoneId(zone.id),
+        role: zone.role,
+        path: zone.path,
+        kind: zone.kind,
+        required: zone.required,
+        description: zone.description,
+    }));
+    const stages = workflow.stages.map((stage) => ({
+        id: assertBuiltinStageId(stage.id),
+        contract_type: stage.contract_type,
+        reads: stage.reads.map(assertBuiltinZoneId),
+        writes: stage.writes.map(assertBuiltinZoneId),
+    }));
+    builtinCompiledContractCache = { zones, stages };
+    return builtinCompiledContractCache;
+}
 export function listBuiltinCompiledZoneSpecs() {
-    return BUILTIN_COMPILED_ZONE_SPECS.map((zone) => ({ ...zone }));
+    return loadBuiltinCompiledContract().zones.map((zone) => ({ ...zone }));
 }
 export function listBuiltinCompiledFallbackStages() {
-    return BUILTIN_COMPILED_STAGE_ACCESS_PATTERNS.map((stage) => ({
-        id: stage.id,
-        contract_type: stage.contractType,
+    return loadBuiltinCompiledContract().stages.map((stage) => ({
+        ...stage,
         reads: [...stage.reads],
         writes: [...stage.writes],
     }));

package/dist/lib/compiled-compile.d.ts

@@ -15,10 +15,6 @@ export interface CompiledCompileResult {
     ok: boolean;
     stageResults: Record<string, WorkflowStageResult>;
     failedStage: string | null;
-    summarize: CompiledSummarizeResult | null;
-    structure: WorkflowStageResult | null;
-    shape: WorkflowStageResult | null;
-    compile: WorkflowStageResult | null;
 }
 export type StageShellRetentionMode = "on-failure" | "always";
 export declare function resolveCompiledContext(compiledPath: string): {

package/dist/lib/compiled-compile.js

@@ -44,7 +44,7 @@ function zoneArtifactCount(compiledPath, zonePath, kind) {
 function resolveStageContractArtifacts(compiledPath, stageDefinition) {
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
     if (!schema) {
-        throw new Error(`Missing compiled schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
+        throw new Error(`Missing workflow schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
     }
     return {
         reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
@@ -198,10 +198,6 @@ export async function compileCompiled(options) {
         ok: true,
         stageResults: {},
         failedStage: null,
-        summarize: null,
-        structure: null,
-        shape: null,
-        compile: null,
     };
     try {
         const sourceInputPath = resolveSourceInputPath(options.compiledPath);
@@ -214,10 +210,13 @@ export async function compileCompiled(options) {
                 ...result,
                 ok: false,
                 failedStage: "workflow",
-                compile: {
-                    ok: false,
-                    code: 1,
-                    summary: workflowValidation.summary,
+                stageResults: {
+                    ...result.stageResults,
+                    workflow: {
+                        ok: false,
+                        code: 1,
+                        summary: workflowValidation.summary,
+                    },
                 },
             };
         }
@@ -232,34 +231,16 @@ export async function compileCompiled(options) {
                 stageDefinition,
             });
             result.stageResults[stageDefinition.id] = stageResult;
-            if (stageDefinition.id === "summarize") {
-                result.summarize = {
-                    ...stageResult,
-                    skipped: false,
-                    plan: {
-                        sourceCount: discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount,
-                        summaryCount: 0,
-                        targetCount: discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount,
-                    },
-                };
-            }
-            else if (stageDefinition.id === "structure") {
-                result.structure = stageResult;
-            }
-            else if (stageDefinition.id === "shape") {
-                result.shape = stageResult;
-            }
             if (!stageResult.ok) {
                 result.ok = false;
                 result.failedStage = stageDefinition.id;
-                result.compile = stageResult;
                 return result;
             }
         }
         const workflowValidationResult = validateCompiledWorkflow(options.compiledPath);
         result.ok = workflowValidationResult.ok;
         result.failedStage = workflowValidationResult.ok ? null : workflowValidationResult.stage;
-        result.compile = {
+        result.stageResults.compiled = {
             ok: workflowValidationResult.ok,
             code: workflowValidationResult.ok ? 0 : 1,
             summary: workflowValidationResult.summary,

package/dist/lib/compiled-paths.d.ts

@@ -26,6 +26,7 @@ export declare function workflowImprovementLoopRoot(compiledPath: string, runId:
 export declare function targetTestRunsRootForCompiled(compiledPath: string): string;
 export declare function targetTestSandboxesRootForCompiled(compiledPath: string): string;
 export declare function compiledRuntimeLogsRoot(compiledPath: string): string;
+export declare function compiledRuntimeArchivedStageContractPath(compiledPath: string, runId: string): string;
 export declare function compiledQueryAcceptanceRoot(compiledPath: string): string;
 export declare function compiledRuntimeStatePath(compiledPath: string): string;
 export declare function compiledRuntimeHealthPath(compiledPath: string): string;

package/dist/lib/compiled-paths.js

@@ -55,6 +55,9 @@ export function targetTestSandboxesRootForCompiled(compiledPath) {
 export function compiledRuntimeLogsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "logs");
 }
+export function compiledRuntimeArchivedStageContractPath(compiledPath, runId) {
+    return join(compiledRuntimeLogsRoot(compiledPath), `${runId}.stage-contract.json`);
+}
 export function compiledQueryAcceptanceRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "query-acceptance");
 }

package/dist/lib/compiled-reset.d.ts

@@ -1 +1,2 @@
+export declare function clearCompiledRuntimeDerivedArtifacts(compiledPath: string): void;
 export declare function resetCompiledGeneratedState(compiledPath: string, scope?: "compile" | "all"): void;

package/dist/lib/compiled-reset.js

@@ -1,9 +1,8 @@
-import { existsSync, rmSync } from "node:fs";
+import { existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { compiledKnowledgeRootPath, compiledSummariesPath, } from "./compiled-schema.js";
-import { initCompiledState, refreshCompiledArtifacts, saveState, } from "./state.js";
-import { saveEmptyCompiledInventory } from "./state-io.js";
-import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
+import { readCompiledSchemaFile, } from "./compiled-schema.js";
+import { initializeCompiledRuntimeState, } from "./state.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } from "./compiled-paths.js";
 function removeIfExists(path) {
     if (existsSync(path)) {
         rmSync(path, { recursive: true, force: true });
@@ -15,24 +14,53 @@ const COMPILE_RUNTIME_RESET_ENTRIES = [
     "view-spec.json",
     "inventory.json",
     "run.json",
+    "raw-snapshot.json",
     "stage-contract.json",
-    "summarize-targets.json",
 ];
-function resetCompiledRuntimeFiles(compiledPath) {
+const PRESERVED_COMPILED_ROOTS = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".cursor",
+    ".gitignore",
+    ".interf",
+    ".interfignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+]);
+export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
     const runtimeRoot = compiledRuntimeRoot(compiledPath);
     for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
         removeIfExists(join(runtimeRoot, entry));
     }
     removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
 }
+function activeCompiledInputRoots(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const roots = new Set();
+    for (const zone of schema?.zones ?? []) {
+        if (zone.role !== "input")
+            continue;
+        const root = zone.path.split("/")[0]?.trim();
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+function resetCompiledGeneratedOutputs(compiledPath) {
+    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
+    for (const entry of readdirSync(compiledPath)) {
+        if (PRESERVED_COMPILED_ROOTS.has(entry))
+            continue;
+        if (preservedInputRoots.has(entry))
+            continue;
+        removeIfExists(join(compiledPath, entry));
+    }
+}
 export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
-    removeIfExists(compiledSummariesPath(compiledPath));
-    removeIfExists(compiledKnowledgeRootPath(compiledPath));
-    removeIfExists(join(compiledPath, ".obsidian"));
-    resetCompiledRuntimeFiles(compiledPath);
-    saveState(compiledPath, initCompiledState());
-    saveEmptyCompiledInventory(compiledPath);
-    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
+    resetCompiledGeneratedOutputs(compiledPath);
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
     if (scope === "all") {
         removeIfExists(stageExecutionShellsRoot(compiledPath));
         removeIfExists(workflowImprovementLoopsRoot(compiledPath));

package/dist/lib/compiled-schema.d.ts

@@ -5,9 +5,11 @@ export interface WorkflowSchemaStageLike {
     writes: readonly string[];
 }
 export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
-export declare const COMPILED_SCHEMA_FILE = "compiled.schema.json";
-export declare function compiledSchemaFilePath(rootPath: string): string;
-export declare function compiledSchemaRelativePath(): string;
+export declare const WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
+export declare function workflowSchemaFilePath(rootPath: string): string;
+export declare function resolveWorkflowSchemaPath(rootPath: string): string | null;
+export declare function workflowSchemaExists(rootPath: string): boolean;
+export declare function workflowSchemaRelativePath(): string;
 export declare function listCompiledSchemaZones(schema: WorkflowCompiledSchema): WorkflowCompiledZone[];
 export declare function findCompiledSchemaZone(schema: WorkflowCompiledSchema, zoneId: WorkflowZoneId): WorkflowCompiledZone | null;
 export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<WorkflowCompiledZone, "path">): string;
@@ -22,6 +24,8 @@ export declare function compiledKnowledgeIndexesPath(compiledPath: string): stri
 export declare function compiledKnowledgeRootPath(compiledPath: string): string;
 export declare function compiledHomePath(compiledPath: string): string;
 export declare function ensureCompiledZoneTargets(compiledPath: string, schema: WorkflowCompiledSchema): void;
-export declare function buildCompiledSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeCompiledSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
+export declare function buildWorkflowSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
+export declare function writeWorkflowSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
+export declare function writeWorkflowSchemaDocument(rootPath: string, schema: WorkflowCompiledSchema): WorkflowCompiledSchema;
+export declare function readWorkflowSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
 export declare function readCompiledSchemaFile(rootPath: string): WorkflowCompiledSchema | null;

package/dist/lib/compiled-schema.js

@@ -1,16 +1,24 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { readJsonFileWithSchema } from "./parse.js";
+import { warnInterf } from "./logger.js";
+import { readJsonFileUnchecked } from "./parse.js";
 import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-workflow.js";
 import { WorkflowCompiledSchemaSchema, } from "./schema.js";
 export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
-export const COMPILED_SCHEMA_FILE = "compiled.schema.json";
+export const WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
 const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
-export function compiledSchemaFilePath(rootPath) {
-    return join(rootPath, COMPILED_SCHEMA_FILE);
+export function workflowSchemaFilePath(rootPath) {
+    return join(rootPath, WORKFLOW_SCHEMA_FILE);
 }
-export function compiledSchemaRelativePath() {
-    return `workflow/${COMPILED_SCHEMA_FILE}`;
+export function resolveWorkflowSchemaPath(rootPath) {
+    const path = workflowSchemaFilePath(rootPath);
+    return existsSync(path) ? path : null;
+}
+export function workflowSchemaExists(rootPath) {
+    return existsSync(workflowSchemaFilePath(rootPath));
+}
+export function workflowSchemaRelativePath() {
+    return `workflow/${WORKFLOW_SCHEMA_FILE}`;
 }
 export function listCompiledSchemaZones(schema) {
     return [...schema.zones];
@@ -77,11 +85,18 @@ function pushZone(zones, zone) {
         return;
     zones.push(zone);
 }
-export function buildCompiledSchema(stages, label = "Compiled dataset schema") {
+function normalizeWorkflowSchema(schema) {
+    return {
+        ...schema,
+        kind: "workflow-schema",
+    };
+}
+export function buildWorkflowSchema(stages, label = "Workflow schema") {
     const zones = [];
     for (const zone of listBuiltinCompiledZoneSpecs()) {
         pushZone(zones, {
             id: zone.id,
+            role: zone.role,
             path: zone.path,
             kind: zone.kind,
             required: zone.required,
@@ -90,21 +105,37 @@ export function buildCompiledSchema(stages, label = "Compiled dataset schema") {
         });
     }
     return {
-        kind: "compiled-schema",
+        kind: "workflow-schema",
         version: 1,
         target_type: "compiled",
         label,
         zones,
     };
 }
-export function writeCompiledSchemaFile(rootPath, stages, label) {
-    const schema = buildCompiledSchema(stages, label);
-    writeFileSync(compiledSchemaFilePath(rootPath), `${JSON.stringify(schema, null, 2)}\n`);
+export function writeWorkflowSchemaFile(rootPath, stages, label) {
+    const schema = buildWorkflowSchema(stages, label);
+    writeWorkflowSchemaDocument(rootPath, schema);
     return schema;
 }
-export function readCompiledSchemaFile(rootPath) {
-    const path = compiledSchemaFilePath(rootPath);
+export function writeWorkflowSchemaDocument(rootPath, schema) {
+    const normalized = normalizeWorkflowSchema(schema);
+    writeFileSync(workflowSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
+    return normalized;
+}
+export function readWorkflowSchemaFile(rootPath) {
+    const path = workflowSchemaFilePath(rootPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "compiled schema", WorkflowCompiledSchemaSchema);
+    const raw = readJsonFileUnchecked(path, "workflow schema");
+    if (raw === null)
+        return null;
+    const parsed = WorkflowCompiledSchemaSchema.safeParse(raw);
+    if (!parsed.success) {
+        warnInterf(`Warning: failed to validate workflow schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
+    }
+    return normalizeWorkflowSchema(parsed.data);
+}
+export function readCompiledSchemaFile(rootPath) {
+    return readWorkflowSchemaFile(rootPath);
 }

package/dist/lib/discovery.d.ts

@@ -4,4 +4,4 @@ export interface DiscoveryResult {
     ignoredCount: number;
 }
 export declare function discoverSourceFiles(sourcePath: string, compiledPath: string): DiscoveryResult;
-export declare function loadIgnorePatterns(knowledgeBasePath: string): string[];
+export declare function loadIgnorePatterns(compiledPath: string): string[];

package/dist/lib/discovery.js

@@ -36,8 +36,8 @@ export function discoverSourceFiles(sourcePath, compiledPath) {
         ignoredCount,
     };
 }
-export function loadIgnorePatterns(knowledgeBasePath) {
-    const ignorePath = join(knowledgeBasePath, ".interfignore");
+export function loadIgnorePatterns(compiledPath) {
+    const ignorePath = join(compiledPath, ".interfignore");
     if (!existsSync(ignorePath))
         return [];
     return readFileSync(ignorePath, "utf-8")

package/dist/lib/executors.d.ts

@@ -18,7 +18,7 @@ export interface WorkflowExecutor {
     displayName: string;
     command?: string | null;
     executionProfile?: WorkflowExecutionProfile;
-    execute(knowledgeBasePath: string, prompt: string, options?: WorkflowExecuteOptions): Promise<number>;
+    execute(rootPath: string, prompt: string, options?: WorkflowExecuteOptions): Promise<number>;
 }
 export type { RuntimeExecutorInfo } from "./schema.js";
 export declare function buildRuntimeExecutorInfo(executor: WorkflowExecutor): RuntimeExecutorInfo;

package/dist/lib/executors.js

@@ -18,8 +18,8 @@ export function createLocalAgentExecutor(agent, executionProfile = {}) {
         displayName: agent.displayName,
         command: agent.command,
         executionProfile,
-        execute(knowledgeBasePath, prompt, options) {
-            return spawnAgent(agent, knowledgeBasePath, prompt, {
+        execute(rootPath, prompt, options) {
+            return spawnAgent(agent, rootPath, prompt, {
                 eventLogPath: options?.eventLogPath,
                 statusLogPath: options?.statusLogPath,
                 executionProfile,

package/dist/lib/interf-scaffold.js

@@ -1,9 +1,7 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
 import { getCompiledWorkflow } from "./workflow-definitions.js";
-import { refreshCompiledArtifacts, saveState, initCompiledState, } from "./state.js";
-import { saveEmptyCompiledInventory } from "./state-io.js";
-import { writeObsidianDefaults } from "./obsidian.js";
+import { initializeCompiledRuntimeState, } from "./state.js";
 import { assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
 import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
@@ -20,7 +18,6 @@ const DEFAULT_INTERFIGNORE = [
     ".interf/tests/",
     ".interf/tests/targets/sandboxes/",
     ".interf/runtime/",
-    ".obsidian/",
     "",
 ].join("\n");
 const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet compiled. Run `interf compile` to build the compiled dataset.";
@@ -47,17 +44,16 @@ function compiledGitignoreEntries(compiledPath) {
         ".interf/tests/",
         ".interf/tests/targets/sandboxes/",
         ".interf/runtime/",
-        ".obsidian/",
     ];
 }
 function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
     if (!schema) {
-        throw new Error(`Missing compiled schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
+        throw new Error(`Missing workflow schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
     }
     ensureCompiledZoneTargets(compiledPath, schema);
     for (const zone of schema.zones) {
-        if (!zone.required || zone.kind !== "file" || zone.id === "raw")
+        if (!zone.required || zone.kind !== "file" || zone.role !== "output")
             continue;
         const targetPath = join(compiledPath, zone.path);
         if (existsSync(targetPath))
@@ -110,10 +106,7 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
     scaffoldCompiledOutputs(compiledPath, name, about);
     refreshCompiledBootstrapGuidance(compiledPath);
     writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
-    saveState(compiledPath, initCompiledState());
-    saveEmptyCompiledInventory(compiledPath);
-    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
-    writeObsidianDefaults(compiledPath, "compiled");
+    initializeCompiledRuntimeState(compiledPath);
     return compiledPath;
 }
 export function defaultCompiledNameForSource(sourcePath) {

package/dist/lib/interf-workflow-package.d.ts

@@ -14,7 +14,12 @@ export declare function createLocalWorkflowPackageFromTemplate(options: {
     workflowId: string;
     label: string;
     hint: string;
-    summarizeBias: string;
-    structureBias: string;
-    shapeBias: string;
+    stagePolicyNotes: Record<string, string[]>;
+}): string;
+export declare function seedLocalWorkflowPackageFromBase(options: {
+    sourcePath: string;
+    baseWorkflowId: string;
+    workflowId: string;
+    label: string;
+    hint: string;
 }): string;