@interf/compiler 0.5.1 → 0.6.1

package/dist/lib/runtime-reconcile.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
-import { join, relative } from "node:path";
+import { extname, join, relative } from "node:path";
 import { listFilesRecursive } from "./filesystem.js";
 import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { parseJsonFrontmatter } from "./parse.js";
@@ -51,59 +51,99 @@ function summaryAbstract(content) {
         return null;
     return extractSynthAbstract(parsed.frontmatter, parsed.body);
 }
+function listZoneArtifacts(dirPath, zone) {
+    const absolutePath = compiledZoneAbsolutePath(dirPath, zone);
+    if (!existsSync(absolutePath) || zone.kind === "runtime")
+        return [];
+    if (zone.kind === "file") {
+        try {
+            return statSync(absolutePath).isFile() ? [absolutePath] : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return listFilesRecursive(absolutePath);
+}
+function buildInventoryMetadata(options) {
+    const metadata = {
+        zone_id: options.zoneId,
+        zone_kind: options.zoneKind,
+        file_extension: extname(options.filePath).toLowerCase() || null,
+    };
+    if (!options.parsedFrontmatter) {
+        return metadata;
+    }
+    metadata.frontmatter_scanned = true;
+    const abstract = summaryAbstract(readFileSync(options.filePath, "utf8"));
+    if (abstract) {
+        metadata.abstract = abstract;
+        metadata.abstract_read = true;
+    }
+    const frontmatter = options.parsedFrontmatter.frontmatter;
+    if (typeof frontmatter.source_kind === "string") {
+        metadata.source_kind = frontmatter.source_kind;
+    }
+    if (typeof frontmatter.evidence_tier === "string") {
+        metadata.evidence_tier = frontmatter.evidence_tier;
+    }
+    if (typeof frontmatter.truth_mode === "string") {
+        metadata.truth_mode = frontmatter.truth_mode;
+    }
+    return metadata;
+}
 function buildStageInventoryEntries(dirPath, stage) {
     const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
     if (!schema)
         return [];
-    const inputZone = stage.reads
+    const readableInputZones = stage.reads
         .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .find((zone) => zone && zone.kind !== "runtime");
-    const outputZone = stage.writes
+        .filter((zone) => zone !== null && zone.kind !== "runtime");
+    const outputZones = stage.writes
         .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .find((zone) => zone && zone.kind !== "runtime");
-    if (!inputZone || !outputZone)
+        .filter((zone) => zone !== null && zone.kind !== "runtime");
+    if (outputZones.length === 0)
         return [];
-    const outputRoot = compiledZoneAbsolutePath(dirPath, outputZone);
-    if (!existsSync(outputRoot))
-        return [];
-    return listFilesRecursive(outputRoot, isOutputMarkdownFile)
-        .map((filePath) => {
-        const content = readFileSync(filePath, "utf8");
-        const parsed = parseJsonFrontmatter(content);
-        if (!parsed)
-            return null;
-        const inputPath = typeof parsed.frontmatter.source === "string"
-            ? parsed.frontmatter.source.trim()
-            : "";
-        if (inputPath.length === 0)
-            return null;
-        const abstract = summaryAbstract(content);
-        return {
-            input_zone: inputZone.id,
-            input_path: inputPath,
-            output_zone: outputZone.id,
-            output_path: relative(dirPath, filePath).replaceAll("\\", "/"),
-            state: typeof parsed.frontmatter.state === "string"
-                ? parsed.frontmatter.state
-                : "complete",
-            metadata: {
-                source_kind: typeof parsed.frontmatter.source_kind === "string"
-                    ? parsed.frontmatter.source_kind
-                    : "unknown",
-                evidence_tier: typeof parsed.frontmatter.evidence_tier === "string"
-                    ? parsed.frontmatter.evidence_tier
-                    : "primary",
-                truth_mode: typeof parsed.frontmatter.truth_mode === "string"
-                    ? parsed.frontmatter.truth_mode
-                    : "reported-data",
-                abstract,
-                frontmatter_scanned: true,
-                abstract_read: Boolean(abstract),
-            },
-        };
-    })
-        .filter((entry) => entry !== null)
-        .sort((left, right) => left.input_path.localeCompare(right.input_path));
+    const entries = [];
+    for (const outputZone of outputZones) {
+        for (const filePath of listZoneArtifacts(dirPath, outputZone)) {
+            const relativeOutputPath = relative(dirPath, filePath).replaceAll("\\", "/");
+            const parsed = isOutputMarkdownFile(filePath)
+                ? parseJsonFrontmatter(readFileSync(filePath, "utf8"))
+                : null;
+            const sourcePath = typeof parsed?.frontmatter.source === "string"
+                ? parsed.frontmatter.source.trim()
+                : "";
+            const sourceZoneId = typeof parsed?.frontmatter.source_zone === "string"
+                ? parsed.frontmatter.source_zone.trim()
+                : "";
+            const inputZone = sourceZoneId.length > 0
+                ? readableInputZones.find((zone) => zone.id === sourceZoneId) ?? null
+                : readableInputZones.length === 1
+                    ? readableInputZones[0]
+                    : null;
+            entries.push({
+                ...(inputZone && sourcePath.length > 0
+                    ? {
+                        input_zone: inputZone.id,
+                        input_path: sourcePath,
+                    }
+                    : {}),
+                output_zone: outputZone.id,
+                output_path: relativeOutputPath,
+                ...(typeof parsed?.frontmatter.state === "string"
+                    ? { state: parsed.frontmatter.state }
+                    : {}),
+                metadata: buildInventoryMetadata({
+                    zoneId: outputZone.id,
+                    zoneKind: outputZone.kind,
+                    filePath,
+                    parsedFrontmatter: parsed,
+                }),
+            });
+        }
+    }
+    return entries.sort((left, right) => `${left.output_zone}:${left.output_path}`.localeCompare(`${right.output_zone}:${right.output_path}`));
 }
 function writeStageInventory(dirPath, stageId, entries) {
     writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
@@ -126,10 +166,7 @@ export function reconcileCompiledStageRun(dirPath, stage) {
     if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
         return false;
     }
-    const inventoryEntries = buildStageInventoryEntries(dirPath, stage);
-    if (inventoryEntries.length > 0) {
-        writeStageInventory(dirPath, stage.id, inventoryEntries);
-    }
+    writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
     const currentState = {
         ...initCompiledState(),
         ...(loadState(dirPath) ?? {}),

package/dist/lib/runtime-runs.js

@@ -5,7 +5,7 @@ import { countFilesRecursive } from "./filesystem.js";
 import { buildRuntimeExecutorInfo } from "./executors.js";
 import { RuntimeRunSchema, } from "./schema.js";
 import { getWorkflowStageDefinition, getWorkflowStagePosition, getWorkflowStages, } from "./workflow-definitions.js";
-import { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 import { warnInterf } from "./logger.js";
 export function loadRuntimeRun(dirPath) {
     const path = runPath(dirPath);
@@ -34,28 +34,34 @@ export function writeStageContract(dirPath, contract) {
     writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
     return path;
 }
+function writeArchivedStageContract(dirPath, runId, contract) {
+    const path = archivedStageContractPath(dirPath, runId);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(contract, null, 2) + "\n");
+    return path;
+}
 export async function runExecutorStage(options) {
-    const run = startRuntimeRun(options);
-    const prompt = options.buildPrompt(run.contract_path);
-    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    const startedRun = startRuntimeRun(options);
+    const prompt = options.buildPrompt(startedRun.activeContractPath);
+    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
     const executionPath = options.executionPath ?? options.compiledPath;
     const code = await options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
     });
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
 }
 export async function runExecutorSummarizeStage(options) {
-    const run = startRuntimeRun(options);
-    const prompt = options.buildPrompt(run.contract_path);
+    const startedRun = startRuntimeRun(options);
+    const prompt = options.buildPrompt(startedRun.activeContractPath);
     let lastReported = 0;
-    writeRuntimeRunPrompt(options.compiledPath, run.run_id, prompt);
+    writeRuntimeRunPrompt(options.compiledPath, startedRun.run.run_id, prompt);
     const executionPath = options.executionPath ?? options.compiledPath;
     const progressPromise = options.executor.execute(executionPath, prompt, {
-        eventLogPath: eventLogPath(options.compiledPath, run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, run.run_id),
+        eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
+        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
     });
     const timer = setInterval(() => {
@@ -66,7 +72,7 @@ export async function runExecutorSummarizeStage(options) {
         lastReported = completed;
         updateRuntimeRun(options.compiledPath, {
             counts: {
-                ...run.counts,
+                ...startedRun.run.counts,
                 completed_summaries: completed,
                 target_summaries: options.targetCount,
             },
@@ -164,7 +170,8 @@ function startRuntimeRun(options) {
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };
-    const contractPath = writeStageContract(options.compiledPath, contract);
+    const activeContractPath = writeStageContract(options.compiledPath, contract);
+    const archivedContractPath = writeArchivedStageContract(options.compiledPath, runId, contract);
     const run = {
         kind: "interf-run",
         version: 1,
@@ -180,7 +187,7 @@ function startRuntimeRun(options) {
         started_at: generatedAt,
         updated_at: generatedAt,
         finished_at: null,
-        contract_path: relative(options.compiledPath, contractPath),
+        contract_path: relative(options.compiledPath, archivedContractPath),
         ...(options.executionPath ? { execution_path: relative(options.compiledPath, options.executionPath) } : {}),
         counts: { ...contract.counts },
         output_artifacts: [...contract.artifacts.writes],
@@ -193,7 +200,12 @@ function startRuntimeRun(options) {
         exit_code: null,
         error: null,
     };
-    return beginRuntimeRun(options.compiledPath, run);
+    return {
+        run: beginRuntimeRun(options.compiledPath, run),
+        activeContractPath: options.executionPath
+            ? "runtime/stage-contract.json"
+            : relative(options.compiledPath, activeContractPath),
+    };
 }
 function finalizeRuntimeRun(dirPath, code) {
     const current = loadRuntimeRun(dirPath);

package/dist/lib/runtime.d.ts

@@ -1,5 +1,5 @@
 export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageAcceptanceValidation, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeSummarizeExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
-export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";

package/dist/lib/runtime.js

@@ -1,4 +1,4 @@
-export { eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 export { validateStageContractAcceptance } from "./runtime-acceptance.js";
 export { buildStagePrompt } from "./runtime-prompt.js";
 export { buildRuntimeStageContract, } from "./runtime-contracts.js";

package/dist/lib/schema.d.ts

@@ -18,6 +18,12 @@ export declare const WorkflowCompiledZoneKindSchema: z.ZodEnum<{
     directory: "directory";
     file: "file";
 }>;
+export declare const WorkflowZoneRoleSchema: z.ZodEnum<{
+    output: "output";
+    runtime: "runtime";
+    input: "input";
+    working: "working";
+}>;
 export declare const CompiledStageStatusSchema: z.ZodEnum<{
     idle: "idle";
     running: "running";
@@ -61,11 +67,6 @@ export declare const CompiledStateSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     last_add: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     last_compile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    inventory_complete: z.ZodOptional<z.ZodBoolean>;
-    abstracts_read: z.ZodOptional<z.ZodNumber>;
-    full_reads: z.ZodOptional<z.ZodNumber>;
-    entity_count: z.ZodOptional<z.ZodNumber>;
-    claim_count: z.ZodOptional<z.ZodNumber>;
     warning_count: z.ZodOptional<z.ZodNumber>;
     error_count: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
@@ -158,8 +159,36 @@ export declare const CompiledRawSnapshotSchema: z.ZodObject<{
     source_total: z.ZodNumber;
     sample_files: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+export declare const WorkflowPurposeSchema: z.ZodObject<{
+    label: z.ZodString;
+    task_hint: z.ZodString;
+}, z.core.$strict>;
+export declare const WorkflowZoneSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        output: "output";
+        runtime: "runtime";
+        input: "input";
+        working: "working";
+    }>;
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        runtime: "runtime";
+        directory: "directory";
+        file: "file";
+    }>;
+    required: z.ZodBoolean;
+    owned_by: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+}, z.core.$strip>;
 export declare const WorkflowCompiledZoneSchema: z.ZodObject<{
     id: z.ZodString;
+    role: z.ZodEnum<{
+        output: "output";
+        runtime: "runtime";
+        input: "input";
+        working: "working";
+    }>;
     path: z.ZodString;
     kind: z.ZodEnum<{
         runtime: "runtime";
@@ -170,13 +199,43 @@ export declare const WorkflowCompiledZoneSchema: z.ZodObject<{
     owned_by: z.ZodArray<z.ZodString>;
     description: z.ZodString;
 }, z.core.$strip>;
+export declare const WorkflowSchemaSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"workflow-schema">;
+    version: z.ZodLiteral<1>;
+    target_type: z.ZodLiteral<"compiled">;
+    label: z.ZodString;
+    zones: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            input: "input";
+            working: "working";
+        }>;
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            runtime: "runtime";
+            directory: "directory";
+            file: "file";
+        }>;
+        required: z.ZodBoolean;
+        owned_by: z.ZodArray<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const WorkflowCompiledSchemaSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"compiled-schema">;
+    kind: z.ZodLiteral<"workflow-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
     zones: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
+        role: z.ZodEnum<{
+            output: "output";
+            runtime: "runtime";
+            input: "input";
+            working: "working";
+        }>;
         path: z.ZodString;
         kind: z.ZodEnum<{
             runtime: "runtime";
@@ -258,6 +317,7 @@ export declare const RuntimeStageAcceptanceSchema: z.ZodObject<{
     zone_counts_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     zone_counts_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     markdown_frontmatter_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    frontmatter_required_keys_in_zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
     markdown_abstract_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
     wikilinks_valid_in_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
     artifacts_must_not_contain: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
@@ -318,6 +378,7 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         zone_counts_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         zone_counts_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         markdown_frontmatter_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        frontmatter_required_keys_in_zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
         markdown_abstract_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
         wikilinks_valid_in_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
         artifacts_must_not_contain: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
@@ -389,8 +450,8 @@ export declare const RuntimeRunSchema: z.ZodObject<{
     error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export declare const CompiledInventoryEntrySchema: z.ZodObject<{
-    input_zone: z.ZodString;
-    input_path: z.ZodString;
+    input_zone: z.ZodOptional<z.ZodString>;
+    input_path: z.ZodOptional<z.ZodString>;
     output_zone: z.ZodString;
     output_path: z.ZodString;
     state: z.ZodOptional<z.ZodString>;
@@ -401,8 +462,8 @@ export declare const CompiledInventorySchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
     stage: z.ZodOptional<z.ZodString>;
     entries: z.ZodArray<z.ZodObject<{
-        input_zone: z.ZodString;
-        input_path: z.ZodString;
+        input_zone: z.ZodOptional<z.ZodString>;
+        input_path: z.ZodOptional<z.ZodString>;
         output_zone: z.ZodString;
         output_path: z.ZodString;
         state: z.ZodOptional<z.ZodString>;
@@ -967,10 +1028,6 @@ export declare const InterfUserConfigSchema: z.ZodObject<{
     agent: z.ZodString;
     agentCommand: z.ZodString;
     skillsInstalled: z.ZodBoolean;
-    viewer: z.ZodOptional<z.ZodEnum<{
-        plain: "plain";
-        obsidian: "obsidian";
-    }>>;
     initialized: z.ZodString;
 }, z.core.$strip>;
 export type InterfConfig = z.infer<typeof InterfConfigSchema>;

package/dist/lib/schema.js

@@ -19,6 +19,7 @@ export const RuntimeContractTypeSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
+export const WorkflowZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
 export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
 export const CompiledStageStateSchema = z.object({
     contract_type: RuntimeContractTypeSchema.optional(),
@@ -37,11 +38,6 @@ export const CompiledStateSchema = z.object({
     stages: z.record(z.string().regex(WorkflowIdPattern), CompiledStageStateSchema).optional(),
     last_add: z.string().nullable().optional(),
     last_compile: z.string().nullable().optional(),
-    inventory_complete: z.boolean().optional(),
-    abstracts_read: z.number().optional(),
-    full_reads: z.number().optional(),
-    entity_count: z.number().optional(),
-    claim_count: z.number().optional(),
     warning_count: z.number().optional(),
     error_count: z.number().optional(),
 }).strict();
@@ -95,8 +91,13 @@ export const CompiledRawSnapshotSchema = z.object({
     source_total: z.number(),
     sample_files: z.array(z.string()),
 });
-export const WorkflowCompiledZoneSchema = z.object({
+export const WorkflowPurposeSchema = z.object({
+    label: z.string().min(1),
+    task_hint: z.string().min(1),
+}).strict();
+export const WorkflowZoneSchema = z.object({
     id: WorkflowZoneIdSchema,
+    role: WorkflowZoneRoleSchema,
     path: z.string().min(1).refine(isCompiledRelativePath, {
         message: "Zone paths must stay inside the compiled root",
     }),
@@ -105,13 +106,15 @@ export const WorkflowCompiledZoneSchema = z.object({
     owned_by: z.array(z.string().regex(WorkflowIdPattern)),
     description: z.string().min(1),
 });
-export const WorkflowCompiledSchemaSchema = z.object({
-    kind: z.literal("compiled-schema"),
+export const WorkflowCompiledZoneSchema = WorkflowZoneSchema;
+export const WorkflowSchemaSchema = z.object({
+    kind: z.literal("workflow-schema"),
     version: z.literal(1),
     target_type: z.literal("compiled"),
     label: z.string().min(1),
-    zones: z.array(WorkflowCompiledZoneSchema).min(1),
+    zones: z.array(WorkflowZoneSchema).min(1),
 });
+export const WorkflowCompiledSchemaSchema = WorkflowSchemaSchema;
 export const WorkflowCompilerApiSchema = z.object({
     kind: z.literal("compiled"),
     version: z.literal(1),
@@ -158,6 +161,7 @@ export const RuntimeStageAcceptanceSchema = z.object({
     zone_counts_at_least: z.record(z.string().regex(WorkflowIdPattern), z.number()).optional(),
     zone_counts_at_least_counts: z.record(z.string().regex(WorkflowIdPattern), z.string()).optional(),
     markdown_frontmatter_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
+    frontmatter_required_keys_in_zones: z.record(WorkflowZoneIdSchema, z.array(z.string().min(1)).min(1)).optional(),
     markdown_abstract_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
     wikilinks_valid_in_zones: z.array(WorkflowZoneIdSchema).optional(),
     artifacts_must_not_contain: z.record(z.string(), z.array(z.string().min(1))).optional(),
@@ -230,8 +234,8 @@ export const RuntimeRunSchema = z.object({
     error: z.string().nullable(),
 });
 export const CompiledInventoryEntrySchema = z.object({
-    input_zone: WorkflowZoneIdSchema,
-    input_path: z.string().min(1),
+    input_zone: WorkflowZoneIdSchema.optional(),
+    input_path: z.string().min(1).optional(),
     output_zone: WorkflowZoneIdSchema,
     output_path: z.string().min(1),
     state: z.string().min(1).optional(),
@@ -534,6 +538,5 @@ export const InterfUserConfigSchema = z.object({
     agent: z.string(),
     agentCommand: z.string(),
     skillsInstalled: z.boolean(),
-    viewer: z.enum(["plain", "obsidian"]).optional(),
     initialized: z.string(),
 });

package/dist/lib/state-view.js

@@ -73,10 +73,10 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`);
     const workflow = getActiveCompiledWorkflow(dirPath, workflowId);
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
-    const zoneDocumentPaths = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
+    const outputDocumentPaths = (schema?.zones ?? [])
+        .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
         .map((zone) => zone.path);
-    const defaultNote = (schema?.zones ?? []).find((zone) => zone.kind === "file")?.path ?? null;
+    const defaultNote = (schema?.zones ?? []).find((zone) => zone.role === "output" && zone.kind === "file")?.path ?? null;
     return {
         kind: "compiled-view-spec",
         version: 2,
@@ -85,7 +85,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
         health_source: ".interf/runtime/health.json",
         state_source: ".interf/runtime/state.json",
         default_note: defaultNote,
-        graph_scope: zoneDocumentPaths,
+        graph_scope: outputDocumentPaths,
         cards: [
             { id: "source-total", label: "Source Files", metric: "source_total", format: "number" },
             { id: "stage-total", label: "Stages", metric: "stage_total", format: "number" },
@@ -94,8 +94,8 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
         sections: [
             { id: "status", type: "status", title: "Compile Status", path: ".interf/runtime/health.json" },
             { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
-            ...(zoneDocumentPaths.length > 0
-                ? [{ id: "outputs", type: "documents", title: "Compiled Outputs", paths: zoneDocumentPaths }]
+            ...(outputDocumentPaths.length > 0
+                ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
                 : []),
             { id: "workflow", type: "documents", title: "Workflow Docs", paths: ["workflow/README.md", ...workflow.stages.map((stage) => `workflow/compile/stages/${stage.skillDir}`)] },
         ],

package/dist/lib/state.d.ts

@@ -4,3 +4,4 @@ export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompi
 export { refreshCompiledArtifacts, } from "./state-artifacts.js";
 export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
 export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+export declare function initializeCompiledRuntimeState(dirPath: string): void;

package/dist/lib/state.js

@@ -3,3 +3,10 @@ export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompi
 export { refreshCompiledArtifacts, } from "./state-artifacts.js";
 export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
 export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+import { saveEmptyCompiledInventory, initCompiledState, saveState } from "./state-io.js";
+import { refreshCompiledArtifacts } from "./state-artifacts.js";
+export function initializeCompiledRuntimeState(dirPath) {
+    saveState(dirPath, initCompiledState());
+    saveEmptyCompiledInventory(dirPath);
+    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
+}

package/dist/lib/test-execution.js

@@ -203,7 +203,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Answer the truth-check question the same way you would answer a real user inside this compiled dataset.",
             "Prefer the workflow-declared compiled outputs before raw fallback.",
             "This sandbox is self-contained: the copied compiled dataset has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
-            "The project control plane is intentionally absent from this sandbox. Work only from this sandboxed compiled dataset and its embedded raw files.",
+            "The original project root is intentionally absent from this sandbox. Work only from this sandboxed compiled dataset and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
@@ -211,7 +211,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Use the local native `interf-query` skill available in this shell.",
             "There is no compiled dataset in this sandbox.",
             "Answer only from `raw/` inside this shell.",
-            "The project control plane is intentionally absent from this sandbox.",
+            "The original project root is intentionally absent from this sandbox.",
         ];
     return [
         ...header,

package/dist/lib/validate-compiled.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { discoverSourceFiles } from "./discovery.js";
-import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
 import { resolveSourceFolderPath } from "./interf.js";
 import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
@@ -9,6 +9,9 @@ import { loadState } from "./state.js";
 import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
 import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
 import { listFilesRecursive } from "./filesystem.js";
+function workflowSchemaPresent(dirPath) {
+    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
+}
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
     if (!existsSync(absolutePath))
@@ -84,7 +87,7 @@ export function validateCompiled(dirPath) {
         config_type_match: context.config.typeMatch(),
         workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
         workflow_valid: context.workflow !== null,
-        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
 }
@@ -96,7 +99,7 @@ export function validateCompiledStage(dirPath, stageId) {
         config_type_match: context.config.typeMatch(),
         workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
         workflow_valid: context.workflow !== null,
-        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     const errors = [];
@@ -111,9 +114,9 @@ export function validateCompiledStage(dirPath, stageId) {
     else if (!checks.workflow_valid)
         errors.push("Could not load the active workflow package.");
     if (!checks.schema_present)
-        errors.push("Missing .interf/workflow/compiled.schema.json.");
+        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
-        errors.push("Could not parse .interf/workflow/compiled.schema.json.");
+        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
     const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
     checks.stage_present = workflowStage !== null;
     if (!checks.stage_present) {
@@ -178,7 +181,7 @@ export function validateCompiledWorkflow(dirPath) {
         config_type_match: context.config.typeMatch(),
         workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
         workflow_valid: context.workflow !== null,
-        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     if (!context.workflow) {

package/dist/lib/validate.d.ts

@@ -5,7 +5,9 @@ export declare function readCompiledConfig(dirPath: string): {
     value: ReturnType<typeof readInterfConfig>;
     typeMatch(): boolean;
 };
-export declare function validateSynthFiles(files: string[]): {
+export declare function validateSynthFiles(files: string[], options?: {
+    requiredFrontmatterKeys?: string[];
+}): {
     invalid_frontmatter: number;
     short_abstracts: number;
 };