@interf/compiler 0.9.5 → 0.16.0

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

@@ -7,7 +7,10 @@ export declare const COMPILED_RUNTIME_DIR = "runtime";
 export declare const COMPILED_RUNTIME_STATE_FILE = "state.json";
 export declare const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
 export declare const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export declare const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
+export declare const COMPILED_RUNTIME_SOURCE_FILES_FILE = "source-files.json";
+export declare const COMPILED_RUNTIME_SOURCE_SNAPSHOT_FILE = "source-snapshot.json";
+export declare const COMPILED_RUNTIME_STAGE_INPUTS_DIR = "stages";
+export declare const COMPILED_RUNTIME_STAGE_INPUTS_FILE = "inputs.json";
 export declare const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
 export declare const COMPILED_RUNTIME_RUN_FILE = "run.json";
 export declare const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
@@ -31,7 +34,11 @@ export declare function compiledQueryAcceptanceRoot(compiledPath: string): strin
 export declare function compiledRuntimeStatePath(compiledPath: string): string;
 export declare function compiledRuntimeHealthPath(compiledPath: string): string;
 export declare function compiledRuntimeViewSpecPath(compiledPath: string): string;
-export declare function compiledRawSnapshotMetadataPath(compiledPath: string): string;
+export declare function compiledRuntimeSourceFilesPath(compiledPath: string): string;
+export declare function compiledRuntimeSourceSnapshotPath(compiledPath: string): string;
+export declare function compiledRuntimeStagesRoot(compiledPath: string): string;
+export declare function compiledRuntimeStageRoot(compiledPath: string, stageId: string): string;
+export declare function compiledRuntimeStageInputsPath(compiledPath: string, stageId: string): string;
 export declare function compiledRuntimeInventoryPath(compiledPath: string): string;
 export declare function compiledRuntimeRunPath(compiledPath: string): string;
 export declare function compiledRuntimeRunHistoryPath(compiledPath: string): string;

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

@@ -8,7 +8,10 @@ export const COMPILED_RUNTIME_DIR = "runtime";
 export const COMPILED_RUNTIME_STATE_FILE = "state.json";
 export const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
 export const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
+export const COMPILED_RUNTIME_SOURCE_FILES_FILE = "source-files.json";
+export const COMPILED_RUNTIME_SOURCE_SNAPSHOT_FILE = "source-snapshot.json";
+export const COMPILED_RUNTIME_STAGE_INPUTS_DIR = "stages";
+export const COMPILED_RUNTIME_STAGE_INPUTS_FILE = "inputs.json";
 export const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
 export const COMPILED_RUNTIME_RUN_FILE = "run.json";
 export const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
@@ -70,8 +73,20 @@ export function compiledRuntimeHealthPath(compiledPath) {
 export function compiledRuntimeViewSpecPath(compiledPath) {
     return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_VIEW_SPEC_FILE);
 }
-export function compiledRawSnapshotMetadataPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RAW_SNAPSHOT_FILE);
+export function compiledRuntimeSourceFilesPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_SOURCE_FILES_FILE);
+}
+export function compiledRuntimeSourceSnapshotPath(compiledPath) {
+    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_SOURCE_SNAPSHOT_FILE);
+}
+export function compiledRuntimeStagesRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), COMPILED_RUNTIME_STAGE_INPUTS_DIR);
+}
+export function compiledRuntimeStageRoot(compiledPath, stageId) {
+    return join(compiledRuntimeStagesRoot(compiledPath), stageId);
+}
+export function compiledRuntimeStageInputsPath(compiledPath, stageId) {
+    return join(compiledRuntimeStageRoot(compiledPath, stageId), COMPILED_RUNTIME_STAGE_INPUTS_FILE);
 }
 export function compiledRuntimeInventoryPath(compiledPath) {
     return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_INVENTORY_FILE);
