@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{compiler → engine/compile}/lib/schema.js

@@ -1,7 +1,12 @@
 import { z } from "zod";
-import { COMPILED_ZONE_KINDS, } from "../method-primitives.js";
-import { RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
-export { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
+import { COMPILED_ARTIFACT_KINDS, } from "../method-primitives.js";
+import { ArtifactIdSchema, ArtifactSchema, CheckSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, InterfIdPattern, MethodIdSchema, } from "../../../contracts/lib/schema.js";
+// `ArtifactSchema` is used internally below in `MethodSchemaSchema`'s
+// `artifacts[]` field. The other Artifact* schemas/types are NOT
+// re-exported through this module — callers import them directly
+// from `contracts/lib/schema.js`. The 0.17 PR cross-check pruned
+// re-exports that had zero consumers.
+export { GateStatusSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../../contracts/lib/schema.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
 function isCompiledRelativePath(value) {
@@ -13,9 +18,9 @@ function isCompiledRelativePath(value) {
         .split(/[\\/]+/)
         .every((segment) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
 }
-export const MethodZoneIdSchema = z.string().regex(InterfIdPattern);
-export const MethodCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
-export const MethodZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
+export const MethodArtifactIdSchema = z.string().regex(InterfIdPattern);
+export const MethodCompiledArtifactKindSchema = z.enum(COMPILED_ARTIFACT_KINDS);
+export const MethodArtifactRoleSchema = z.enum(["input", "working", "output", "runtime"]);
 export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
 export const CompiledStageStateSchema = z.object({
     contract_type: RuntimeContractTypeSchema.optional(),
@@ -23,7 +28,7 @@ export const CompiledStageStateSchema = z.object({
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
     counts: z.record(z.string(), z.number()).optional(),
-    zone_counts: z.record(z.string(), z.number()).optional(),
+    artifact_counts: z.record(z.string(), z.number()).optional(),
     artifacts: z.array(z.string()).optional(),
     summary: z.string().nullable().optional(),
     run_id: z.string().nullable().optional(),
@@ -81,36 +86,37 @@ export const MethodPurposeSchema = z.object({
     label: z.string().min(1),
     task_hint: z.string().min(1),
 }).strict();
-export const MethodZoneSchema = z.object({
-    id: MethodZoneIdSchema,
-    role: MethodZoneRoleSchema,
+export const MethodCompiledArtifactProjectionSchema = z.object({
+    id: MethodArtifactIdSchema,
+    role: MethodArtifactRoleSchema,
     path: z.string().min(1).refine(isCompiledRelativePath, {
-        message: "Zone paths must stay inside the compiled root",
+        message: "Artifact paths must stay inside the compiled root",
     }),
-    kind: MethodCompiledZoneKindSchema,
+    kind: MethodCompiledArtifactKindSchema,
     required: z.boolean(),
     owned_by: z.array(z.string().regex(InterfIdPattern)),
     description: z.string().min(1),
 });
-export const MethodCompiledZoneSchema = MethodZoneSchema;
-// Persisted schema for the method-defined context interface that one
+export const MethodCompiledArtifactSchema = MethodCompiledArtifactProjectionSchema;
+// Persisted schema for the method-defined artifact interface that one
 // portable context must implement on disk.
 export const MethodSchemaSchema = z.object({
     kind: z.literal("method-schema"),
     version: z.literal(1),
     target_type: z.literal("compiled"),
     label: z.string().min(1),
-    zones: z.array(MethodZoneSchema).min(1),
-});
+    artifacts: z.array(ArtifactSchema).min(1),
+}).strict();
 export const MethodCompiledSchemaSchema = MethodSchemaSchema;
 export const MethodCompilerApiSchema = z.object({
     kind: z.literal("compiled"),
     version: z.literal(1),
 });
-export const MethodStageZoneAccessSchema = z.array(MethodZoneIdSchema).min(1);
-export const ExecutionShellZoneMountSchema = z.object({
-    zone_id: MethodZoneIdSchema,
-    compiled_path: z.string(),
+export const MethodStageArtifactReadAccessSchema = z.array(ArtifactIdSchema);
+export const MethodStageArtifactWriteAccessSchema = z.array(ArtifactIdSchema).min(1);
+export const ExecutionShellArtifactMountSchema = z.object({
+    artifact_id: ArtifactIdSchema,
+    artifact_path: z.string(),
     shell_root_path: z.string(),
     input_mount_path: z.string().nullable(),
     output_mount_path: z.string().nullable(),
@@ -120,8 +126,8 @@ export const ExecutionShellPathsSchema = z.object({
     version: z.literal(1),
     method: MethodIdSchema,
     stage: RuntimeStageSchema,
-    reads: z.array(ExecutionShellZoneMountSchema),
-    writes: z.array(ExecutionShellZoneMountSchema),
+    reads: z.array(ExecutionShellArtifactMountSchema),
+    writes: z.array(ExecutionShellArtifactMountSchema),
 });
 export const RuntimeStageInstructionsSchema = z.object({
     stage_skill_dir: z.string().regex(InterfIdPattern),
@@ -130,20 +136,6 @@ export const RuntimeStageInstructionsSchema = z.object({
     local_docs: z.array(z.string()),
     mode_sources: z.array(z.string()),
 }).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(),
-    stage_at_least: z.record(z.string(), z.number()).optional(),
-    stage_at_least_counts: z.record(z.string(), z.string()).optional(),
-    zone_counts_at_least: z.record(z.string().regex(InterfIdPattern), z.number()).optional(),
-    zone_counts_at_least_counts: z.record(z.string().regex(InterfIdPattern), z.string()).optional(),
-    markdown_frontmatter_valid_zones: z.array(MethodZoneIdSchema).optional(),
-    frontmatter_required_keys_in_zones: z.record(MethodZoneIdSchema, z.array(z.string().min(1)).min(1)).optional(),
-    markdown_abstract_valid_zones: z.array(MethodZoneIdSchema).optional(),
-    wikilinks_valid_in_zones: z.array(MethodZoneIdSchema).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),
@@ -163,10 +155,14 @@ export const RuntimeStageContractSchema = z.object({
     executor: RuntimeExecutorInfoSchema,
     instructions: RuntimeStageInstructionsSchema,
     counts: z.record(z.string(), z.number()),
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
     artifacts: z.object({
         reads: z.array(z.string()),
         writes: z.array(z.string()),
+        write_contracts: z.array(z.object({
+            artifact_id: ArtifactIdSchema,
+            path: z.string().min(1),
+            checks: z.array(CheckSchema),
+        }).strict()).default([]),
     }),
     policies: z.object({
         execution_mode: z.literal("deterministic"),
@@ -211,9 +207,9 @@ export const RuntimeRunSchema = z.object({
     error: z.string().nullable(),
 });
 export const CompiledInventoryEntrySchema = z.object({
-    input_zone: MethodZoneIdSchema.optional(),
+    input_artifact: ArtifactIdSchema.optional(),
     input_path: z.string().min(1).optional(),
-    output_zone: MethodZoneIdSchema,
+    output_artifact: ArtifactIdSchema,
     output_path: z.string().min(1),
     state: z.string().min(1).optional(),
     metadata: JsonRecordSchema.optional(),

package/dist/packages/engine/compile/method-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPILED_ARTIFACT_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledArtifactKind = typeof COMPILED_ARTIFACT_KINDS[number];

package/dist/packages/{compiler → engine/compile}/method-primitives.js

@@ -1,4 +1,4 @@
-export const COMPILED_ZONE_KINDS = [
+export const COMPILED_ARTIFACT_KINDS = [
     "directory",
     "file",
     "runtime",

package/dist/packages/{compiler → engine/compile}/method-runs.d.ts

@@ -1,5 +1,5 @@
-import { type InterfConfig } from "../project-model/interf-detect.js";
-export type { MethodReporter } from "../method-package/method-helpers.js";
+import { type InterfConfig } from "../../project/interf-detect.js";
+export type { MethodReporter } from "../../methods/package/method-helpers.js";
 export type CompiledCheck = "compiled" | "stage";
 export interface DetectedInterfTarget {
     path: string;
@@ -11,4 +11,4 @@ export declare function detectCompiled(cwd: string): DetectedInterfTarget | null
 export declare function createCompiled(name: string, sourcePath: string, methodId: string | undefined, about: string | undefined, sourceFolderPath: string): string;
 export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledMethodValidation;
 export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
-export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, ResolveStageExecutor, } from "./compiled-compile.js";

package/dist/packages/{compiler → engine/compile}/method-runs.js

@@ -1,7 +1,7 @@
-import { createCompiled as createCompiledScaffold, } from "../project-model/interf-scaffold.js";
-import { detectInterf } from "../project-model/interf-detect.js";
+import { createCompiled as createCompiledScaffold, } from "../../project/interf-scaffold.js";
+import { detectInterf } from "../../project/interf-detect.js";
 import { validateCompiledCompile, } from "./validate.js";
-import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
+import { DEFAULT_METHOD_ID } from "../../methods/method-resolution.js";
 export function detectCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)

package/dist/packages/{compiler → engine/compile}/reset.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { initializeCompiledRuntimeState } from "./state.js";
 import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, methodPackagePathForCompiled, } from "./compiled-paths.js";
 function removeIfExists(path) {
@@ -40,10 +40,10 @@ export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
 function activeCompiledInputRoots(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const roots = new Set();
-    for (const zone of schema?.zones ?? []) {
-        if (zone.role !== "input")
+    for (const artifact of schema ? listCompiledSchemaArtifacts(schema) : []) {
+        if (artifact.role !== "input")
             continue;
-        const root = zone.path.split("/")[0]?.trim();
+        const root = artifact.path.split("/")[0]?.trim();
         if (root)
             roots.add(root);
     }

package/dist/packages/{compiler → engine/compile}/runtime-contracts.js

@@ -8,7 +8,6 @@ export function buildRuntimeStageContract(options) {
             ...(options.counts ?? {}),
             local_skill_docs: localSkillDocs.length,
         },
-        ...(options.acceptance ? { acceptance: options.acceptance } : {}),
         artifacts: {
             reads: [
                 "interf.json",
@@ -18,6 +17,7 @@ export function buildRuntimeStageContract(options) {
                 ...localSkillDocs,
             ],
             writes: options.stageWriteArtifacts,
+            write_contracts: options.stageWriteContracts ?? [],
         },
         policies: {
             execution_mode: "deterministic",
@@ -28,6 +28,7 @@ export function buildRuntimeStageContract(options) {
                 `Use \`method/${METHOD_SCHEMA_FILE}\` as the deterministic context-interface reference for this portable context.`,
                 "Honor the declared read and write artifacts instead of inventing a parallel process.",
                 "Only create or update files that fall under the declared write targets for this stage.",
+                "Before emitting DONE, satisfy every check listed under `artifacts.write_contracts[]` for the write Artifacts this stage owns.",
                 "Interf writes `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",
                 "Keep scratch extraction commands single-purpose and non-destructive. Avoid wildcard cleanup and multi-command chains.",
                 ...methodNotes,

package/dist/packages/{compiler → engine/compile}/runtime-prompt.js

@@ -21,9 +21,10 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
         "The user has already invoked this stage through the Interf CLI. Execute it now.",
         "Do not ask what the user wants, offer help, list tools, or wait for another instruction.",
         `Read \`${contractPath}\` first. It is the authoritative contract for this stage.`,
-        "If `runtime/paths.json` exists in this shell, read it next. It maps Method zone ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
-        "For file-zone mounts, `runtime/paths.json` also gives the exact file path inside the `inputs/` or `outputs/` mount root.",
+        "If `runtime/paths.json` exists in this shell, read it next. It maps Method Artifact ids onto the shell-local `inputs/` and `outputs/` mounts for this stage.",
+        "For file Artifact mounts, `runtime/paths.json` also gives the exact file path inside the `inputs/` or `outputs/` mount root.",
         "Honor the contract's counts, artifact paths, and policies instead of inventing another Method.",
+        "The contract's `artifacts.write_contracts[]` lists the checks Interf will run against the Artifacts this stage writes. Treat those checks as required output constraints.",
         "Read only the files named by the contract's `artifacts.reads` list plus any paths they explicitly direct you to open.",
         "Prefer direct file-reading and search tools over shell commands when you inspect inputs, docs, or generated outputs.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` for routine file inspection if a native read/search tool can do the same job.",

package/dist/packages/{compiler → engine/compile}/runtime-reconcile.d.ts

@@ -1,2 +1,2 @@
-import { type MethodStageDefinition } from "../method-package/method-definitions.js";
+import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
 export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<MethodStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;

package/dist/packages/{compiler → engine/compile}/runtime-reconcile.js

@@ -1,11 +1,12 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { extname, join, relative } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { compiledArtifactAbsolutePath, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
+import { STANDARD_EVIDENCE_FRONTMATTER_KEYS, } from "../../contracts/lib/schema.js";
 import { compiledRuntimeRoot, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
@@ -37,8 +38,8 @@ function anyPathUpdatedSince(absolutePath, sinceMs) {
     }
     return false;
 }
-function zoneArtifactCount(dirPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(dirPath, { path: zonePath });
+function artifactCount(dirPath, artifactPath, kind) {
+    const absolutePath = compiledArtifactAbsolutePath(dirPath, { path: artifactPath });
     if (!existsSync(absolutePath))
         return 0;
     if (kind === "file")
@@ -51,11 +52,11 @@ 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")
+function listZoneArtifacts(dirPath, artifact) {
+    const absolutePath = compiledArtifactAbsolutePath(dirPath, artifact);
+    if (!existsSync(absolutePath) || artifact.kind === "runtime")
         return [];
-    if (zone.kind === "file") {
+    if (artifact.kind === "file") {
         try {
             return statSync(absolutePath).isFile() ? [absolutePath] : [];
         }
@@ -67,8 +68,8 @@ function listZoneArtifacts(dirPath, zone) {
 }
 function buildInventoryMetadata(options) {
     const metadata = {
-        zone_id: options.zoneId,
-        zone_kind: options.zoneKind,
+        artifact_id: options.artifactId,
+        artifact_kind: options.artifactKind,
         file_extension: extname(options.filePath).toLowerCase() || null,
     };
     if (!options.parsedFrontmatter) {
@@ -80,15 +81,16 @@ function buildInventoryMetadata(options) {
         metadata.abstract = abstract;
         metadata.abstract_read = true;
     }
+    // Project the standard evidence frontmatter keys onto the inventory
+    // metadata. Method authors that emit the canonical evidence keys
+    // (`STANDARD_EVIDENCE_FRONTMATTER_KEYS` in contracts) get them
+    // surfaced on stage inventory entries; non-standard keys are ignored.
     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;
+    for (const key of STANDARD_EVIDENCE_FRONTMATTER_KEYS) {
+        const value = frontmatter[key];
+        if (typeof value === "string") {
+            metadata[key] = value;
+        }
     }
     return metadata;
 }
@@ -96,16 +98,16 @@ function buildStageInventoryEntries(dirPath, stage) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     if (!schema)
         return [];
-    const readableInputZones = stage.reads
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    const outputZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null && zone.kind !== "runtime");
-    if (outputZones.length === 0)
+    const readableInputArtifacts = stage.reads
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
+    const outputArtifacts = stage.writes
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null && artifact.kind !== "runtime");
+    if (outputArtifacts.length === 0)
         return [];
     const entries = [];
-    for (const outputZone of outputZones) {
+    for (const outputZone of outputArtifacts) {
         for (const filePath of listZoneArtifacts(dirPath, outputZone)) {
             const relativeOutputPath = relative(dirPath, filePath).replaceAll("\\", "/");
             const parsed = isOutputMarkdownFile(filePath)
@@ -114,36 +116,36 @@ function buildStageInventoryEntries(dirPath, stage) {
             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 sourceArtifactId = typeof parsed?.frontmatter.source_artifact === "string"
+                ? parsed.frontmatter.source_artifact.trim()
                 : "";
-            const inputZone = sourceZoneId.length > 0
-                ? readableInputZones.find((zone) => zone.id === sourceZoneId) ?? null
-                : readableInputZones.length === 1
-                    ? readableInputZones[0]
+            const inputZone = sourceArtifactId.length > 0
+                ? readableInputArtifacts.find((artifact) => artifact.id === sourceArtifactId) ?? null
+                : readableInputArtifacts.length === 1
+                    ? readableInputArtifacts[0]
                     : null;
             entries.push({
                 ...(inputZone && sourcePath.length > 0
                     ? {
-                        input_zone: inputZone.id,
+                        input_artifact: inputZone.id,
                         input_path: sourcePath,
                     }
                     : {}),
-                output_zone: outputZone.id,
+                output_artifact: outputZone.id,
                 output_path: relativeOutputPath,
                 ...(typeof parsed?.frontmatter.state === "string"
                     ? { state: parsed.frontmatter.state }
                     : {}),
                 metadata: buildInventoryMetadata({
-                    zoneId: outputZone.id,
-                    zoneKind: outputZone.kind,
+                    artifactId: outputZone.id,
+                    artifactKind: outputZone.kind,
                     filePath,
                     parsedFrontmatter: parsed,
                 }),
             });
         }
     }
-    return entries.sort((left, right) => `${left.output_zone}:${left.output_path}`.localeCompare(`${right.output_zone}:${right.output_path}`));
+    return entries.sort((left, right) => `${left.output_artifact}:${left.output_path}`.localeCompare(`${right.output_artifact}:${right.output_path}`));
 }
 function writeStageInventory(dirPath, stageId, entries) {
     writeFileSync(join(compiledRuntimeRoot(dirPath), "inventory.json"), JSON.stringify(compiledInventoryFromEntries(entries, stageId), null, 2) + "\n");
@@ -158,12 +160,12 @@ export function reconcileCompiledStageRun(dirPath, stage) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     if (!schema)
         return false;
-    const writeZones = stage.writes
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null);
-    if (writeZones.length === 0)
+    const writeArtifacts = stage.writes
+        .map((artifactId) => findCompiledSchemaArtifact(schema, artifactId))
+        .filter((artifact) => artifact !== null);
+    if (writeArtifacts.length === 0)
         return false;
-    if (!writeZones.some((zone) => anyPathUpdatedSince(compiledZoneAbsolutePath(dirPath, zone), startedAtMs))) {
+    if (!writeArtifacts.some((artifact) => anyPathUpdatedSince(compiledArtifactAbsolutePath(dirPath, artifact), startedAtMs))) {
         return false;
     }
     writeStageInventory(dirPath, stage.id, buildStageInventoryEntries(dirPath, stage));
@@ -181,8 +183,8 @@ export function reconcileCompiledStageRun(dirPath, stage) {
         started_at: loadRuntimeRun(dirPath)?.started_at ?? now,
         finished_at: now,
         counts: activeRunCounts(dirPath),
-        zone_counts: Object.fromEntries(writeZones.map((zone) => [zone.id, zoneArtifactCount(dirPath, zone.path, zone.kind)])),
-        artifacts: writeZones.map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`),
+        artifact_counts: Object.fromEntries(writeArtifacts.map((artifact) => [artifact.id, artifactCount(dirPath, artifact.path, artifact.kind)])),
+        artifacts: writeArtifacts.map((artifact) => artifact.kind === "file" ? artifact.path : `${artifact.path}/`),
         summary: loadRuntimeRun(dirPath)?.summary ?? null,
         run_id: loadRuntimeRun(dirPath)?.run_id ?? null,
     };

package/dist/packages/{compiler → engine/compile}/runtime-runs.d.ts

@@ -1,10 +1,9 @@
 import { type RuntimeRun, type RuntimeStageContract } from "./lib/schema.js";
-import { type RuntimeRunPatch, type RuntimeStageExecutionOptions, type RuntimeSummarizeExecutionOptions } from "./runtime-types.js";
+import { type RuntimeRunPatch, type RuntimeStageExecutionOptions } from "./runtime-types.js";
 export declare function loadRuntimeRun(dirPath: string): RuntimeRun | null;
 export declare function saveRuntimeRun(dirPath: string, run: RuntimeRun): void;
 export declare function writeStageContract(dirPath: string, contract: RuntimeStageContract): string;
 export declare function runExecutorStage(options: RuntimeStageExecutionOptions): Promise<number>;
-export declare function runExecutorSummarizeStage(options: RuntimeSummarizeExecutionOptions): Promise<number>;
 export declare function beginRuntimeRun(dirPath: string, run: RuntimeRun): RuntimeRun;
 export declare function updateRuntimeRun(dirPath: string, patch: RuntimeRunPatch): RuntimeRun | null;
 export declare function markRuntimeRunFailedAfterValidation(dirPath: string, summary: string): RuntimeRun | null;

package/dist/packages/{compiler → engine/compile}/runtime-runs.js

@@ -1,12 +1,10 @@
 import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { dirname, join, relative } from "node:path";
-import chalk from "chalk";
-import { countFilesRecursive } from "../shared/filesystem.js";
+import { dirname, relative } from "node:path";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
 import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../method-package/method-definitions.js";
+import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../../methods/package/method-definitions.js";
 import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-import { warnInterf } from "../shared/logger.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
 export function loadRuntimeRun(dirPath) {
     const path = runPath(dirPath);
     if (!existsSync(path))
@@ -54,44 +52,6 @@ export async function runExecutorStage(options) {
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
 }
-export async function runExecutorSummarizeStage(options) {
-    const startedRun = startRuntimeRun(options);
-    const prompt = options.buildPrompt(startedRun.activeContractPath);
-    let lastReported = 0;
-    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, startedRun.run.run_id),
-        statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
-        completionCheck: options.completionCheck,
-        onStatus: options.onStatus,
-    });
-    const timer = setInterval(() => {
-        const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
-        const completed = Math.max(0, Math.min(options.targetCount, currentSummaryCount - options.startingSummaryCount));
-        if (completed <= lastReported)
-            return;
-        lastReported = completed;
-        updateRuntimeRun(options.compiledPath, {
-            counts: {
-                ...startedRun.run.counts,
-                completed_summaries: completed,
-                target_summaries: options.targetCount,
-            },
-            summary: `${options.stageLabel} ${completed}/${options.targetCount} source files into summaries.`,
-        });
-        console.log(chalk.dim(`  STATUS: wrote ${completed}/${options.targetCount} summaries`));
-        options.onStatus?.(`STATUS: wrote ${completed}/${options.targetCount} summaries`);
-    }, 10000);
-    try {
-        const code = await progressPromise;
-        finalizeRuntimeRun(options.compiledPath, code);
-        return code;
-    }
-    finally {
-        clearInterval(timer);
-    }
-}
 export function beginRuntimeRun(dirPath, run) {
     saveRuntimeRun(dirPath, run);
     return run;
@@ -169,7 +129,6 @@ function startRuntimeRun(options) {
         executor: buildRuntimeExecutorInfo(options.executor),
         instructions: options.contract.instructions,
         counts: options.contract.counts,
-        ...(options.contract.acceptance ? { acceptance: options.contract.acceptance } : {}),
         artifacts: options.contract.artifacts,
         policies: options.contract.policies,
     };

package/dist/packages/{compiler → engine/compile}/runtime-types.d.ts

@@ -1,6 +1,6 @@
 import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type RuntimeRun, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
-import type { MethodId, RuntimeContractType, RuntimeStage } from "../contracts/lib/schema.js";
+import { type RuntimeRun, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
+import type { Check, MethodId, RuntimeContractType, RuntimeStage } from "../../contracts/lib/schema.js";
 export type RuntimeRunStatus = "running" | "succeeded" | "failed";
 export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "method" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
@@ -19,15 +19,6 @@ export interface RuntimeStageExecutionOptions {
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
 }
-export interface RuntimeSummarizeExecutionOptions extends RuntimeStageExecutionOptions {
-    startingSummaryCount: number;
-    targetCount: number;
-}
-export interface RuntimeStageAcceptanceValidation {
-    ok: boolean;
-    summary: string;
-    failures: string[];
-}
 export interface RuntimeStageContractOptions {
     compiledName: string;
     stageId: string;
@@ -36,10 +27,14 @@ export interface RuntimeStageContractOptions {
     extraReadArtifacts?: string[];
     stageReadArtifacts: string[];
     stageWriteArtifacts: string[];
+    stageWriteContracts?: Array<{
+        artifact_id: string;
+        path: string;
+        checks: Check[];
+    }>;
     methodNotes?: string[];
     localSkillDocs?: string[];
     instructions: RuntimeStageInstructions;
-    acceptance?: RuntimeStageAcceptance;
 }
 export interface RuntimeRunPatch extends Partial<Pick<RuntimeRun, "counts" | "summary" | "status" | "error" | "exit_code" | "finished_at">> {
 }

package/dist/packages/engine/compile/runtime.d.ts

@@ -0,0 +1,5 @@
+export type { RuntimeRunPatch, RuntimeRunStatus, RuntimeStageContractDraft, RuntimeStageExecutionOptions, RuntimeStageContractOptions, } from "./runtime-types.js";
+export { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
+export { buildStagePrompt } from "./runtime-prompt.js";
+export { buildRuntimeStageContract, } from "./runtime-contracts.js";
+export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/{compiler → engine/compile}/runtime.js

@@ -1,5 +1,4 @@
 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";
-export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, runExecutorSummarizeStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";
+export { beginRuntimeRun, loadRuntimeRun, markRuntimeRunFailedAfterValidation, markRuntimeRunSucceededAfterValidation, runExecutorStage, saveRuntimeRun, updateRuntimeRun, writeStageContract, } from "./runtime-runs.js";

package/dist/packages/{compiler → engine/compile}/source-files.d.ts

@@ -1,4 +1,4 @@
-import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../contracts/lib/schema.js";
+import { type SourceFiles, type SourceSnapshot, type StageInputs } from "../../contracts/lib/schema.js";
 export declare function buildCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
 export declare function writeCompiledSourceFiles(compiledPath: string, sourcePath?: string, generatedAt?: string): SourceFiles;
 export declare function buildCompiledSourceSnapshot(options: {

package/dist/packages/{compiler → engine/compile}/source-files.js

@@ -1,11 +1,11 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { SourceFilesSchema, SourceSnapshotSchema, StageInputsSchema, } from "../contracts/lib/schema.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
+import { SourceFilesSchema, SourceSnapshotSchema, StageInputsSchema, } from "../../contracts/lib/schema.js";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { compiledRuntimeSourceFilesPath, compiledRuntimeSourceSnapshotPath, compiledRuntimeStageInputsPath, } from "./compiled-paths.js";
-import { resolveSourceInputPath } from "../project-model/interf-detect.js";
+import { resolveSourceInputPath } from "../../project/interf-detect.js";
 function shortHash(value, length = 16) {
     return createHash("sha256")
         .update(value)