@interf/compiler 0.5.0 → 0.5.1

package/README.md

@@ -31,7 +31,6 @@ A maintained public test run in this repo uses checks like this:
   "datasets": [
     {
       "name": "cbre-chart-sanity",
-      "path": ".",
       "about": "Bristol historical take-up and availability chart lookup.",
       "checks": [
         {
@@ -65,7 +64,7 @@ A recent maintained internal run on the CBRE chart sanity dataset produced:
 
 Use `interf test` on your own dataset to measure files as-is versus the compiled dataset on the same checks.
 
-Each dataset keeps one latest comparison under `interf/<dataset>/tests/latest.json`. Target-specific runs stay under `interf/<dataset>/tests/file-as-is/runs/` and `interf/<dataset>/tests/compiled/runs/`.
+Each dataset keeps one latest comparison under `interf/tests/<dataset>/latest.json`. Target-specific runs stay under `interf/tests/<dataset>/file-as-is/runs/` and `interf/tests/<dataset>/compiled/runs/`.
 
 ## Quick Start
 
@@ -104,8 +103,8 @@ After setup, the project root stays simple:
 
 - `interf.json` at the root holds your saved dataset entries and truth checks
 - `interf/` is created only when Interf has artifacts to save
-- `interf/<dataset>/compiled/` is the compiled dataset
-- `interf/<dataset>/tests/` is the saved comparison history for that dataset
+- `interf/<dataset>/` is the compiled dataset
+- `interf/tests/<dataset>/` is the saved comparison history for that dataset
 
 A compiled dataset is a folder on top of your dataset. It includes:
 
@@ -143,7 +142,7 @@ interf doctor
 
 ## What `interf test` Does
 
-By default, if a compiled dataset exists, it runs both sides and saves one latest comparison under `interf/<dataset>/tests/latest.json`.
+By default, if a compiled dataset exists, it runs both sides and saves one latest comparison under `interf/tests/<dataset>/latest.json`.
 
 You can also select one or more detected local agents in the CLI and compare them in one table.
 
@@ -153,7 +152,7 @@ For live runs:
 - compiled-dataset tests execute from a copied compiled sandbox with embedded sanitized `raw/`
 - both sides use the same saved truth checks from `interf.json`
 - neither sandbox includes the project control plane
-- detailed dataset-visible runs are kept under `interf/<dataset>/tests/file-as-is/runs/` and `interf/<dataset>/tests/compiled/runs/`
+- detailed dataset-visible runs are kept under `interf/tests/<dataset>/file-as-is/runs/` and `interf/tests/<dataset>/compiled/runs/`
 - local detailed target runs and preserved sandboxes stay under `.interf/tests/targets/`
 - failed test sandboxes are kept automatically
 - `interf test --keep-sandboxes` keeps every sandbox, even successful ones
@@ -176,7 +175,7 @@ Add another only when you want a different dataset folder, focus, or set of trut
 Why add another:
 
 - it keeps a separate set of truth checks
-- it gives that dataset its own compiled output under `interf/<dataset>/compiled/`
+- it gives that dataset its own compiled output under `interf/<dataset>/`
 - it lets you test that dataset separately
 
 ## Advanced: Compile Loops

package/dist/commands/compile-controller.js

@@ -4,7 +4,7 @@ import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../lib/interf.js";
 import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
-import { formatActiveCompiledWorkflowStageStep, resolveCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
 import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
 import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
@@ -12,7 +12,7 @@ import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
 import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
-    const workflowId = resolveCompiledWorkflowFromConfig(readInterfConfig(compiledPath));
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
     const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, workflowId, failedStage ?? "compile");
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
@@ -362,7 +362,7 @@ export async function runConfiguredCompiledCompile(options) {
                 const improvement = await runWorkflowImprovementLoop({
                     executor: options.executor,
                     compiledPath: options.compiledPath,
-                    workflowId: resolveCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath)),
+                    workflowId: resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
                     compiledConfig,
                     runId: improvementRunId,
                     loopIndex,

package/dist/commands/test-flow.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createRawTestTarget, createCompiledTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "../lib/test.js";
 import { buildTestSpecFromSourceFolderConfig, buildTestSpecFromCompiledDatasetConfig, resolveSourceDatasetPath, } from "../lib/source-config.js";
-import { datasetArtifactRoot, datasetLatestTestStatePath, datasetLatestTestSummaryPath, datasetTestRunsRoot, } from "../lib/project-paths.js";
+import { datasetLatestTestStatePath, datasetLatestTestSummaryPath, normalizeDatasetTestRunId, datasetTestRunPath, datasetTestRunsRoot, datasetTestsRoot, } from "../lib/project-paths.js";
 import { testRootForCompiled } from "../lib/compiled-paths.js";
 import { readJsonFileWithSchema } from "../lib/parse.js";
 import { TestRunComparisonSchema } from "../lib/schema.js";
@@ -29,21 +29,10 @@ function summarizeSavedTestOutcome(label, outcome) {
         target: outcome.target,
     };
 }
-function normalizeTestRunId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-function datasetRunPathForTarget(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
-    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeTestRunId(runSuffix)}` : ""}.json`);
-}
 function writeDatasetTargetRun(options) {
     const dirPath = datasetTestRunsRoot(options.projectPath, options.datasetName, options.target);
     mkdirSync(dirPath, { recursive: true });
-    const runPath = datasetRunPathForTarget(options.projectPath, options.datasetName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    const runPath = datasetTestRunPath(options.projectPath, options.datasetName, options.target, options.generatedAt, options.runId, options.runSuffix);
     writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
     return runPath;
 }
@@ -354,7 +343,7 @@ export async function runSavedRawTest(options) {
     const run = await runTargetTestsAuto(datasetSourcePath, spec, [target], {
         executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: datasetArtifactRoot(options.sourcePath, options.datasetConfig.name),
+        artifactRootPath: datasetTestsRoot(options.sourcePath, options.datasetConfig.name),
     });
     const result = run.results[0];
     if (!result)
@@ -364,7 +353,7 @@ export async function runSavedRawTest(options) {
         datasetName: options.datasetConfig.name,
         target: "file-as-is",
         generatedAt: run.generated_at,
-        runId: normalizeTestRunId(spec.id),
+        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });
@@ -413,7 +402,7 @@ export async function runSavedCompiledTest(options) {
         datasetName: options.datasetConfig.name,
         target: "compiled",
         generatedAt: run.generated_at,
-        runId: normalizeTestRunId(spec.id),
+        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });

package/dist/lib/agent-shells.js

@@ -70,7 +70,7 @@ export function renderCompiledAgents(compiledPath, name, workflowId, about, opti
         "- Compiled output zones are declared in `.interf/workflow/compiled.schema.json`.",
         ...zoneLines,
         "- `.interf/runtime/` holds CLI-owned runtime artifacts.",
-        "- `.interf/tests/` holds saved raw-vs-compiled test comparisons for this compiled dataset.",
+        "- `.interf/tests/` mirrors the latest dataset-level comparison and keeps detailed target runs plus preserved sandboxes.",
         "- `.interf/tests/targets/` holds detailed raw and compiled target runs plus preserved test sandboxes.",
         "",
         "## Manual query rules",

package/dist/lib/{workflow-abi.d.ts → builtin-compiled-workflow.d.ts}

@@ -1,7 +1,6 @@
+import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "./workflow-primitives.js";
 export declare const COMPILED_CONTRACT_TYPES: readonly ["compiled-file-evidence", "compiled-knowledge-structure", "compiled-query-shape"];
 export type CompiledContractType = typeof COMPILED_CONTRACT_TYPES[number];
-export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
-export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];
 export declare const COMPILED_CONTRACT_FAMILY_METADATA: {
     readonly "compiled-file-evidence": {
         readonly order: 0;
@@ -127,3 +126,4 @@ export declare function requiredCompiledZoneOwners<TStage extends {
     id: string;
     writes: readonly string[];
 }>(stages: readonly TStage[], zoneId: BuiltinCompiledZoneId): string[];
+export { COMPILED_ZONE_KINDS };

package/dist/lib/{workflow-abi.js → builtin-compiled-workflow.js}

@@ -1,13 +1,9 @@
+import { COMPILED_ZONE_KINDS } from "./workflow-primitives.js";
 export const COMPILED_CONTRACT_TYPES = [
     "compiled-file-evidence",
     "compiled-knowledge-structure",
     "compiled-query-shape",
 ];
-export const COMPILED_ZONE_KINDS = [
-    "directory",
-    "file",
-    "runtime",
-];
 export const COMPILED_CONTRACT_FAMILY_METADATA = {
     "compiled-file-evidence": {
         order: 0,
@@ -154,3 +150,4 @@ export function requiredCompiledZoneOwners(stages, zoneId) {
         .filter((stage) => stage.writes.includes(zoneId))
         .map((stage) => stage.id)));
 }
+export { COMPILED_ZONE_KINDS };

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),

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;

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");
 }
@@ -91,14 +85,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-schema.d.ts

@@ -1,10 +1,10 @@
-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 { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
 export declare const COMPILED_SCHEMA_FILE = "compiled.schema.json";
 export declare function compiledSchemaFilePath(rootPath: string): string;
 export declare function compiledSchemaRelativePath(): string;

package/dist/lib/compiled-schema.js

@@ -1,9 +1,9 @@
 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 { 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 { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
 export const COMPILED_SCHEMA_FILE = "compiled.schema.json";
 const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
 export function compiledSchemaFilePath(rootPath) {

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.d.ts

@@ -1,4 +1,4 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareCompiledLayout, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
 export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";

package/dist/lib/interf.js

@@ -1,4 +1,4 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareCompiledLayout, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
 export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";

package/dist/lib/local-workflows.js

@@ -6,7 +6,7 @@ import { isMarkdownFile } from "./util.js";
 import { listFilesRecursive } from "./filesystem.js";
 import { warnInterf } from "./logger.js";
 import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { listBuiltinCompiledZoneSpecs, } from "./workflow-abi.js";
+import { listBuiltinCompiledZoneSpecs, } from "./builtin-compiled-workflow.js";
 import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowStageZoneAccessSchema, WorkflowCompiledSchemaSchema, WorkflowIdPattern, } from "./schema.js";
 import { writeCompiledSchemaFile, compiledSchemaFilePath } from "./compiled-schema.js";
 const LocalWorkflowStageDefinitionSchema = z.object({

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

@@ -1,13 +1,11 @@
 export declare const PROJECT_INTERF_DIR = "interf";
-export declare const PROJECT_WORKFLOW_DIR = "workflows";
-export declare const PROJECT_COMPILED_DIR = "compiled";
 export declare const PROJECT_TESTS_DIR = "tests";
 export declare function projectInterfRoot(projectPath: string): string;
-export declare function projectWorkflowRoot(projectPath: string): string;
-export declare function datasetArtifactRoot(projectPath: string, datasetName: string): string;
 export declare function compiledCompiledPathForDataset(projectPath: string, datasetName: string): string;
 export declare function datasetTestsRoot(projectPath: string, datasetName: string): string;
 export type DatasetTestTargetLabel = "file-as-is" | "compiled";
 export declare function datasetTestRunsRoot(projectPath: string, datasetName: string, target: DatasetTestTargetLabel): string;
 export declare function datasetLatestTestStatePath(projectPath: string, datasetName: string): string;
 export declare function datasetLatestTestSummaryPath(projectPath: string, datasetName: string): string;
+export declare function normalizeDatasetTestRunId(input: string): string;
+export declare function datasetTestRunPath(projectPath: string, datasetName: string, target: DatasetTestTargetLabel, generatedAt: string, runId: string, runSuffix?: string | null): string;

package/dist/lib/project-paths.js

@@ -1,22 +1,14 @@
 import { join } from "node:path";
 export const PROJECT_INTERF_DIR = "interf";
-export const PROJECT_WORKFLOW_DIR = "workflows";
-export const PROJECT_COMPILED_DIR = "compiled";
 export const PROJECT_TESTS_DIR = "tests";
 export function projectInterfRoot(projectPath) {
     return join(projectPath, PROJECT_INTERF_DIR);
 }
-export function projectWorkflowRoot(projectPath) {
-    return join(projectInterfRoot(projectPath), PROJECT_WORKFLOW_DIR);
-}
-export function datasetArtifactRoot(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), datasetName);
-}
 export function compiledCompiledPathForDataset(projectPath, datasetName) {
-    return join(datasetArtifactRoot(projectPath, datasetName), PROJECT_COMPILED_DIR);
+    return join(projectInterfRoot(projectPath), datasetName);
 }
 export function datasetTestsRoot(projectPath, datasetName) {
-    return join(datasetArtifactRoot(projectPath, datasetName), PROJECT_TESTS_DIR);
+    return join(projectInterfRoot(projectPath), PROJECT_TESTS_DIR, datasetName);
 }
 export function datasetTestRunsRoot(projectPath, datasetName, target) {
     return join(datasetTestsRoot(projectPath, datasetName), target, "runs");
@@ -27,3 +19,14 @@ export function datasetLatestTestStatePath(projectPath, datasetName) {
 export function datasetLatestTestSummaryPath(projectPath, datasetName) {
     return join(datasetTestsRoot(projectPath, datasetName), "latest.md");
 }
+export function normalizeDatasetTestRunId(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+export function datasetTestRunPath(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
+    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeDatasetTestRunId(runSuffix)}` : ""}.json`);
+}

package/dist/lib/runtime-prompt.js

@@ -1,7 +1,5 @@
 export function buildStagePrompt(instructions, contractPath, statusLines) {
-    const stageSkillDir = instructions.stage_skill_dir ||
-        (instructions.bundled_skill?.split(/[\\/]/).filter(Boolean).pop()) ||
-        "stage";
+    const stageSkillDir = instructions.stage_skill_dir || "stage";
     const modeNotes = instructions.effective_mode === "override"
         ? [
             "Local stage instruction docs are authoritative for this run.",

package/dist/lib/runtime-reconcile.js

@@ -7,7 +7,7 @@ import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
 import { compiledRuntimeRoot } from "./compiled-paths.js";
-import { isOutputMarkdownFile } from "./validate.js";
+import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);
     if (!run)
@@ -49,14 +49,7 @@ function summaryAbstract(content) {
     const parsed = parseJsonFrontmatter(content);
     if (!parsed)
         return null;
-    const frontmatterAbstract = typeof parsed.frontmatter.abstract === "string"
-        ? parsed.frontmatter.abstract.trim()
-        : "";
-    if (frontmatterAbstract.length > 0)
-        return frontmatterAbstract;
-    const match = parsed.body.match(/^## Abstract\s+([\s\S]*?)(?:\n## |\n# |$)/m);
-    const bodyAbstract = match?.[1]?.trim() ?? "";
-    return bodyAbstract.length > 0 ? bodyAbstract : null;
+    return extractSynthAbstract(parsed.frontmatter, parsed.body);
 }
 function buildStageInventoryEntries(dirPath, stage) {
     const schema = readCompiledSchemaFile(join(dirPath, ".interf", "workflow"));
@@ -81,11 +74,7 @@ function buildStageInventoryEntries(dirPath, stage) {
             return null;
         const inputPath = typeof parsed.frontmatter.source === "string"
             ? parsed.frontmatter.source.trim()
-            : typeof parsed.frontmatter.source_file === "string"
-                ? parsed.frontmatter.source_file.trim()
-                : typeof parsed.frontmatter.raw === "string"
-                    ? parsed.frontmatter.raw.trim()
-                    : "";
+            : "";
         if (inputPath.length === 0)
             return null;
         const abstract = summaryAbstract(content);

package/dist/lib/runtime-runs.js

@@ -16,7 +16,8 @@ export function loadRuntimeRun(dirPath) {
         const parsed = RuntimeRunSchema.safeParse(raw);
         if (parsed.success)
             return parsed.data;
-        return normalizeRuntimeRunRecord(raw);
+        warnInterf(`Warning: failed to validate runtime run at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
     }
     catch (error) {
         warnInterf(`Warning: failed to read runtime run at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -221,92 +222,6 @@ function writeRuntimeRunPrompt(dirPath, runId, prompt) {
 function createRunId() {
     return `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
-function normalizeRuntimeRunRecord(raw) {
-    if (!raw || typeof raw !== "object")
-        return null;
-    const record = raw;
-    const executor = record.executor;
-    if (record.kind !== "interf-run" ||
-        typeof record.version !== "number" ||
-        typeof record.run_id !== "string" ||
-        typeof record.target_name !== "string" ||
-        typeof record.workflow !== "string" ||
-        typeof record.stage !== "string" ||
-        !executor ||
-        typeof executor !== "object" ||
-        typeof record.started_at !== "string" ||
-        typeof record.updated_at !== "string" ||
-        typeof record.contract_path !== "string" ||
-        typeof record.summary !== "string") {
-        return null;
-    }
-    const normalizedTargetType = inferRuntimeTargetType(record.target_type);
-    if (!normalizedTargetType)
-        return null;
-    const executorRecord = executor;
-    const normalized = {
-        kind: "interf-run",
-        version: record.version,
-        run_id: record.run_id,
-        target_type: normalizedTargetType,
-        target_name: record.target_name,
-        workflow: record.workflow,
-        stage: record.stage,
-        stage_label: typeof record.stage_label === "string" ? record.stage_label : record.stage,
-        contract_type: typeof record.contract_type === "string"
-            ? inferRuntimeContractType(record.contract_type, record.stage)
-            : inferRuntimeContractType(record.target_type, record.stage),
-        status: normalizeRuntimeRunStatus(record),
-        executor: {
-            kind: executorRecord.kind,
-            name: executorRecord.name,
-            display_name: executorRecord.display_name,
-            command: typeof executorRecord.command === "string" ? executorRecord.command : null,
-            model: typeof executorRecord.model === "string" ? executorRecord.model : null,
-            effort: typeof executorRecord.effort === "string" ? executorRecord.effort : null,
-            profile: typeof executorRecord.profile === "string" ? executorRecord.profile : null,
-            timeout_ms: typeof executorRecord.timeout_ms === "number" ? executorRecord.timeout_ms : null,
-        },
-        started_at: record.started_at,
-        updated_at: record.updated_at,
-        finished_at: typeof record.finished_at === "string" ? record.finished_at : null,
-        contract_path: record.contract_path,
-        execution_path: typeof record.execution_path === "string" ? record.execution_path : undefined,
-        counts: record.counts && typeof record.counts === "object" ? record.counts : {},
-        output_artifacts: Array.isArray(record.output_artifacts) ? record.output_artifacts : [],
-        logs: record.logs && typeof record.logs === "object" ? record.logs : undefined,
-        summary: record.summary,
-        exit_code: typeof record.exit_code === "number" ? record.exit_code : null,
-        error: typeof record.error === "string" ? record.error : null,
-    };
-    const parsed = RuntimeRunSchema.safeParse(normalized);
-    return parsed.success ? parsed.data : null;
-}
-function normalizeRuntimeRunStatus(record) {
-    const status = record.status;
-    if (status === "running" || status === "succeeded" || status === "failed")
-        return status;
-    if (typeof record.exit_code === "number")
-        return record.exit_code === 0 ? "succeeded" : "failed";
-    if (typeof record.error === "string" && record.error.length > 0)
-        return "failed";
-    return "running";
-}
-function inferRuntimeTargetType(targetType) {
-    if (targetType === "compiled") {
-        return "compiled";
-    }
-    return null;
-}
-function inferRuntimeContractType(contractType, stage) {
-    if (typeof contractType === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(contractType)) {
-        return contractType;
-    }
-    if (typeof stage === "string" && /^[a-z0-9][a-z0-9-]{0,79}$/.test(stage)) {
-        return stage;
-    }
-    return "compiled";
-}
 function replaceOrAppendRunHistoryEntry(dirPath, run) {
     const historyPath = runHistoryPath(dirPath);
     if (!existsSync(historyPath)) {