@@ -86,19 +101,19 @@ export function compiledRuntimeStageContractPath(compiledPath) {
     return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_STAGE_CONTRACT_FILE);
 }
 export function resolveSourceControlPathForCompiled(compiledPath) {
-    let cursor = resolve(compiledPath);
-    while (true) {
-        const parent = dirname(cursor);
-        if (basename(parent) === "interf" &&
-            basename(cursor) !== "tests" &&
-            basename(cursor) !== "methods") {
-            return dirname(parent);
-        }
-        if (parent === cursor)
-            break;
-        cursor = parent;
+    // Flat workspace layout: the portable context lives at
+    // `<workspace>/<preparation>/`, so the workspace root is the parent of the
+    // portable context. Reject the filesystem root (which has no parent) and the
+    // legacy `<workspace>/interf/<preparation>/` shape so stale fixtures fail loudly.
+    const compiledAbsolute = resolve(compiledPath);
+    const parent = dirname(compiledAbsolute);
+    if (parent === compiledAbsolute) {
+        throw new Error(`Portable context is not under the canonical Interf Workspace layout: ${compiledPath}`);
+    }
+    if (basename(parent) === "interf") {
+        throw new Error(`Portable context is not under the canonical Interf Workspace layout: ${compiledPath}`);
     }
-    throw new Error(`Portable context is not under the canonical Interf Workspace layout: ${compiledPath}`);
+    return parent;
 }
 export function defaultControlPathForCompiled(compiledPath) {
     const relativePath = relative(compiledPath, resolveSourceControlPathForCompiled(compiledPath));

package/dist/packages/{compiler → engine/compile}/compiled-pipeline.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 interface CompiledSummarizeResult extends MethodStageResult {
@@ -15,8 +15,17 @@ export interface CompiledCompileResult {
     failedStage: string | null;
 }
 export type StageShellRetentionMode = "on-failure" | "always";
+/**
+ * Per-stage executor resolver. When provided, the pipeline calls this
+ * for each stage and uses the returned executor instead of the
+ * top-level `executor`. The top-level `executor` stays as the default
+ * fallback so single-active-agent setups keep working without any
+ * resolver wired up.
+ */
+export type ResolveStageExecutor = (stage: CompiledStageExecutionDefinition) => MethodExecutor;
 export declare function runCompiledSummarize(options: {
     executor: MethodExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
     compiledPath: string;
     reporter?: MethodReporter;
     reportSummary?: boolean;
@@ -28,6 +37,7 @@ export declare function runCompiledSummarize(options: {
 }): Promise<CompiledSummarizeResult>;
 export declare function runCompiledCompile(options: {
     executor: MethodExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
     compiledPath: string;
     reporter?: MethodReporter;
     reportStep?: boolean;
@@ -37,6 +47,7 @@ export declare function runCompiledCompile(options: {
 }): Promise<MethodStageResult>;
 export declare function compileCompiled(options: {
     executor: MethodExecutor;
+    resolveStageExecutor?: ResolveStageExecutor;
     compiledPath: string;
     reporter?: MethodReporter;
     preserveStageShells?: StageShellRetentionMode;

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

@@ -1,15 +1,25 @@
 import { refreshCompiledBootstrapGuidance, } from "../agents/lib/compiled-bootstrap.js";
-import { validateMethodPackage } from "../method-package/local-methods.js";
-import { reportValidationFailure, } from "../method-package/method-helpers.js";
+import { validateMethodPackage } from "../../methods/package/local-methods.js";
+import { reportValidationFailure, } from "../../methods/package/method-helpers.js";
 import { validateCompiledMethod, } from "./validate.js";
 import { pruneStageExecutionShells, } from "../agents/lib/shells.js";
 import { resetCompiledGeneratedState } from "./reset.js";
-import { syncCompiledRawSnapshot } from "./raw-snapshot.js";
 import { compiledExecutionStages, resolveCompiledContext, } from "./compiled-target.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { runCompiledStage } from "./compiled-stage-runner.js";
-import { resolveSourceInputPath } from "../project-model/interf-detect.js";
+import { resolveSourceInputPath } from "../../project/interf-detect.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
+import { writeCompiledSourceRuntime } from "./source-files.js";
+function pickStageExecutor(fallback, stage, resolve) {
+    if (!resolve)
+        return fallback;
+    try {
+        return resolve(stage) ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
 export async function runCompiledSummarize(options) {
     const context = resolveCompiledContext(options.compiledPath);
     const stageDefinition = options.stageDefinition
@@ -23,8 +33,15 @@ export async function runCompiledSummarize(options) {
         };
     }
     const sourceCount = discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount;
+    writeCompiledSourceRuntime({
+        compiledPath: options.compiledPath,
+        methodId: context.methodId,
+        stageIds: [stageDefinition.id],
+        sourcePath: context.sourcePath,
+        runId: options.runId ?? null,
+    });
     const result = await runCompiledStage({
-        executor: options.executor,
+        executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
         compiledPath: options.compiledPath,
         reporter: options.reporter,
         reportStep: options.reportStep,
@@ -50,9 +67,16 @@ export async function runCompiledCompile(options) {
     try {
         const context = resolveCompiledContext(options.compiledPath);
         const stages = compiledExecutionStages(context.methodId, options.compiledPath);
+        writeCompiledSourceRuntime({
+            compiledPath: options.compiledPath,
+            methodId: context.methodId,
+            stageIds: stages.map((stage) => stage.id),
+            sourcePath: context.sourcePath,
+            runId: options.runId ?? null,
+        });
         for (const [index, stageDefinition] of stages.entries()) {
             const result = await runCompiledStage({
-                executor: options.executor,
+                executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: options.reportStep,
@@ -86,8 +110,6 @@ export async function compileCompiled(options) {
         failedStage: null,
     };
     try {
-        const sourceInputPath = resolveSourceInputPath(options.compiledPath);
-        syncCompiledRawSnapshot(options.compiledPath, sourceInputPath);
         refreshCompiledBootstrapGuidance(options.compiledPath);
         const methodValidation = validateMethodPackage(methodPackagePathForCompiled(options.compiledPath));
         if (!methodValidation.ok) {
@@ -107,10 +129,18 @@ export async function compileCompiled(options) {
             };
         }
         const context = resolveCompiledContext(options.compiledPath);
+        const sourceInputPath = resolveSourceInputPath(options.compiledPath);
         const stages = compiledExecutionStages(context.methodId, options.compiledPath);
+        writeCompiledSourceRuntime({
+            compiledPath: options.compiledPath,
+            methodId: context.methodId,
+            stageIds: stages.map((stage) => stage.id),
+            sourcePath: sourceInputPath,
+            runId: options.runId ?? null,
+        });
         for (const [index, stageDefinition] of stages.entries()) {
             const stageResult = await runCompiledStage({
-                executor: options.executor,
+                executor: pickStageExecutor(options.executor, stageDefinition, options.resolveStageExecutor),
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: true,

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

@@ -1,10 +1,10 @@
-import { type BuiltinCompiledZoneId } from "../method-package/builtin-compiled-method.js";
+import { type BuiltinCompiledZoneId } from "../../methods/package/builtin-compiled-method.js";
 import { type MethodCompiledSchema, type MethodCompiledZone, type MethodZoneId } from "./lib/schema.js";
 export interface MethodSchemaStageLike {
     id: string;
     writes: readonly string[];
 }
-export { BUILTIN_COMPILED_ZONE_IDS } from "../method-package/builtin-compiled-method.js";
+export { BUILTIN_COMPILED_ZONE_IDS } from "../../methods/package/builtin-compiled-method.js";
 export declare const METHOD_SCHEMA_FILE = "method.schema.json";
 export declare function methodSchemaFilePath(rootPath: string): string;
 export declare function resolveMethodSchemaPath(rootPath: string): string | null;

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

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked } from "../shared/parse.js";
-import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "../method-package/builtin-compiled-method.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
+import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "../../methods/package/builtin-compiled-method.js";
 import { MethodCompiledSchemaSchema, } from "./lib/schema.js";
-export { BUILTIN_COMPILED_ZONE_IDS } from "../method-package/builtin-compiled-method.js";
+export { BUILTIN_COMPILED_ZONE_IDS } from "../../methods/package/builtin-compiled-method.js";
 export const METHOD_SCHEMA_FILE = "method.schema.json";
 const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
 export function methodSchemaFilePath(rootPath) {

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

@@ -1,5 +1,5 @@
 import { type RuntimeStageContractDraft } from "./runtime.js";
-import { type MethodStageDefinition } from "../method-package/method-definitions.js";
+import { type MethodStageDefinition } from "../../methods/package/method-definitions.js";
 import { resolveCompiledContext, type CompiledStageExecutionDefinition } from "./compiled-target.js";
 import type { RuntimeStageInstructions } from "./lib/schema.js";
 export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<MethodStageDefinition, "id" | "reads" | "writes">): {

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

@@ -1,12 +1,12 @@
 import { join } from "node:path";
 import { buildRuntimeStageContract, } from "./runtime.js";
 import { discoverSourceFiles } from "./discovery.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
+import { listFilesRecursive } from "../../contracts/utils/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 { buildLocalSkillContractExtension, buildStageInstructions, methodCompileStageDirectory, } from "../../methods/package/method-helpers.js";
+import { getActiveCompiledStagePolicyNotes, resolveActiveCompiledStageAcceptance, } 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);
@@ -59,6 +59,10 @@ export function buildStageContract(compiledPath, stageDefinition, instructions)
         stageId: stageDefinition.id,
         stageLabel: stageDefinition.label,
         counts: buildStageCounts(compiledPath, stageDefinition),
+        extraReadArtifacts: [
+            ".interf/runtime/source-snapshot.json",
+            `.interf/runtime/stages/${stageDefinition.id}/inputs.json`,
+        ],
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
         methodNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),

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

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

@@ -1,11 +1,11 @@
-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): {
     compiledName: string;
     sourcePath: string;
-    controlPath: string;
+    prepDataDir: string;
     methodId: CompiledMethodId;
 };
 export declare function compiledExecutionStages(_methodId: CompiledMethodId, compiledPath: string): CompiledStageExecutionDefinition[];

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

@@ -1,12 +1,12 @@
-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}`);
     return {
         compiledName: config?.name ?? "compiled",
         sourcePath: resolveSourceFolderPath(compiledPath, config),
-        controlPath: resolveSourceControlPath(compiledPath),
+        prepDataDir: resolveSourceControlPath(compiledPath),
         methodId,
     };
 }

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

@@ -11,6 +11,7 @@ export * as runtimePrompt from "./runtime-prompt.js";
 export * as runtimeReconcile from "./runtime-reconcile.js";
 export * as runtimeRuns from "./runtime-runs.js";
 export * as runtimeTypes from "./runtime-types.js";
+export * as sourceFiles from "./source-files.js";
 export * as state from "./state.js";
 export * as stateArtifacts from "./state-artifacts.js";
 export * as stateHealth from "./state-health.js";

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

@@ -11,6 +11,7 @@ export * as runtimePrompt from "./runtime-prompt.js";
 export * as runtimeReconcile from "./runtime-reconcile.js";
 export * as runtimeRuns from "./runtime-runs.js";
 export * as runtimeTypes from "./runtime-types.js";
+export * as sourceFiles from "./source-files.js";
 export * as state from "./state.js";
 export * as stateArtifacts from "./state-artifacts.js";
 export * as stateHealth from "./state-health.js";

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, TestCaseExpectSchema, TestTargetTypeSchema, MethodIdSchema } from "../../contracts/lib/schema.js";
-export { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
+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";
 export type RuntimeStatus = "idle" | "running" | "compiled" | "stale" | "failed";
 export type CompiledStage = "idle" | "compiled" | "failed" | string;
 export declare const MethodZoneIdSchema: z.ZodString;
@@ -10,24 +10,24 @@ export declare const MethodCompiledZoneKindSchema: z.ZodEnum<{
     directory: "directory";
 }>;
 export declare const MethodZoneRoleSchema: z.ZodEnum<{
-    output: "output";
     runtime: "runtime";
+    output: "output";
     input: "input";
     working: "working";
 }>;
 export declare const CompiledStageStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
     failed: "failed";
-    idle: "idle";
     running: "running";
-    succeeded: "succeeded";
+    idle: "idle";
 }>;
 export declare const CompiledStageStateSchema: z.ZodObject<{
     contract_type: z.ZodOptional<z.ZodString>;
     status: z.ZodOptional<z.ZodEnum<{
+        succeeded: "succeeded";
         failed: "failed";
-        idle: "idle";
         running: "running";
-        succeeded: "succeeded";
+        idle: "idle";
     }>>;
     started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -43,10 +43,10 @@ export declare const CompiledStateSchema: z.ZodObject<{
     stages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         contract_type: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodEnum<{
+            succeeded: "succeeded";
             failed: "failed";
-            idle: "idle";
             running: "running";
-            succeeded: "succeeded";
+            idle: "idle";
         }>>;
         started_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         finished_at: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -94,8 +94,8 @@ export declare const CompiledHealthSchema: z.ZodObject<{
         compiled: "compiled";
         stale: "stale";
         failed: "failed";
-        idle: "idle";
         running: "running";
+        idle: "idle";
     }>;
     stage: z.ZodUnion<readonly [z.ZodEnum<{
         compiled: "compiled";
@@ -140,16 +140,6 @@ export declare const CompiledViewSpecSchema: z.ZodObject<{
         paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const CompiledRawSnapshotSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"compiled-raw-snapshot">;
-    version: z.ZodLiteral<1>;
-    generated_at: z.ZodString;
-    target_name: z.ZodString;
-    source_root: z.ZodString;
-    raw_root: z.ZodString;
-    source_total: z.ZodNumber;
-    sample_files: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
 export declare const MethodPurposeSchema: z.ZodObject<{
     label: z.ZodString;
     task_hint: z.ZodString;
@@ -157,8 +147,8 @@ export declare const MethodPurposeSchema: z.ZodObject<{
 export declare const MethodZoneSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
-        output: "output";
         runtime: "runtime";
+        output: "output";
         input: "input";
         working: "working";
     }>;
@@ -175,8 +165,8 @@ export declare const MethodZoneSchema: z.ZodObject<{
 export declare const MethodCompiledZoneSchema: z.ZodObject<{
     id: z.ZodString;
     role: z.ZodEnum<{
-        output: "output";
         runtime: "runtime";
+        output: "output";
         input: "input";
         working: "working";
     }>;
@@ -198,8 +188,8 @@ export declare const MethodSchemaSchema: z.ZodObject<{
     zones: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             input: "input";
             working: "working";
         }>;
@@ -222,8 +212,8 @@ export declare const MethodCompiledSchemaSchema: z.ZodObject<{
     zones: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         role: z.ZodEnum<{
-            output: "output";
             runtime: "runtime";
+            output: "output";
             input: "input";
             working: "working";
         }>;
@@ -275,12 +265,12 @@ export declare const RuntimeStageInstructionsSchema: z.ZodObject<{
     stage_skill_dir: z.ZodString;
     effective_mode: z.ZodEnum<{
         builtin: "builtin";
-        extend: "extend";
         override: "override";
+        extend: "extend";
     }>;
     local_mode: z.ZodNullable<z.ZodEnum<{
-        extend: "extend";
         override: "override";
+        extend: "extend";
     }>>;
     local_docs: z.ZodArray<z.ZodString>;
     mode_sources: z.ZodArray<z.ZodString>;
@@ -335,12 +325,12 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
         stage_skill_dir: z.ZodString;
         effective_mode: z.ZodEnum<{
             builtin: "builtin";
-            extend: "extend";
             override: "override";
+            extend: "extend";
         }>;
         local_mode: z.ZodNullable<z.ZodEnum<{
-            extend: "extend";
             override: "override";
+            extend: "extend";
         }>>;
         local_docs: z.ZodArray<z.ZodString>;
         mode_sources: z.ZodArray<z.ZodString>;
@@ -363,7 +353,6 @@ export declare const RuntimeStageContractSchema: z.ZodObject<{
     artifacts: z.ZodObject<{
         reads: z.ZodArray<z.ZodString>;
         writes: z.ZodArray<z.ZodString>;
-        verifies: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     policies: z.ZodObject<{
         execution_mode: z.ZodLiteral<"deterministic">;
@@ -392,9 +381,9 @@ export declare const RuntimeRunSchema: z.ZodObject<{
     stage_label: z.ZodString;
     contract_type: z.ZodString;
     status: z.ZodEnum<{
+        succeeded: "succeeded";
         failed: "failed";
         running: "running";
-        succeeded: "succeeded";
     }>;
     executor: z.ZodObject<{
         kind: z.ZodEnum<{
@@ -635,7 +624,13 @@ export type ViewSection = z.infer<typeof ViewSectionSchema>;
 export type ViewCard = z.infer<typeof ViewCardSchema>;
 export type CompiledHealth = z.infer<typeof CompiledHealthSchema>;
 export type CompiledViewSpec = z.infer<typeof CompiledViewSpecSchema>;
-export type CompiledRawSnapshot = z.infer<typeof CompiledRawSnapshotSchema>;
+export type SourceKind = z.infer<typeof SourceKindSchema>;
+export type Source = z.infer<typeof SourceSchema>;
+export type SourceFile = z.infer<typeof SourceFileSchema>;
+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 MethodCompiledSchema = z.infer<typeof MethodCompiledSchemaSchema>;
 export type MethodCompiledZoneKind = z.infer<typeof MethodCompiledZoneKindSchema>;

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

@@ -1,7 +1,7 @@
 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, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.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";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
 function isCompiledRelativePath(value) {
@@ -77,16 +77,6 @@ export const CompiledViewSpecSchema = z.object({
     cards: z.array(ViewCardSchema),
     sections: z.array(ViewSectionSchema),
 });
-export const CompiledRawSnapshotSchema = z.object({
-    kind: z.literal("compiled-raw-snapshot"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    source_root: z.string(),
-    raw_root: z.string(),
-    source_total: z.number(),
-    sample_files: z.array(z.string()),
-});
 export const MethodPurposeSchema = z.object({
     label: z.string().min(1),
     task_hint: z.string().min(1),
@@ -177,7 +167,6 @@ export const RuntimeStageContractSchema = z.object({
     artifacts: z.object({
         reads: z.array(z.string()),
         writes: z.array(z.string()),
-        verifies: z.array(z.string()).optional(),
     }),
     policies: z.object({
         execution_mode: z.literal("deterministic"),

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

@@ -0,0 +1,14 @@
+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;
+    kind: "compiled";
+    engineType: "compiled";
+    config: InterfConfig;
+}
+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, ResolveStageExecutor, } from "./compiled-compile.js";

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

@@ -1,8 +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";
-export { methodQueryDirectory, methodImproveDirectory, methodCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../method-package/method-helpers.js";
+import { DEFAULT_METHOD_ID } from "../../methods/method-resolution.js";
 export function detectCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
@@ -14,8 +13,8 @@ export function detectCompiled(cwd) {
         config: detected.config,
     };
 }
-export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath = sourcePath) {
-    return createCompiledScaffold(name, sourcePath, methodId, about, sourceFolderPath);
+export function createCompiled(name, sourcePath, methodId, about, sourceFolderPath) {
+    return createCompiledScaffold(name, sourcePath, methodId ?? DEFAULT_METHOD_ID, about, sourceFolderPath);
 }
 export function verifyCompiledCheck(check, compiledPath) {
     switch (check) {