@interf/compiler 0.5.0 → 0.5.1

package/dist/lib/schema.d.ts

@@ -61,13 +61,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>>;
-    summarized: z.ZodOptional<z.ZodNumber>;
-    structured: z.ZodOptional<z.ZodNumber>;
-    shaped: z.ZodOptional<z.ZodNumber>;
-    compiled: z.ZodOptional<z.ZodNumber>;
-    last_summarize: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    last_structure: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    last_shape: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     inventory_complete: z.ZodOptional<z.ZodBoolean>;
     abstracts_read: z.ZodOptional<z.ZodNumber>;
     full_reads: z.ZodOptional<z.ZodNumber>;
@@ -75,7 +68,7 @@ export declare const CompiledStateSchema: z.ZodObject<{
     claim_count: z.ZodOptional<z.ZodNumber>;
     warning_count: z.ZodOptional<z.ZodNumber>;
     error_count: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const ViewSectionSchema: z.ZodObject<{
     id: z.ZodString;
     type: z.ZodEnum<{
@@ -242,7 +235,7 @@ export declare const RuntimeExecutorInfoSchema: z.ZodObject<{
     profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
-export declare const RuntimeStageInstructionsSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const RuntimeStageInstructionsSchema: z.ZodObject<{
     stage_skill_dir: z.ZodString;
     effective_mode: z.ZodEnum<{
         builtin: "builtin";
@@ -255,8 +248,8 @@ export declare const RuntimeStageInstructionsSchema: z.ZodPipe<z.ZodTransform<un
     }>>;
     local_docs: z.ZodArray<z.ZodString>;
     mode_sources: z.ZodArray<z.ZodString>;
-}, z.core.$strip>>;
-export declare const RuntimeStageAcceptanceSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+}, z.core.$strict>;
+export declare const RuntimeStageAcceptanceSchema: z.ZodObject<{
     artifacts_exist: z.ZodOptional<z.ZodArray<z.ZodString>>;
     stage_truthy: z.ZodOptional<z.ZodArray<z.ZodString>>;
     stage_equals_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -268,7 +261,7 @@ export declare const RuntimeStageAcceptanceSchema: z.ZodPipe<z.ZodTransform<unkn
     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>>>;
-}, z.core.$strip>>;
+}, z.core.$strict>;
 export declare const RuntimeStageContractSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-stage-contract">;
     version: z.ZodLiteral<1>;
@@ -301,7 +294,7 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>;
-    instructions: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    instructions: z.ZodObject<{
         stage_skill_dir: z.ZodString;
         effective_mode: z.ZodEnum<{
             builtin: "builtin";
@@ -314,9 +307,9 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         }>>;
         local_docs: z.ZodArray<z.ZodString>;
         mode_sources: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>;
     counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
-    acceptance: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    acceptance: z.ZodOptional<z.ZodObject<{
         artifacts_exist: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stage_truthy: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stage_equals_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -328,7 +321,7 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         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>>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strict>>;
     artifacts: z.ZodObject<{
         reads: z.ZodArray<z.ZodString>;
         writes: z.ZodArray<z.ZodString>;
@@ -395,26 +388,26 @@ export declare const RuntimeRunSchema: z.ZodObject<{
     exit_code: z.ZodNullable<z.ZodNumber>;
     error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export declare const CompiledInventoryEntrySchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const CompiledInventoryEntrySchema: z.ZodObject<{
     input_zone: z.ZodString;
     input_path: z.ZodString;
     output_zone: z.ZodString;
     output_path: z.ZodString;
     state: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>;
+}, z.core.$strict>;
 export declare const CompiledInventorySchema: z.ZodObject<{
     kind: z.ZodOptional<z.ZodLiteral<"compiled-runtime-ledger">>;
     version: z.ZodOptional<z.ZodNumber>;
     stage: z.ZodOptional<z.ZodString>;
-    entries: z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
         input_zone: z.ZodString;
         input_path: z.ZodString;
         output_zone: z.ZodString;
         output_path: z.ZodString;
         state: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strict>>;
     total: z.ZodNumber;
 }, z.core.$strip>;
 export declare const TestCaseExpectSchema: z.ZodObject<{
@@ -424,7 +417,7 @@ export declare const TestCaseExpectSchema: z.ZodObject<{
     min_words: z.ZodOptional<z.ZodNumber>;
     max_words: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
-export declare const TestCaseSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const TestCaseSchema: z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
     file: z.ZodOptional<z.ZodString>;
@@ -437,15 +430,15 @@ export declare const TestCaseSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>,
         max_words: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-export declare const TestSpecSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+}, z.core.$strip>;
+export declare const TestSpecSchema: z.ZodObject<{
     type: z.ZodEnum<{
         compiled: "compiled";
         raw: "raw";
     }>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    cases: z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    cases: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         question: z.ZodString;
         file: z.ZodOptional<z.ZodString>;
@@ -458,8 +451,8 @@ export declare const TestSpecSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>,
             max_words: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const SourceTruthCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
@@ -476,10 +469,10 @@ export declare const SourceTruthCheckSchema: z.ZodObject<{
 export declare const SourceCompiledMaxAttemptsSchema: z.ZodNumber;
 export declare const SourceCompiledMaxLoopsSchema: z.ZodNumber;
 export declare const DatasetNameSchema: z.ZodString;
-export declare const SourceDatasetConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+export declare const SourceDatasetConfigSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
-    path: z.ZodString;
+    path: z.ZodDefault<z.ZodString>;
     about: z.ZodOptional<z.ZodString>;
     workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
@@ -497,12 +490,12 @@ export declare const SourceDatasetConfigSchema: z.ZodPipe<z.ZodTransform<unknown
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-}, z.core.$strict>>;
-export declare const CompiledInterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+}, z.core.$strict>;
+export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -525,14 +518,14 @@ export declare const CompiledInterfConfigSchema: z.ZodPipe<z.ZodTransform<unknow
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodOptional<z.ZodString>;
+        dataset_path: z.ZodString;
     }, z.core.$strip>;
-}, z.core.$loose>>;
-export declare const InterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+}, z.core.$loose>;
+export declare const InterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -555,9 +548,9 @@ export declare const InterfConfigSchema: z.ZodPipe<z.ZodTransform<unknown, unkno
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodOptional<z.ZodString>;
+        dataset_path: z.ZodString;
     }, z.core.$strip>;
-}, z.core.$loose>>;
+}, z.core.$loose>;
 export declare const WorkflowImprovementLoopSummarySchema: z.ZodObject<{
     variation: z.ZodNumber;
     kind: z.ZodEnum<{
@@ -734,10 +727,10 @@ export type WorkflowPackageValidation = z.infer<typeof WorkflowPackageValidation
 export type WorkflowImprovementLoopRecord = z.infer<typeof WorkflowImprovementLoopRecordSchema>;
 export type WorkflowImprovementRunLedger = z.infer<typeof WorkflowImprovementRunLedgerSchema>;
 export declare const SourceFolderConfigSchema: z.ZodObject<{
-    datasets: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
-        path: z.ZodString;
+        path: z.ZodDefault<z.ZodString>;
         about: z.ZodOptional<z.ZodString>;
         workflow: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
@@ -755,7 +748,7 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             strictness: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
-    }, z.core.$strict>>>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const TestCheckResultSchema: z.ZodObject<{
     label: z.ZodString;

package/dist/lib/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { COMPILED_ZONE_KINDS, } from "./workflow-abi.js";
+import { COMPILED_ZONE_KINDS, } from "./workflow-primitives.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
 function isCompiledRelativePath(value) {
@@ -37,13 +37,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(),
-    summarized: z.number().optional(),
-    structured: z.number().optional(),
-    shaped: z.number().optional(),
-    compiled: z.number().optional(),
-    last_summarize: z.string().nullable().optional(),
-    last_structure: z.string().nullable().optional(),
-    last_shape: z.string().nullable().optional(),
     inventory_complete: z.boolean().optional(),
     abstracts_read: z.number().optional(),
     full_reads: z.number().optional(),
@@ -51,7 +44,7 @@ export const CompiledStateSchema = z.object({
     claim_count: z.number().optional(),
     warning_count: z.number().optional(),
     error_count: z.number().optional(),
-});
+}).strict();
 export const ViewSectionSchema = z.object({
     id: z.string(),
     type: z.enum(["status", "cards", "graph", "documents", "table"]),
@@ -149,36 +142,14 @@ export const RuntimeExecutorInfoSchema = z.object({
     profile: z.string().nullable().optional(),
     timeout_ms: z.number().nullable().optional(),
 });
-export const RuntimeStageInstructionsSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    const legacyBundledSkill = typeof raw.bundled_skill === "string" && raw.bundled_skill.length > 0
-        ? raw.bundled_skill.split(/[\\/]/).filter(Boolean).pop()
-        : undefined;
-    return {
-        ...raw,
-        stage_skill_dir: raw.stage_skill_dir ?? legacyBundledSkill,
-    };
-}, z.object({
+export const RuntimeStageInstructionsSchema = z.object({
     stage_skill_dir: z.string().regex(WorkflowIdPattern),
     effective_mode: z.enum(["builtin", "extend", "override"]),
     local_mode: z.enum(["extend", "override"]).nullable(),
     local_docs: z.array(z.string()),
     mode_sources: z.array(z.string()),
-}));
-export const RuntimeStageAcceptanceSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        stage_truthy: raw.stage_truthy ?? raw.state_truthy,
-        stage_equals_counts: raw.stage_equals_counts ?? raw.state_equals_counts,
-        stage_at_least: raw.stage_at_least ?? raw.state_at_least,
-        stage_at_least_counts: raw.stage_at_least_counts ?? raw.state_at_least_counts,
-    };
-}, z.object({
+}).strict();
+export const RuntimeStageAcceptanceSchema = z.object({
     artifacts_exist: z.array(z.string()).optional(),
     stage_truthy: z.array(z.string()).optional(),
     stage_equals_counts: z.record(z.string(), z.string()).optional(),
@@ -190,7 +161,7 @@ export const RuntimeStageAcceptanceSchema = z.preprocess((value) => {
     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(),
-}));
+}).strict();
 export const RuntimeStageContractSchema = z.object({
     kind: z.literal("interf-stage-contract"),
     version: z.literal(1),
@@ -258,36 +229,14 @@ export const RuntimeRunSchema = z.object({
     exit_code: z.number().nullable(),
     error: z.string().nullable(),
 });
-export const CompiledInventoryEntrySchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    if (typeof raw.source !== "string" && typeof raw.summary !== "string")
-        return raw;
-    return {
-        input_zone: raw.input_zone ?? "raw",
-        input_path: raw.input_path ?? raw.source,
-        output_zone: raw.output_zone ?? "summaries",
-        output_path: raw.output_path ?? raw.summary,
-        state: raw.state,
-        metadata: {
-            source_kind: raw.source_kind,
-            evidence_tier: raw.evidence_tier,
-            truth_mode: raw.truth_mode,
-            status: raw.status,
-            abstract: raw.abstract,
-            frontmatter_scanned: raw.frontmatter_scanned,
-            abstract_read: raw.abstract_read,
-        },
-    };
-}, z.object({
+export const CompiledInventoryEntrySchema = z.object({
     input_zone: WorkflowZoneIdSchema,
     input_path: z.string().min(1),
     output_zone: WorkflowZoneIdSchema,
     output_path: z.string().min(1),
     state: z.string().min(1).optional(),
     metadata: JsonRecordSchema.optional(),
-}));
+}).strict();
 export const CompiledInventorySchema = z.object({
     kind: z.literal("compiled-runtime-ledger").optional(),
     version: z.number().int().min(1).optional(),
@@ -327,32 +276,14 @@ const TestCaseCoreSchema = z.object({
         });
     }
 });
-export const TestCaseSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        question: raw.question ?? raw.check ?? raw.ask,
-        answer: raw.answer ?? raw.expected ?? raw.pass_when,
-    };
-}, TestCaseCoreSchema);
+export const TestCaseSchema = TestCaseCoreSchema;
 const TestSpecCoreSchema = z.object({
     type: TestTargetTypeSchema,
     name: z.string().min(1),
     description: z.string().min(1).optional(),
     cases: z.array(TestCaseSchema).min(1),
 });
