@interf/compiler 0.5.0 → 0.6.1

package/dist/lib/compiled-compile.js

@@ -5,7 +5,7 @@ import { reconcileCompiledStageRun, } from "./runtime-reconcile.js";
 import { refreshCompiledArtifacts, } from "./state.js";
 import { buildRuntimeStageContract, } from "./runtime.js";
 import { validateWorkflowPackage } from "./local-workflows.js";
-import { formatActiveCompiledWorkflowStageStep, getActiveCompiledStagePolicyNotes, getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig, resolveActiveCompiledStageAcceptance, } from "./workflow-definitions.js";
+import { formatActiveCompiledWorkflowStageStep, getActiveCompiledStagePolicyNotes, getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, resolveActiveCompiledStageAcceptance, } from "./workflow-definitions.js";
 import { validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
 import { buildLocalSkillContractExtension, buildStageInstructions, reportBlankLine, reportLine, reportValidationFailure, workflowCompileStageDirectory, } from "./workflow-helpers.js";
 import { executeValidatedStage, } from "./workflow-stage-runner.js";
@@ -16,7 +16,7 @@ import { discoverSourceFiles } from "./discovery.js";
 import { listFilesRecursive } from "./filesystem.js";
 export function resolveCompiledContext(compiledPath) {
     const config = readInterfConfig(compiledPath);
-    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${compiledPath}`);
     return {
         compiledName: config?.name ?? "compiled",
         sourcePath: resolveSourceFolderPath(compiledPath, config),
@@ -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

@@ -18,9 +18,7 @@ export declare function compiledInterfRoot(compiledPath: string): string;
 export declare function compiledInterfConfigPath(compiledPath: string): string;
 export declare function workflowPackagePathForCompiled(compiledPath: string): string;
 export declare function testRootForCompiled(compiledPath: string): string;
-export declare function testRunsRootForCompiled(compiledPath: string): string;
 export declare function testTargetsRootForCompiled(compiledPath: string): string;
-export declare function latestTestComparisonPathForCompiled(compiledPath: string): string;
 export declare function stageExecutionShellsRoot(compiledPath: string): string;
 export declare function workflowImprovementLoopsRoot(compiledPath: string): string;
 export declare function workflowImprovementRunRoot(compiledPath: string, runId: string): string;
@@ -28,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

@@ -31,15 +31,9 @@ export function workflowPackagePathForCompiled(compiledPath) {
 export function testRootForCompiled(compiledPath) {
     return join(compiledInterfRoot(compiledPath), COMPILED_TEST_DIR);
 }
-export function testRunsRootForCompiled(compiledPath) {
-    return join(testRootForCompiled(compiledPath), "runs");
-}
 export function testTargetsRootForCompiled(compiledPath) {
     return join(testRootForCompiled(compiledPath), COMPILED_TEST_TARGETS_DIR);
 }
-export function latestTestComparisonPathForCompiled(compiledPath) {
-    return join(testRootForCompiled(compiledPath), "latest.json");
-}
 export function stageExecutionShellsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "execution-shells");
 }
@@ -61,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");
 }
@@ -91,14 +88,12 @@ export function compiledRuntimeStageContractPath(compiledPath) {
 export function resolveSourceControlPathForCompiled(compiledPath) {
     let cursor = resolve(compiledPath);
     while (true) {
-        if (basename(cursor) === "compiled") {
-            const datasetRoot = dirname(cursor);
-            const interfRoot = dirname(datasetRoot);
-            if (basename(interfRoot) === "interf") {
-                return dirname(interfRoot);
-            }
-        }
         const parent = dirname(cursor);
+        if (basename(parent) === "interf" &&
+            basename(cursor) !== "tests" &&
+            basename(cursor) !== "workflows") {
+            return dirname(parent);
+        }
         if (parent === cursor)
             break;
         cursor = parent;

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

@@ -9,6 +9,7 @@ export declare function resolveCompiledRawPath(compiledPath: string, config?: {
     [x: string]: unknown;
     type: "compiled";
     name: string;
+    workflow: string;
     checks: {
         question: string;
         id?: string | undefined;
@@ -24,11 +25,10 @@ export declare function resolveCompiledRawPath(compiledPath: string, config?: {
     }[];
     source: {
         path: string;
+        dataset_path: string;
         control_path?: string | undefined;
-        dataset_path?: string | undefined;
     };
     about?: string | undefined;
-    workflow?: string | undefined;
     max_attempts?: number | undefined;
     max_loops?: number | undefined;
     workflow_origin?: {

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

@@ -1,13 +1,15 @@
-import { type BuiltinCompiledZoneId } from "./workflow-abi.js";
+import { type BuiltinCompiledZoneId } from "./builtin-compiled-workflow.js";
 import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "./schema.js";
 export interface WorkflowSchemaStageLike {
     id: string;
     writes: readonly string[];
 }
-export { BUILTIN_COMPILED_ZONE_IDS } from "./workflow-abi.js";
-export declare const COMPILED_SCHEMA_FILE = "compiled.schema.json";
-export declare function compiledSchemaFilePath(rootPath: string): string;
-export declare function compiledSchemaRelativePath(): string;
+export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
+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 { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./workflow-abi.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 "./workflow-abi.js";
-export const COMPILED_SCHEMA_FILE = "compiled.schema.json";
+export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
+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-detect.d.ts

@@ -10,7 +10,6 @@ export declare const WORKFLOW_CONTAINER_NAME = "workflows";
 export declare const TEST_CONTAINER_NAME = "tests";
 export declare const INTERF_CONFIG_FILE = "interf.json";
 export declare const WORKFLOW_PACKAGE_DIR = "workflow";
-export declare function prepareCompiledLayout(dirPath: string): boolean;
 export declare function readInterfConfig(dirPath: string): InterfConfig | null;
 export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
     source: {

package/dist/lib/interf-detect.js

@@ -4,7 +4,6 @@ import { warnInterf } from "./logger.js";
 import { readJsonFileUnchecked } from "./parse.js";
 import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
 import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
-import { normalizeLegacyCompiledLayout, compiledNeedsLegacyLayoutNormalization, } from "./compiled-layout.js";
 import { InterfConfigSchema, } from "./schema.js";
 import { assertPathWithinRoot } from "./util.js";
 export const INTERF_CONTAINER_NAME = "interf";
@@ -12,12 +11,6 @@ export const WORKFLOW_CONTAINER_NAME = "workflows";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
 export const WORKFLOW_PACKAGE_DIR = "workflow";
-export function prepareCompiledLayout(dirPath) {
-    if (!compiledNeedsLegacyLayoutNormalization(dirPath)) {
-        return false;
-    }
-    return normalizeLegacyCompiledLayout(dirPath);
-}
 export function readInterfConfig(dirPath) {
     const configPath = compiledInterfConfigPath(dirPath);
     if (!existsSync(configPath))
@@ -41,7 +34,6 @@ export function hasSourceFolderInput(config) {
     return typeof config?.source?.path === "string" && config.source.path.length > 0;
 }
 export function detectInterf(cwd) {
-    prepareCompiledLayout(cwd);
     const config = readInterfConfig(cwd);
     if (config)
         return { path: cwd, config };
@@ -58,7 +50,6 @@ export function resolveCompiled(cwd) {
     };
 }
 export function resolveSourceFolderPath(compiledPath, config = null) {
-    prepareCompiledLayout(compiledPath);
     const resolvedConfig = config ?? readInterfConfig(compiledPath);
     if (hasSourceFolderInput(resolvedConfig)) {
         return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
@@ -66,17 +57,15 @@ export function resolveSourceFolderPath(compiledPath, config = null) {
     return resolve(compiledPath, "raw");
 }
 export function resolveSourceControlPath(compiledPath) {
-    prepareCompiledLayout(compiledPath);
     return resolveSourceControlPathForCompiled(compiledPath);
 }
 export function resolveSourceInputPath(compiledPath) {
-    prepareCompiledLayout(compiledPath);
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
     const config = readInterfConfig(compiledPath);
     if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
+        const projectPath = resolveSourceControlPathForCompiled(compiledPath);
         return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
     }
-    return projectPath;
+    throw new Error(`Compiled dataset is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
 export function listCompiledDatasetsForSourceFolder(sourcePath) {
     const interfRoot = projectInterfRoot(sourcePath);
@@ -91,11 +80,12 @@ export function listCompiledDatasetsForSourceFolder(sourcePath) {
         return [];
     }
     return readdirSync(interfRoot)
-        .filter((entry) => !entry.startsWith(".") && entry !== WORKFLOW_CONTAINER_NAME)
+        .filter((entry) => !entry.startsWith(".") &&
+        entry !== WORKFLOW_CONTAINER_NAME &&
+        entry !== TEST_CONTAINER_NAME)
         .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
         .filter((compiledPath) => existsSync(compiledPath))
         .map((compiledPath) => {
-        prepareCompiledLayout(compiledPath);
         const config = readInterfConfig(compiledPath);
         return config ? { path: compiledPath, config } : null;
     })
@@ -112,7 +102,7 @@ export function assertCompiledContainer(sourcePath) {
             if (entry.startsWith("."))
                 return false;
             const entryPath = join(interfRoot, entry);
-            if (entry === WORKFLOW_CONTAINER_NAME) {
+            if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
                 }
@@ -146,7 +136,7 @@ export function assertCompiledContainer(sourcePath) {
     const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
         if (entry.startsWith("."))
             return false;
-        if (entry === WORKFLOW_CONTAINER_NAME)
+        if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
             return false;
         const entryPath = join(containerPath, entry);
         try {
@@ -161,7 +151,6 @@ export function assertCompiledContainer(sourcePath) {
         if (!existsSync(compiledPath)) {
             return false;
         }
-        prepareCompiledLayout(compiledPath);
         return !readInterfConfig(compiledPath);
     });
     if (unexpectedEntries.length > 0) {

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;