@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/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>;
@@ -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>;
@@ -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>;

package/dist/packages/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

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

package/dist/packages/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/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/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/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.",