-export const TestSpecSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        type: raw.type ?? "compiled",
-        cases: raw.cases ?? raw.checks,
-    };
-}, TestSpecCoreSchema);
+export const TestSpecSchema = TestSpecCoreSchema;
 export const SourceTruthCheckSchema = z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
     question: z.string().min(1),
@@ -376,39 +307,21 @@ export const DatasetNameSchema = z
     .string()
     .regex(DatasetNamePattern, "Dataset names must use lowercase letters, numbers, and dashes only.")
     .refine((value) => !RESERVED_DATASET_NAMES.has(value), "Dataset name is reserved.");
-export const SourceDatasetConfigSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        path: raw.path ?? ".",
-    };
-}, z.object({
+export const SourceDatasetConfigSchema = z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
     name: DatasetNameSchema,
-    path: z.string().min(1),
+    path: z.string().min(1).default("."),
     about: z.string().min(1).optional(),
     workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceTruthCheckSchema).default([]),
-}).strict());
-export const CompiledInterfConfigSchema = z.preprocess((value) => {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const raw = value;
-    return {
-        ...raw,
-        type: "compiled",
-        source: raw.source ?? { path: "./raw" },
-        checks: raw.checks ?? [],
-    };
-}, z.object({
+}).strict();
+export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
     name: DatasetNameSchema,
     about: z.string().optional(),
-    workflow: WorkflowIdSchema.optional(),
+    workflow: WorkflowIdSchema,
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceTruthCheckSchema).default([]),
@@ -419,9 +332,9 @@ export const CompiledInterfConfigSchema = z.preprocess((value) => {
     source: z.object({
         path: z.string(),
         control_path: z.string().optional(),
-        dataset_path: z.string().optional(),
+        dataset_path: z.string(),
     }),
-}).passthrough());
+}).passthrough();
 export const InterfConfigSchema = CompiledInterfConfigSchema;
 export const WorkflowImprovementLoopSummarySchema = z.object({
     variation: z.number().int().min(1),

package/dist/lib/source-config.js

@@ -83,19 +83,22 @@ function toWritableSourceProjectConfig(config) {
     const datasets = config?.datasets ?? [];
     if (datasets.length > 0) {
         return {
-            datasets: datasets.map((dataset) => ({
-                name: dataset.name,
-                ...(dataset.path && dataset.path !== "." ? { path: dataset.path } : {}),
-                ...(dataset.about ? { about: dataset.about } : {}),
-                ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
-                ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
-                ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
-                checks: dataset.checks,
-            })),
+            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
         };
     }
     return {};
 }
+function toWritableSourceDatasetConfig(dataset) {
+    return {
+        name: dataset.name,
+        ...(dataset.path && dataset.path !== "." ? { path: dataset.path } : {}),
+        ...(dataset.about ? { about: dataset.about } : {}),
+        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
+        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
+        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
+        checks: dataset.checks,
+    };
+}
 export function saveSourceFolderConfig(sourcePath, config) {
     writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
 }
@@ -104,21 +107,17 @@ export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
     const currentDataset = findSourceDatasetConfig(existing, datasetName);
     const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
     const currentChecks = currentDataset?.checks ?? [];
+    const nextDataset = {
+        ...toWritableSourceDatasetConfig(currentDataset ?? {
+            name: datasetName,
+            path: ".",
+            checks: [],
+        }),
+        checks: [...currentChecks, ...checks],
+    };
     saveSourceFolderConfig(sourcePath, {
         datasets: [
-            {
-                name: datasetName,
-                path: currentDataset?.path ?? ".",
-                ...(currentDataset?.about ? { about: currentDataset.about } : {}),
-                ...(currentDataset?.workflow ? { workflow: currentDataset.workflow } : {}),
-                ...(typeof currentDataset?.max_attempts === "number"
-                    ? { max_attempts: currentDataset.max_attempts }
-                    : {}),
-                ...(typeof currentDataset?.max_loops === "number"
-                    ? { max_loops: currentDataset.max_loops }
-                    : {}),
-                checks: [...currentChecks, ...checks],
-            },
+            nextDataset,
             ...otherDatasets,
         ],
     });

package/dist/lib/state-health.js

@@ -7,7 +7,7 @@ import { loadState } from "./state-io.js";
 import { validateCompiled, validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
 import { listFilesRecursive } from "./filesystem.js";
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = join(compiledPath, zonePath);
@@ -26,7 +26,9 @@ export function computeCompiledHealth(dirPath) {
     const state = loadState(dirPath);
     const validation = validateCompiled(dirPath);
     const activeRun = loadRuntimeRun(dirPath);
-    const workflowId = config ? resolveCompiledWorkflowFromConfig(config) : null;
+    const workflowId = config
+        ? resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`)
+        : null;
     let workflow = null;
     if (workflowId) {
         try {

package/dist/lib/state-io.js

@@ -1,17 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { warnInterf } from "./logger.js";
 import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { CompiledHealthSchema, CompiledInventorySchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./schema.js";
-import { compiledInventoryEntryCount, compiledInventoryTotal, emptyCompiledInventory, } from "./runtime-inventory.js";
+import { CompiledHealthSchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./schema.js";
+import { emptyCompiledInventory, } from "./runtime-inventory.js";
 import { healthPath, rawSnapshotPath, statePath, viewSpecPath } from "./state-paths.js";
 import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
-const NORMALIZABLE_RUNTIME_TIMESTAMP_FIELDS = [
-    "last_add",
-    "last_summarize",
-    "last_structure",
-    "last_shape",
-    "last_compile",
-];
 export function loadState(dirPath) {
     const path = statePath(dirPath);
     if (!existsSync(path))
@@ -21,18 +14,8 @@ export function loadState(dirPath) {
         return null;
     const parsed = CompiledStateSchema.safeParse(raw);
     if (parsed.success) {
-        const healed = healParsedRuntimeState(dirPath, parsed.data);
-        if (healed !== null) {
-            saveState(dirPath, healed);
-            return healed;
-        }
         return parsed.data;
     }
-    const normalized = normalizeRuntimeState(raw);
-    if (normalized !== null) {
-        saveState(dirPath, normalized);
-        return normalized;
-    }
     warnInterf(`Warning: failed to validate runtime state at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
     return null;
 }
@@ -81,97 +64,6 @@ export function initCompiledState() {
         error_count: 0,
     };
 }
-function normalizeRuntimeState(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    const normalized = { ...raw };
-    let changed = false;
-    for (const field of NORMALIZABLE_RUNTIME_TIMESTAMP_FIELDS) {
-        const timestamp = normalizeRuntimeTimestampField(normalized[field]);
-        if (timestamp !== undefined && timestamp !== normalized[field]) {
-            normalized[field] = timestamp;
-            changed = true;
-        }
-    }
-    if (!changed)
-        return null;
-    const parsed = CompiledStateSchema.safeParse(normalized);
-    return parsed.success ? parsed.data : null;
-}
-function healParsedRuntimeState(dirPath, state) {
-    const hasLegacyStageFields = (typeof state.last_summarize === "string" && state.last_summarize.length > 0) ||
-        (typeof state.last_structure === "string" && state.last_structure.length > 0) ||
-        (typeof state.last_shape === "string" && state.last_shape.length > 0);
-    const hasStageMap = Boolean(state.stages) &&
-        typeof state.stages === "object" &&
-        Object.keys(state.stages ?? {}).length > 0;
-    if (state.version >= 2 && (hasStageMap || !hasLegacyStageFields))
-        return null;
-    const next = {
-        ...initCompiledState(),
-        ...state,
-        stages: { ...(state.stages ?? {}) },
-    };
-    if (typeof state.last_summarize === "string" && state.last_summarize.length > 0) {
-        next.stages.summarize = {
-            contract_type: "compiled-file-evidence",
-            status: "succeeded",
-            finished_at: state.last_summarize,
-            counts: {
-                summarized: state.summarized ?? 0,
-                expected_summary_total: state.summarized ?? 0,
-            },
-            zone_counts: {
-                summaries: state.summarized ?? 0,
-            },
-        };
-    }
-    if (typeof state.last_structure === "string" && state.last_structure.length > 0) {
-        next.stages.structure = {
-            contract_type: "compiled-knowledge-structure",
-            status: "succeeded",
-            finished_at: state.last_structure,
-            counts: {
-                summary_total: state.structured ?? state.summarized ?? 0,
-            },
-        };
-    }
-    if (typeof state.last_shape === "string" && state.last_shape.length > 0) {
-        next.stages.shape = {
-            contract_type: "compiled-query-shape",
-            status: "succeeded",
-            finished_at: state.last_shape,
-            counts: {
-                summary_total: state.shaped ?? state.summarized ?? 0,
-            },
-        };
-    }
-    const inventoryPath = compiledRuntimeInventoryPath(dirPath);
-    if (existsSync(inventoryPath)) {
-        const inventory = readJsonFileWithSchema(inventoryPath, "compiled inventory", CompiledInventorySchema);
-        const inventoryTotal = compiledInventoryTotal(inventory);
-        if (inventory &&
-            inventoryTotal === (state.summarized ?? 0) &&
-            compiledInventoryEntryCount(inventory) === (state.summarized ?? 0)) {
-            next.inventory_complete = true;
-        }
-    }
-    return next;
-}
-function normalizeRuntimeTimestampField(value) {
-    if (typeof value === "string" || value === null)
-        return value;
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    for (const key of ["generated_at", "finished_at", "updated_at", "started_at", "timestamp"]) {
-        const candidate = record[key];
-        if (typeof candidate === "string" && candidate.length > 0) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
 function loadViewSpec(filePath, schema) {
     try {
         const raw = JSON.parse(readFileSync(filePath, "utf8"));

package/dist/lib/state-view.js

@@ -6,7 +6,7 @@ import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { rawSnapshotPath } from "./state-paths.js";
 import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
 export function ensureCompiledViewSpec(dirPath) {
     const existing = loadCompiledViewSpec(dirPath);
     const now = new Date().toISOString();
@@ -70,7 +70,7 @@ export function normalizeCompiledViewSpec(existing, defaults) {
 }
 function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     const config = readInterfConfig(dirPath);
-    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`);
     const workflow = getActiveCompiledWorkflow(dirPath, workflowId);
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
     const zoneDocumentPaths = (schema?.zones ?? [])