@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{compiler → engine/compile}/compiled-stage-plan.js

@@ -1,15 +1,15 @@
 import { join } from "node:path";
 import { buildRuntimeStageContract, } from "./runtime.js";
 import { discoverSourceFiles } from "./discovery.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../method-package/method-helpers.js";
-import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } from "../method-package/method-definitions.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { compiledContractArtifactPath, compiledContractArtifactPathsForArtifactIds, findCompiledSchemaArtifact, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../../methods/package/method-helpers.js";
+import { getActiveCompiledStagePolicyNotes, } from "../../methods/package/method-definitions.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { readInterfConfig } from "../project-model/interf-detect.js";
+import { readInterfConfig } from "../../project/interf-detect.js";
 import { resolveCompiledContext, } from "./compiled-target.js";
-function zoneArtifactCount(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
+function artifactCount(compiledPath, artifactPath, kind) {
+    const absolutePath = join(compiledPath, artifactPath);
     try {
         if (kind === "file") {
             return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
@@ -27,28 +27,45 @@ export function resolveStageContractArtifacts(compiledPath, stageDefinition) {
         throw new Error(`Missing Method schema for stage "${stageDefinition.id}" at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
     return {
-        reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
-        writes: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.writes),
+        reads: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.reads),
+        writes: compiledContractArtifactPathsForArtifactIds(schema, stageDefinition.writes),
+        writeContracts: stageDefinition.writes.map((artifactId) => {
+            const artifact = schema.artifacts.find((candidate) => candidate.id === artifactId);
+            if (!artifact) {
+                throw new Error(`Compiled schema is missing declared Artifact "${artifactId}".`);
+            }
+            const path = artifact.shape.kind === "path"
+                ? compiledContractArtifactPath({
+                    path: artifact.shape.path,
+                    kind: artifact.shape.artifact_kind,
+                })
+                : artifact.id;
+            return {
+                artifact_id: artifact.id,
+                path,
+                checks: artifact.checks ?? [],
+            };
+        }),
     };
 }
 export function buildStageCounts(compiledPath, stageDefinition) {
     const context = resolveCompiledContext(compiledPath);
     const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zoneCounts = {};
+    const artifactCounts = {};
     if (schema) {
-        for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
-            const zone = findCompiledSchemaZone(schema, zoneId);
-            if (!zone)
+        for (const artifactId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
+            const artifact = findCompiledSchemaArtifact(schema, artifactId);
+            if (!artifact)
                 continue;
-            zoneCounts[zoneId] = zoneArtifactCount(compiledPath, zone.path, zone.kind);
+            artifactCounts[artifactId] = artifactCount(compiledPath, artifact.path, artifact.kind);
         }
     }
     return {
         source_total: sourceTotal,
-        read_zone_total: stageDefinition.reads.length,
-        write_zone_total: stageDefinition.writes.length,
-        ...zoneCounts,
+        read_artifact_total: stageDefinition.reads.length,
+        write_artifact_total: stageDefinition.writes.length,
+        ...artifactCounts,
     };
 }
 export function buildStageContract(compiledPath, stageDefinition, instructions) {
@@ -65,10 +82,10 @@ export function buildStageContract(compiledPath, stageDefinition, instructions)
         ],
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
+        stageWriteContracts: stageArtifacts.writeContracts,
         methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
         localSkillDocs: instructions.local_docs,
         instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, stageDefinition.id),
     });
 }
 export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {

package/dist/packages/{compiler → engine/compile}/compiled-stage-runner.d.ts

@@ -1,5 +1,5 @@
 import { type MethodExecutor } from "../agents/lib/executors.js";
-import { type MethodReporter, type MethodStageResult } from "../method-package/method-helpers.js";
+import { type MethodReporter, type MethodStageResult } from "../../methods/package/method-helpers.js";
 import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
 import { type RunEventSink } from "../execution/events.js";
 export declare function runCompiledStage(options: {

package/dist/packages/{compiler → engine/compile}/compiled-stage-runner.js

@@ -2,9 +2,9 @@ import { createStageExecutionShell, freezeStageExecutionShell, syncStageExecutio
 import { reconcileCompiledStageRun } from "./runtime-reconcile.js";
 import { refreshCompiledArtifacts } from "./state.js";
 import { validateCompiledStage } from "./validate.js";
-import { executeValidatedStage, } from "../method-package/method-stage-runner.js";
-import { formatActiveCompiledMethodStageStep, } from "../method-package/method-definitions.js";
-import { reportBlankLine, reportLine, } from "../method-package/method-helpers.js";
+import { executeValidatedStage, } from "../../methods/package/method-stage-runner.js";
+import { formatActiveCompiledMethodStageStep, } from "../../methods/package/method-definitions.js";
+import { reportBlankLine, reportLine, } from "../../methods/package/method-helpers.js";
 import { buildCompiledStageExecutionPlan, } from "./compiled-stage-plan.js";
 import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
 async function emitRunEvent(sink, event) {
@@ -44,7 +44,7 @@ export async function runCompiledStage(options) {
             statusLines: [
                 `Emit exactly one startup line: STATUS: loaded ${stageDefinition.label.toLowerCase()} stage.`,
                 "Emit STATUS: reading declared inputs after you confirm the shell contract and local docs.",
-                "Emit STATUS: writing declared outputs after the stage starts updating the compiled zones.",
+                "Emit STATUS: writing declared outputs after the stage starts updating the compiled Artifacts.",
                 `Emit DONE: ${stageDefinition.id} complete when the declared outputs and proof are on disk.`,
             ],
             reporter: options.reporter,

package/dist/packages/{compiler → engine/compile}/compiled-target.d.ts

@@ -1,5 +1,5 @@
-import { type MethodStageDefinition } from "../method-package/method-definitions.js";
-import { type CompiledMethodId } from "../method-package/method-definitions.js";
+import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
+import { type CompiledMethodId } from "../../methods/package/method-definitions.js";
 export interface CompiledStageExecutionDefinition extends MethodStageDefinition {
 }
 export declare function resolveCompiledContext(compiledPath: string): {

package/dist/packages/{compiler → engine/compile}/compiled-target.js

@@ -1,5 +1,5 @@
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
-import { readInterfConfig, resolveSourceFolderPath, resolveSourceControlPath, } from "../project-model/interf-detect.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
+import { readInterfConfig, resolveSourceFolderPath, resolveSourceControlPath, } from "../../project/interf-detect.js";
 export function resolveCompiledContext(compiledPath) {
     const config = readInterfConfig(compiledPath);
     const methodId = resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${compiledPath}`);

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

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
-import { listFilesRecursive } from "../shared/filesystem.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
 const DEFAULT_IGNORE_DIRS = new Set([
     "interf",
     ".interf",

package/dist/packages/{compiler → engine/compile}/index.d.ts

@@ -3,7 +3,6 @@ export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
 export * as runtime from "./runtime.js";
-export * as runtimeAcceptance from "./runtime-acceptance.js";
 export * as runtimeContracts from "./runtime-contracts.js";
 export * as runtimeInventory from "./runtime-inventory.js";
 export * as runtimePaths from "./runtime-paths.js";

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

@@ -3,7 +3,6 @@ export * as schema from "./lib/schema.js";
 export * as compiledSchema from "./compiled-schema.js";
 export * as compile from "./compiled-compile.js";
 export * as runtime from "./runtime.js";
-export * as runtimeAcceptance from "./runtime-acceptance.js";
 export * as runtimeContracts from "./runtime-contracts.js";
 export * as runtimeInventory from "./runtime-inventory.js";
 export * as runtimePaths from "./runtime-paths.js";

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

@@ -1,15 +1,15 @@
 import { z } from "zod";
-import { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, TestCaseExpectSchema, TestTargetTypeSchema, 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 { GateStatusSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceSchema, SourceSnapshotSchema, StageInputSchema, StageInputsSchema, TestCaseExpectSchema, TestTargetTypeSchema, MethodIdSchema } from "../../../contracts/lib/schema.js";
+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";
 export type RuntimeStatus = "idle" | "running" | "compiled" | "stale" | "failed";
 export type CompiledStage = "idle" | "compiled" | "failed" | string;
-export declare const MethodZoneIdSchema: z.ZodString;
-export declare const MethodCompiledZoneKindSchema: z.ZodEnum<{
+export declare const MethodArtifactIdSchema: z.ZodString;
+export declare const MethodCompiledArtifactKindSchema: z.ZodEnum<{
     runtime: "runtime";
     file: "file";
     directory: "directory";
 }>;
-export declare const MethodZoneRoleSchema: z.ZodEnum<{
+export declare const MethodArtifactRoleSchema: z.ZodEnum<{
     runtime: "runtime";
     output: "output";
     input: "input";
@@ -32,7 +32,7 @@ export declare const CompiledStageStateSchema: z.ZodObject<{
     started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    zone_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    artifact_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -51,7 +51,7 @@ export declare const CompiledStateSchema: z.ZodObject<{
         started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        zone_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        artifact_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
         summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         run_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -92,8 +92,8 @@ export declare const CompiledHealthSchema: z.ZodObject<{
     target_name: z.ZodString;
     status: z.ZodEnum<{
         compiled: "compiled";
-        stale: "stale";
         failed: "failed";
+        stale: "stale";
         running: "running";
         idle: "idle";
     }>;
@@ -144,7 +144,7 @@ export declare const MethodPurposeSchema: z.ZodObject<{
     label: z.ZodString;
     task_hint: z.ZodString;
 }, z.core.$strict>;
-export declare const MethodZoneSchema: z.ZodObject<{
+export declare const MethodCompiledArtifactProjectionSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
         runtime: "runtime";
@@ -162,7 +162,7 @@ export declare const MethodZoneSchema: z.ZodObject<{
     owned_by: z.ZodArray<z.ZodString>;
     description: z.ZodString;
 }, z.core.$strip>;
-export declare const MethodCompiledZoneSchema: z.ZodObject<{
+export declare const MethodCompiledArtifactSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
         runtime: "runtime";
@@ -185,58 +185,85 @@ export declare const MethodSchemaSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
-    zones: z.ZodArray<z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        role: z.ZodEnum<{
-            runtime: "runtime";
-            output: "output";
-            input: "input";
-            working: "working";
-        }>;
-        path: z.ZodString;
-        kind: z.ZodEnum<{
-            runtime: "runtime";
-            file: "file";
-            directory: "directory";
-        }>;
-        required: z.ZodBoolean;
-        owned_by: z.ZodArray<z.ZodString>;
         description: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>], "kind">;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const MethodCompiledSchemaSchema: z.ZodObject<{
     kind: z.ZodLiteral<"method-schema">;
     version: z.ZodLiteral<1>;
     target_type: z.ZodLiteral<"compiled">;
     label: z.ZodString;
-    zones: z.ZodArray<z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        role: z.ZodEnum<{
-            runtime: "runtime";
-            output: "output";
-            input: "input";
-            working: "working";
-        }>;
-        path: z.ZodString;
-        kind: z.ZodEnum<{
-            runtime: "runtime";
-            file: "file";
-            directory: "directory";
-        }>;
-        required: z.ZodBoolean;
-        owned_by: z.ZodArray<z.ZodString>;
         description: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+        shape: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"path">;
+            path: z.ZodString;
+            artifact_kind: z.ZodEnum<{
+                file: "file";
+                directory: "directory";
+            }>;
+        }, z.core.$strict>], "kind">;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                file_exists: "file_exists";
+                min_file_count: "min_file_count";
+                min_file_count_matches_source: "min_file_count_matches_source";
+                frontmatter_valid: "frontmatter_valid";
+                frontmatter_required_keys: "frontmatter_required_keys";
+                wikilinks_valid: "wikilinks_valid";
+                must_not_contain: "must_not_contain";
+                must_contain: "must_contain";
+                qa_match: "qa_match";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>>;
+        built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const MethodCompilerApiSchema: z.ZodObject<{
     kind: z.ZodLiteral<"compiled">;
     version: z.ZodLiteral<1>;
 }, z.core.$strip>;
 export type MethodCompilerApi = z.infer<typeof MethodCompilerApiSchema>;
-export declare const MethodStageZoneAccessSchema: z.ZodArray<z.ZodString>;
-export declare const ExecutionShellZoneMountSchema: z.ZodObject<{
-    zone_id: z.ZodString;
-    compiled_path: z.ZodString;
+export declare const MethodStageArtifactReadAccessSchema: z.ZodArray<z.ZodString>;
+export declare const MethodStageArtifactWriteAccessSchema: z.ZodArray<z.ZodString>;
+export type MethodStageArtifactReadAccess = z.infer<typeof MethodStageArtifactReadAccessSchema>;
+export type MethodStageArtifactWriteAccess = z.infer<typeof MethodStageArtifactWriteAccessSchema>;
+export declare const ExecutionShellArtifactMountSchema: z.ZodObject<{
+    artifact_id: z.ZodString;
+    artifact_path: z.ZodString;
     shell_root_path: z.ZodString;
     input_mount_path: z.ZodNullable<z.ZodString>;
     output_mount_path: z.ZodNullable<z.ZodString>;
@@ -247,15 +274,15 @@ export declare const ExecutionShellPathsSchema: z.ZodObject<{
     method: z.ZodString;
     stage: z.ZodString;
     reads: z.ZodArray<z.ZodObject<{
-        zone_id: z.ZodString;
-        compiled_path: z.ZodString;
+        artifact_id: z.ZodString;
+        artifact_path: z.ZodString;
         shell_root_path: z.ZodString;
         input_mount_path: z.ZodNullable<z.ZodString>;
         output_mount_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
     writes: z.ZodArray<z.ZodObject<{
-        zone_id: z.ZodString;
-        compiled_path: z.ZodString;
+        artifact_id: z.ZodString;
+        artifact_path: z.ZodString;
         shell_root_path: z.ZodString;
         input_mount_path: z.ZodNullable<z.ZodString>;
         output_mount_path: z.ZodNullable<z.ZodString>;
@@ -264,8 +291,8 @@ export declare const ExecutionShellPathsSchema: z.ZodObject<{
 export declare const RuntimeStageInstructionsSchema: z.ZodObject<{
     stage_skill_dir: z.ZodString;
     effective_mode: z.ZodEnum<{
-        override: "override";
         builtin: "builtin";
+        override: "override";
         extend: "extend";
     }>;
     local_mode: z.ZodNullable<z.ZodEnum<{
@@ -275,20 +302,6 @@ export declare const RuntimeStageInstructionsSchema: z.ZodObject<{
     local_docs: z.ZodArray<z.ZodString>;
     mode_sources: z.ZodArray<z.ZodString>;
 }, 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>>;
-    stage_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    stage_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    zone_counts_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-    zone_counts_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    markdown_frontmatter_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    frontmatter_required_keys_in_zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-    markdown_abstract_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    wikilinks_valid_in_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    artifacts_must_not_contain: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-}, z.core.$strict>;
 export declare const RuntimeStageContractSchema: z.ZodObject<{
     kind: z.ZodLiteral<"interf-stage-contract">;
     version: z.ZodLiteral<1>;
@@ -324,8 +337,8 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
     instructions: z.ZodObject<{
         stage_skill_dir: z.ZodString;
         effective_mode: z.ZodEnum<{
-            override: "override";
             builtin: "builtin";
+            override: "override";
             extend: "extend";
         }>;
         local_mode: z.ZodNullable<z.ZodEnum<{
@@ -336,23 +349,30 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         mode_sources: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
     counts: z.ZodRecord<z.ZodString, z.ZodNumber>;
-    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>>;
-        stage_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        stage_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        zone_counts_at_least: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        zone_counts_at_least_counts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        markdown_frontmatter_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        frontmatter_required_keys_in_zones: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-        markdown_abstract_valid_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        wikilinks_valid_in_zones: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        artifacts_must_not_contain: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
-    }, z.core.$strict>>;
     artifacts: z.ZodObject<{
         reads: z.ZodArray<z.ZodString>;
         writes: z.ZodArray<z.ZodString>;
+        write_contracts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            artifact_id: z.ZodString;
+            path: z.ZodString;
+            checks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    file_exists: "file_exists";
+                    min_file_count: "min_file_count";
+                    min_file_count_matches_source: "min_file_count_matches_source";
+                    frontmatter_valid: "frontmatter_valid";
+                    frontmatter_required_keys: "frontmatter_required_keys";
+                    wikilinks_valid: "wikilinks_valid";
+                    must_not_contain: "must_not_contain";
+                    must_contain: "must_contain";
+                    qa_match: "qa_match";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                required: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
     }, z.core.$strip>;
     policies: z.ZodObject<{
         execution_mode: z.ZodLiteral<"deterministic">;
@@ -416,9 +436,9 @@ export declare const RuntimeRunSchema: z.ZodObject<{
     error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export declare const CompiledInventoryEntrySchema: z.ZodObject<{
-    input_zone: z.ZodOptional<z.ZodString>;
+    input_artifact: z.ZodOptional<z.ZodString>;
     input_path: z.ZodOptional<z.ZodString>;
-    output_zone: z.ZodString;
+    output_artifact: z.ZodString;
     output_path: z.ZodString;
     state: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -428,9 +448,9 @@ export declare const CompiledInventorySchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodNumber>;
     stage: z.ZodOptional<z.ZodString>;
     entries: z.ZodArray<z.ZodObject<{
-        input_zone: z.ZodOptional<z.ZodString>;
+        input_artifact: z.ZodOptional<z.ZodString>;
         input_path: z.ZodOptional<z.ZodString>;
-        output_zone: z.ZodString;
+        output_artifact: z.ZodString;
         output_path: z.ZodString;
         state: z.ZodOptional<z.ZodString>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -616,9 +636,9 @@ export type MethodImprovementLoopRecord = z.infer<typeof MethodImprovementLoopRe
 export type MethodImprovementRunLedger = z.infer<typeof MethodImprovementRunLedgerSchema>;
 export type ReadinessStatus = z.infer<typeof ReadinessStatusSchema>;
 export type ReadinessGate = z.infer<typeof ReadinessGateSchema>;
-export type ReadinessCheck = z.infer<typeof ReadinessCheckSchema>;
-export type ReadinessTargetResult = z.infer<typeof ReadinessTargetResultSchema>;
-export type ReadinessState = z.infer<typeof ReadinessStateSchema>;
+export type GateStatus = z.infer<typeof GateStatusSchema>;
+export type VerifyTargetResult = z.infer<typeof VerifyTargetResultSchema>;
+export type Readiness = z.infer<typeof ReadinessSchema>;
 export type CompiledState = z.infer<typeof CompiledStateSchema>;
 export type ViewSection = z.infer<typeof ViewSectionSchema>;
 export type ViewCard = z.infer<typeof ViewCardSchema>;
@@ -631,11 +651,11 @@ export type SourceFiles = z.infer<typeof SourceFilesSchema>;
 export type SourceSnapshot = z.infer<typeof SourceSnapshotSchema>;
 export type StageInput = z.infer<typeof StageInputSchema>;
 export type StageInputs = z.infer<typeof StageInputsSchema>;
-export type MethodCompiledZone = z.infer<typeof MethodCompiledZoneSchema>;
+export type MethodCompiledArtifact = z.infer<typeof MethodCompiledArtifactSchema>;
 export type MethodCompiledSchema = z.infer<typeof MethodCompiledSchemaSchema>;
-export type MethodCompiledZoneKind = z.infer<typeof MethodCompiledZoneKindSchema>;
-export type MethodZoneId = z.infer<typeof MethodZoneIdSchema>;
-export type ExecutionShellZoneMount = z.infer<typeof ExecutionShellZoneMountSchema>;
+export type MethodCompiledArtifactKind = z.infer<typeof MethodCompiledArtifactKindSchema>;
+export type MethodArtifactId = z.infer<typeof MethodArtifactIdSchema>;
+export type ExecutionShellArtifactMount = z.infer<typeof ExecutionShellArtifactMountSchema>;
 export type ExecutionShellPaths = z.infer<typeof ExecutionShellPathsSchema>;
 export type RuntimeExecutorInfo = z.infer<typeof RuntimeExecutorInfoSchema>;
 export type RuntimeTargetType = z.infer<typeof RuntimeTargetTypeSchema>;
@@ -646,7 +666,6 @@ export type MethodId = z.infer<typeof MethodIdSchema>;
 export type LocalInstructionMode = "extend" | "override";
 export type RuntimeInstructionMode = "builtin" | LocalInstructionMode;
 export type RuntimeStageInstructions = z.infer<typeof RuntimeStageInstructionsSchema>;
-export type RuntimeStageAcceptance = z.infer<typeof RuntimeStageAcceptanceSchema>;
 export type RuntimeStageContract = z.infer<typeof RuntimeStageContractSchema>;
 export type RuntimeRun = z.infer<typeof RuntimeRunSchema>;
 export type CompiledInventoryEntry = z.infer<typeof CompiledInventoryEntrySchema>;