@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{local-service → engine}/preparation-store.js

@@ -19,29 +19,14 @@
  *
  * Public callers reach this through the preparation-keyed HTTP routes.
  */
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { PreparationNameSchema, MethodIdSchema, } from "../contracts/lib/schema.js";
 import { preparationDataDir, preparationsRoot, } from "./instance-paths.js";
-import { saveSourceFolderConfig, loadSourceFolderConfig, } from "../project-model/source-config.js";
+import { saveSourceFolderConfig, loadSourceFolderConfig, } from "../project/source-config.js";
 function ensurePreparationsRoot() {
     mkdirSync(preparationsRoot(), { recursive: true });
 }
-function readSourceFolderBindingFromInterfJson(prepDataDir) {
-    const filePath = join(prepDataDir, "interf.json");
-    if (!existsSync(filePath))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(filePath, "utf8"));
-        const sourceFolder = raw.source_folder;
-        if (!sourceFolder?.path)
-            return null;
-        return { path: sourceFolder.path, about: sourceFolder.about ?? null };
-    }
-    catch {
-        return null;
-    }
-}
 function loadStoredPreparation(prepId) {
     const prepDataDir = preparationDataDir(prepId);
     if (!existsSync(prepDataDir) || !statSync(prepDataDir).isDirectory())
@@ -52,15 +37,15 @@ function loadStoredPreparation(prepId) {
     const preparation = config.preparations?.find((p) => p.name === prepId);
     if (!preparation)
         return null;
-    const binding = readSourceFolderBindingFromInterfJson(prepDataDir);
-    if (!binding?.path)
+    const sourceFolderPath = config.source_folder?.path;
+    if (!sourceFolderPath)
         return null;
     return {
         id: prepId,
         prepDataDir,
-        source: { kind: "local-folder", locator: binding.path },
-        methodId: preparation.method ?? "interf-default",
-        about: binding.about ?? null,
+        source: { kind: "local-folder", locator: sourceFolderPath },
+        methodId: preparation.method ?? null,
+        about: preparation.about ?? null,
         config: preparation,
         portableContextPath: join(prepDataDir, prepId),
         configPath: join(prepDataDir, "interf.json"),
@@ -95,7 +80,9 @@ export function getStoredPreparation(prepId) {
  */
 export function createStoredPreparation(runtime, input) {
     PreparationNameSchema.parse(input.id);
-    MethodIdSchema.parse(input.method_id);
+    if (input.method_id != null) {
+        MethodIdSchema.parse(input.method_id);
+    }
     const sourceLocator = resolve(input.source.locator);
     if (!existsSync(sourceLocator)) {
         throw new Error(`Source folder does not exist: ${sourceLocator}`);
@@ -112,7 +99,7 @@ export function createStoredPreparation(runtime, input) {
     const preparation = {
         name: input.id,
         path: input.id,
-        method: input.method_id,
+        ...(input.method_id ? { method: input.method_id } : {}),
         checks: (input.checks ?? []).map((check) => ({
             question: check.question,
             ...(check.answer ? { answer: check.answer } : {}),
@@ -124,7 +111,7 @@ export function createStoredPreparation(runtime, input) {
         ...(input.max_loops ? { max_loops: input.max_loops } : {}),
     };
     saveSourceFolderConfig(prepDataDir, {
-        source_folder: { path: sourceLocator, ...(input.about ? { about: input.about } : {}) },
+        source_folder: { path: sourceLocator },
         preparations: [preparation],
     });
     // Hand the synthetic workspace to the runtime so the existing
@@ -148,6 +135,50 @@ export function deleteStoredPreparation(runtime, prepId) {
     rmSync(prepDataDir, { recursive: true, force: true });
     return true;
 }
+/**
+ * Update mutable fields on an existing preparation (method binding,
+ * about text). Returns the freshly-loaded record. Throws if the
+ * preparation does not exist.
+ */
+export function updateStoredPreparation(prepId, patch) {
+    const stored = loadStoredPreparation(prepId);
+    if (!stored)
+        throw new Error(`Preparation not found: ${prepId}`);
+    if (patch.method_id !== undefined && patch.method_id !== null) {
+        MethodIdSchema.parse(patch.method_id);
+    }
+    const nextPreparation = {
+        ...stored.config,
+        ...(patch.method_id === null
+            ? { method: undefined }
+            : patch.method_id !== undefined
+                ? { method: patch.method_id }
+                : {}),
+        ...(patch.checks !== undefined
+            ? { checks: patch.checks.map((check) => ({
+                    question: check.question,
+                    ...(check.answer ? { answer: check.answer } : {}),
+                    ...(check.strictness ? { strictness: check.strictness } : {}),
+                    ...(check.expect ? { expect: check.expect } : {}),
+                })) }
+            : {}),
+    };
+    const aboutPatch = patch.about === undefined ? stored.about : patch.about;
+    const preparationWithAbout = aboutPatch
+        ? { ...nextPreparation, about: aboutPatch }
+        : (() => {
+            const { about: _omitAbout, ...rest } = nextPreparation;
+            return rest;
+        })();
+    saveSourceFolderConfig(stored.prepDataDir, {
+        source_folder: { path: stored.source.locator },
+        preparations: [preparationWithAbout],
+    });
+    const next = loadStoredPreparation(prepId);
+    if (!next)
+        throw new Error(`Failed to reload updated preparation ${prepId}`);
+    return next;
+}
 /**
  * Re-register every preparation directory with the runtime on startup so
  * synthetic workspaces survive a `interf web` restart.

package/dist/packages/{local-service → engine}/readiness-check-draft.d.ts

@@ -1,5 +1,5 @@
-import type { MethodExecutor } from "../agents/lib/executors.js";
-import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
+import type { MethodExecutor } from "./agents/lib/executors.js";
+import type { SourceReadinessCheck } from "../project/lib/schema.js";
 export declare function buildReadinessCheckDraftPrompt(options: {
     preparationName: string;
     sourceFolderPath: string;

package/dist/packages/{local-service → engine}/routes.d.ts

@@ -9,13 +9,23 @@ export declare const LOCAL_SERVICE_ROUTES: {
     readonly methods: "/v1/methods";
     readonly runs: "/v1/runs";
     readonly actionProposals: "/v1/action-proposals";
+    /**
+     * 0.14 single-active-agent shortcut. Kept as a back-compat shim
+     * over the role-map's `general` row in 0.15+.
+     */
     readonly executor: "/v1/executor";
+    /**
+     * 0.15 connected-agents primitive — registry, role-map, role list.
+     * `agents/{name}` and `agents/role-map` are sub-resources handled
+     * by string match in `server.ts`.
+     */
+    readonly agents: "/v1/agents";
     readonly openPath: "/v1/open-path";
 };
 /** Preparation-scoped sub-resources (relative to /v1/preparations/<id>/). */
 export declare const PREPARATION_SUBRESOURCES: {
     readonly compileRuns: "compile-runs";
-    readonly testRuns: "test-runs";
+    readonly verifyRuns: "verify-runs";
     readonly methodAuthoringRuns: "method-authoring-runs";
     readonly methodImprovementRuns: "method-improvement-runs";
     readonly readinessCheckDrafts: "readiness-check-drafts";
@@ -25,6 +35,29 @@ export declare const PREPARATION_SUBRESOURCES: {
     readonly readiness: "readiness";
     readonly sourceFiles: "source-files";
     readonly portableContext: "portable-context";
+    /**
+     * 0.16 — read a portable-context file (read-only, path-guarded
+     * inside the prep's portable-context root). Used by the locator
+     * pattern's `api-served` kind:
+     *   GET /v1/preparations/<id>/files/<relpath>
+     */
+    readonly files: "files";
+    /**
+     * 0.17 — per-Artifact detail. Returns the latest status, contributing
+     * stages, and proof refs for a Method-declared Artifact:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    readonly artifacts: "artifacts";
+};
+/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
+export declare const METHOD_SUBRESOURCES: {
+    readonly runs: "runs";
+    /**
+     * 0.16 — read a method package file (read-only, path-guarded inside
+     * the method root). Used by the locator pattern's `api-served` kind:
+     *   GET /v1/methods/<id>/files/<relpath>
+     */
+    readonly files: "files";
 };
 /** Run-scoped sub-resources (relative to /v1/runs/<run-id>/). */
 export declare const RUN_SUBRESOURCES: {
@@ -47,3 +80,5 @@ export declare function runResourcePath(runId: string): string;
 export declare function runSubresourcePath(runId: string, sub: keyof typeof RUN_SUBRESOURCES): string;
 /** Path builder: /v1/methods/<id>. */
 export declare function methodResourcePath(methodId: string): string;
+/** Path builder: /v1/methods/<id>/<subresource>. */
+export declare function methodSubresourcePath(methodId: string, sub: keyof typeof METHOD_SUBRESOURCES): string;

package/dist/packages/{local-service → engine}/routes.js

@@ -10,13 +10,23 @@ export const LOCAL_SERVICE_ROUTES = {
     methods: "/v1/methods",
     runs: "/v1/runs",
     actionProposals: "/v1/action-proposals",
+    /**
+     * 0.14 single-active-agent shortcut. Kept as a back-compat shim
+     * over the role-map's `general` row in 0.15+.
+     */
     executor: "/v1/executor",
+    /**
+     * 0.15 connected-agents primitive — registry, role-map, role list.
+     * `agents/{name}` and `agents/role-map` are sub-resources handled
+     * by string match in `server.ts`.
+     */
+    agents: "/v1/agents",
     openPath: "/v1/open-path",
 };
 /** Preparation-scoped sub-resources (relative to /v1/preparations/<id>/). */
 export const PREPARATION_SUBRESOURCES = {
     compileRuns: "compile-runs",
-    testRuns: "test-runs",
+    verifyRuns: "verify-runs",
     methodAuthoringRuns: "method-authoring-runs",
     methodImprovementRuns: "method-improvement-runs",
     readinessCheckDrafts: "readiness-check-drafts",
@@ -26,6 +36,29 @@ export const PREPARATION_SUBRESOURCES = {
     readiness: "readiness",
     sourceFiles: "source-files",
     portableContext: "portable-context",
+    /**
+     * 0.16 — read a portable-context file (read-only, path-guarded
+     * inside the prep's portable-context root). Used by the locator
+     * pattern's `api-served` kind:
+     *   GET /v1/preparations/<id>/files/<relpath>
+     */
+    files: "files",
+    /**
+     * 0.17 — per-Artifact detail. Returns the latest status, contributing
+     * stages, and proof refs for a Method-declared Artifact:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    artifacts: "artifacts",
+};
+/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
+export const METHOD_SUBRESOURCES = {
+    runs: "runs",
+    /**
+     * 0.16 — read a method package file (read-only, path-guarded inside
+     * the method root). Used by the locator pattern's `api-served` kind:
+     *   GET /v1/methods/<id>/files/<relpath>
+     */
+    files: "files",
 };
 /** Run-scoped sub-resources (relative to /v1/runs/<run-id>/). */
 export const RUN_SUBRESOURCES = {
@@ -59,3 +92,7 @@ export function runSubresourcePath(runId, sub) {
 export function methodResourcePath(methodId) {
     return `${LOCAL_SERVICE_ROUTES.methods}/${encodeURIComponent(methodId)}`;
 }
+/** Path builder: /v1/methods/<id>/<subresource>. */
+export function methodSubresourcePath(methodId, sub) {
+    return `${methodResourcePath(methodId)}/${METHOD_SUBRESOURCES[sub]}`;
+}

package/dist/packages/{local-service → engine}/run-observability.d.ts

@@ -1,6 +1,6 @@
-import { type ArtifactRef, type CompileRun } from "../execution/lib/schema.js";
-import { type LocalJobRunResource, type RunObservabilityResource, type TestRunResource } from "./lib/schema.js";
+import { type ArtifactRef, type CompileRun } from "./execution/lib/schema.js";
+import { type LocalJobRunResource, type RunObservabilityResource, type VerifyRunResource } from "./lib/schema.js";
 export declare function uniqueArtifacts(artifacts: ArtifactRef[]): ArtifactRef[];
 export declare function compileRunToObservability(run: CompileRun): RunObservabilityResource;
-export declare function testRunToObservability(run: TestRunResource): RunObservabilityResource;
+export declare function verifyRunToObservability(run: VerifyRunResource): RunObservabilityResource;
 export declare function jobRunToObservability(job: LocalJobRunResource): RunObservabilityResource;

package/dist/packages/{local-service → engine}/run-observability.js

@@ -1,4 +1,4 @@
-import { createRunEventTimestamp, } from "../execution/events.js";
+import { createRunEventTimestamp, } from "./execution/events.js";
 import { RunObservabilityResourceSchema, } from "./lib/schema.js";
 export function uniqueArtifacts(artifacts) {
     const seen = new Set();
@@ -79,7 +79,7 @@ function buildTraceStreamChunks(runId, events) {
         time: event.timestamp ?? null,
         type: event.type,
         scope: event.stage_id ?? event.step_id ?? event.type,
-        message: event.message ?? event.summary ?? event.error ?? event.type,
+        message: event.message ?? event.summary ?? event.error ?? event.reason ?? event.type,
     }), event));
 }
 function proofChecksForCompileRun(run) {
@@ -164,7 +164,6 @@ export function compileRunToObservability(run) {
                 stage_total: stage.stage_total ?? null,
                 reads: stage.contract?.reads ?? [],
                 writes: stage.contract?.writes ?? [],
-                acceptance: stage.contract?.acceptance ?? null,
                 executor: stage.executor ?? null,
             },
         }, stage.stage_id));
@@ -268,10 +267,10 @@ export function compileRunToObservability(run) {
         },
     });
 }
-export function testRunToObservability(run) {
+export function verifyRunToObservability(run) {
     const traceStatus = methodTraceRunStatus(run.status);
     const title = `Check readiness ${run.preparation}`;
-    const methodName = interfTraceName("test", title);
+    const methodName = interfTraceName("verify", title);
     const completedAt = run.finished_at ?? (traceStatus === "completed" || traceStatus === "failed" || traceStatus === "cancelled"
         ? run.started_at ?? new Date().toISOString()
         : undefined);
@@ -307,9 +306,10 @@ export function testRunToObservability(run) {
             deploymentId: "local-interf",
             methodName,
             input: {
-                kind: "test",
+                kind: "verify",
                 preparation: run.preparation,
-                mode: run.mode,
+                // 0.15 — verify runs always judge against compiled output.
+                mode: "compiled",
             },
         }),
     ];
@@ -318,7 +318,7 @@ export function testRunToObservability(run) {
             methodName,
             input: {
                 preparation: run.preparation,
-                mode: run.mode,
+                mode: "compiled",
             },
         }));
     }
@@ -350,7 +350,7 @@ export function testRunToObservability(run) {
             status: run.status === "failed" ? "failed" : "succeeded",
             input: {
                 preparation: run.preparation,
-                mode: run.mode,
+                mode: "compiled",
             },
             output: readinessRun ?? null,
         });
@@ -358,7 +358,7 @@ export function testRunToObservability(run) {
     for (const step of targetSteps) {
         const timestamp = run.started_at ?? run.finished_at ?? new Date().toISOString();
         events.push(traceEvent(run.run_id, "step_created", timestamp, eventIndex++, {
-            stepName: methodStepName("test", step.label),
+            stepName: methodStepName("verify", step.label),
             input: step.input,
         }, step.id));
         events.push(traceEvent(run.run_id, "step_started", timestamp, eventIndex++, {
@@ -388,7 +388,7 @@ export function testRunToObservability(run) {
         kind: "interf-run-observability",
         version: 1,
         run_id: run.run_id,
-        run_type: "test",
+        run_type: "verify",
         title,
         status: observableRunStatus(run.status),
         preparation: run.preparation,
@@ -401,7 +401,7 @@ export function testRunToObservability(run) {
         readiness: run.readiness ?? null,
         metrics: [
             { label: "Preparation", value: run.preparation },
-            { label: "Mode", value: run.mode },
+            { label: "Mode", value: "compiled" },
             { label: "Readiness checks", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : sourceFiles ? `${sourceFiles.passed_cases}/${sourceFiles.total_cases}` : "0/0" },
             { label: "Source files", value: sourceFiles ? `${sourceFiles.passed_cases}/${sourceFiles.total_cases}` : "-" },
             { label: "Portable context", value: compiled ? `${compiled.passed_cases}/${compiled.total_cases}` : "-" },
@@ -417,13 +417,13 @@ export function testRunToObservability(run) {
                 specVersion: 1,
                 executionContext: {
                     product: "Interf",
-                    run_type: "test",
+                    run_type: "verify",
                     preparation: run.preparation,
-                    mode: run.mode,
+                    mode: "compiled",
                 },
                 input: {
                     preparation: run.preparation,
-                    mode: run.mode,
+                    mode: "compiled",
                     source_path: run.source_path ?? null,
                     portable_context_path: run.portable_context_path ?? null,
                 },

package/dist/packages/{local-service → engine}/runtime-event-applier.d.ts

@@ -6,7 +6,7 @@
  * what lets the runtime coordinator stay small: every other handler can
  * compose these without learning the resource shape.
  */
-import { type CompileRun, type InterfRunEvent } from "../execution/lib/schema.js";
+import { type CompileRun, type InterfRunEvent } from "./execution/lib/schema.js";
 import { type LocalJobEvent, type LocalJobRunResource } from "./lib/schema.js";
 export declare function applyEventToCompileRun(run: CompileRun, event: InterfRunEvent): CompileRun;
 export declare function applyEventToLocalJob(run: LocalJobRunResource, event: LocalJobEvent): LocalJobRunResource;

package/dist/packages/{local-service → engine}/runtime-event-applier.js

@@ -86,6 +86,13 @@ export function applyEventToCompileRun(run, event) {
                 finished_at: run.finished_at ?? now,
                 events: [...run.events, event],
             };
+        case "run.cancelled":
+            return {
+                ...run,
+                status: "cancelled",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
         case "readiness.updated":
             return {
                 ...run,

package/dist/packages/{local-service → engine}/runtime-persistence.d.ts

@@ -1,10 +1,10 @@
-import { type CompileRun } from "../execution/lib/schema.js";
-import { type RuntimeRun } from "../compiler/lib/schema.js";
-import { type ActionProposalResource, type LocalJobRunResource, type TestRunResource } from "./lib/schema.js";
+import { type CompileRun } from "./execution/lib/schema.js";
+import { type RuntimeRun } from "./compile/lib/schema.js";
+import { type ActionProposalResource, type LocalJobRunResource, type VerifyRunResource } from "./lib/schema.js";
 export declare function compileRunsRoot(compiledPath: string): string;
 export declare function compileRunPath(compiledPath: string, runId: string): string;
-export declare function testRunsRoot(compiledPath: string): string;
-export declare function testRunPath(compiledPath: string, runId: string): string;
+export declare function verifyRunsRoot(compiledPath: string): string;
+export declare function verifyRunPath(compiledPath: string, runId: string): string;
 export declare function localJobsRoot(rootPath: string): string;
 export declare function localJobPath(rootPath: string, runId: string): string;
 export declare function actionProposalsRoot(rootPath: string): string;
@@ -21,7 +21,7 @@ export declare function readJsonOrNull<T>(filePath: string, schema: {
 }): T | null;
 export declare function listJsonFiles(dirPath: string): string[];
 export declare function readCompileRunAt(filePath: string): CompileRun | null;
-export declare function readTestRunAt(filePath: string): TestRunResource | null;
+export declare function readVerifyRunAt(filePath: string): VerifyRunResource | null;
 export declare function readLocalJobRunAt(filePath: string): LocalJobRunResource | null;
 export declare function readActionProposalAt(filePath: string): ActionProposalResource | null;
 /**

package/dist/packages/{local-service → engine}/runtime-persistence.js

@@ -7,11 +7,11 @@
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { dirname, join } from "node:path";
-import { CompileRunSchema, } from "../execution/lib/schema.js";
-import { compiledRuntimeRunHistoryPath, compiledRuntimeRoot, testRootForCompiled, } from "../compiler/compiled-paths.js";
-import { RuntimeRunSchema, } from "../compiler/lib/schema.js";
+import { CompileRunSchema, } from "./execution/lib/schema.js";
+import { compiledRuntimeRunHistoryPath, compiledRuntimeRoot, testRootForCompiled, } from "./compile/compiled-paths.js";
+import { RuntimeRunSchema, } from "./compile/lib/schema.js";
 import { asPreparationDataDir, preparationServiceActionProposalsRoot, preparationServiceJobsRoot, } from "../contracts/lib/preparation-paths.js";
-import { ActionProposalResourceSchema, LocalJobRunResourceSchema, TestRunResourceSchema, } from "./lib/schema.js";
+import { ActionProposalResourceSchema, LocalJobRunResourceSchema, VerifyRunResourceSchema, } from "./lib/schema.js";
 // ---- Path helpers --------------------------------------------------------
 export function compileRunsRoot(compiledPath) {
     return join(compiledRuntimeRoot(compiledPath), "compile-runs");
@@ -19,11 +19,11 @@ export function compileRunsRoot(compiledPath) {
 export function compileRunPath(compiledPath, runId) {
     return join(compileRunsRoot(compiledPath), `${runId}.json`);
 }
-export function testRunsRoot(compiledPath) {
+export function verifyRunsRoot(compiledPath) {
     return join(testRootForCompiled(compiledPath), "service-runs");
 }
-export function testRunPath(compiledPath, runId) {
-    return join(testRunsRoot(compiledPath), `${runId}.json`);
+export function verifyRunPath(compiledPath, runId) {
+    return join(verifyRunsRoot(compiledPath), `${runId}.json`);
 }
 export function localJobsRoot(rootPath) {
     return preparationServiceJobsRoot(asPreparationDataDir(rootPath));
@@ -75,8 +75,8 @@ export function listJsonFiles(dirPath) {
 export function readCompileRunAt(filePath) {
     return readJsonOrNull(filePath, CompileRunSchema);
 }
-export function readTestRunAt(filePath) {
-    return readJsonOrNull(filePath, TestRunResourceSchema);
+export function readVerifyRunAt(filePath) {
+    return readJsonOrNull(filePath, VerifyRunResourceSchema);
 }
 export function readLocalJobRunAt(filePath) {
     return readJsonOrNull(filePath, LocalJobRunResourceSchema);

package/dist/packages/{local-service → engine}/runtime-proposal-helpers.d.ts

@@ -1,4 +1,4 @@
-import { type SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type ActionProposalPlanActionType, type ActionProposalResource } from "./lib/schema.js";
 export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
 export type LocalTestMode = "source-files" | "compiled" | "both";

package/dist/packages/{local-service → engine}/runtime-proposal-helpers.js

@@ -6,12 +6,12 @@
  * helpers without booting a runtime.
  */
 import { existsSync } from "node:fs";
-import { AGENTS, } from "../agents/lib/constants.js";
-import { detectAgents, supportsAutomatedRuns, } from "../agents/lib/detection.js";
-import { loadUserConfig, } from "../agents/lib/user-config.js";
+import { AGENTS, } from "./agents/lib/constants.js";
+import { detectAgents, supportsAutomatedRuns, } from "./agents/lib/detection.js";
+import { loadUserConfig, } from "./agents/lib/user-config.js";
 import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../project-model/source-config.js";
-import { createCompiledTestTarget, } from "../testing/test-targets.js";
+import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../project/source-config.js";
+import { createCompiledTestTarget, } from "./verify/verify-targets.js";
 import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, } from "./action-values.js";
 import { ActionProposalPlanActionTypeSchema, } from "./lib/schema.js";
 export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";

package/dist/packages/{local-service → engine}/runtime-resource-builders.d.ts

@@ -6,14 +6,14 @@
  * Splitting these out keeps the runtime coordinator focused on
  * orchestration rather than payload formatting.
  */
-import { type ArtifactRef, type ProofRecord } from "../execution/lib/schema.js";
-import { type CompiledState } from "../compiler/state.js";
-import { type RuntimeRun } from "../compiler/lib/schema.js";
-import { type ReadinessState, type ReadinessTargetResult } from "../contracts/lib/schema.js";
-import { type TestRunTargetSummary } from "../testing/lib/schema.js";
-import { type SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type ArtifactRef, type ProofRecord } from "./execution/lib/schema.js";
+import { type CompiledState } from "./compile/state.js";
+import { type RuntimeRun } from "./compile/lib/schema.js";
+import { type Artifact, type Readiness, type VerifyTargetResult } from "../contracts/lib/schema.js";
+import { type TestRunTargetSummary } from "./verify/lib/schema.js";
+import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type MethodResource, type PreparationResource } from "./lib/schema.js";
-export declare function createRunId(prefix: "compile" | "test" | "job"): string;
+export declare function createRunId(prefix: "compile" | "verify" | "job"): string;
 export declare function stageArtifactRefs(stageId: string, artifacts: string[] | undefined): ArtifactRef[];
 export declare function proofForStage(options: {
     runId: string;
@@ -35,10 +35,10 @@ export declare function logsForRuntimeRun(run: RuntimeRun | undefined): {
     prompt_path?: string | undefined;
 } | undefined;
 export declare function passRate(passed: number, total: number): number | null;
-export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): ReadinessTargetResult | null;
-export declare function readinessSummaryForStatus(status: ReadinessState["status"]): string;
-export declare function readinessStateToPreparationReadiness(readiness: ReadinessState): ReadinessState;
-export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: ReadinessState, latestCompileRunId: string | null, latestTestRunId: string | null): PreparationResource;
+export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): VerifyTargetResult | null;
+export declare function readinessSummaryForStatus(status: Readiness["status"]): string;
+export declare function readinessStateToPreparationReadiness(readiness: Readiness): Readiness;
+export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: Readiness, latestCompileRunId: string | null, latestTestRunId: string | null, artifacts?: PreparationResource["artifacts"]): PreparationResource;
 export declare function buildMethodResource(resource: {
     id: string;
     path: string;
@@ -47,6 +47,6 @@ export declare function buildMethodResource(resource: {
     source_kind: "builtin" | "local";
     built_in: boolean;
     active_for_preparations: string[];
-    output_paths: string[];
+    artifacts: Artifact[];
     stages: MethodResource["stages"];
 }): MethodResource;

package/dist/packages/{local-service → engine}/runtime-resource-builders.js

@@ -1,5 +1,5 @@
-import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
-import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project-model/source-config.js";
+import { ReadinessSchema, } from "../contracts/lib/schema.js";
+import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project/source-config.js";
 import { MethodResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
 export function createRunId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -101,12 +101,12 @@ export function readinessSummaryForStatus(status) {
     return "Latest preparation failed.";
 }
 export function readinessStateToPreparationReadiness(readiness) {
-    return ReadinessStateSchema.parse({
+    return ReadinessSchema.parse({
         ...readiness,
         checks: readiness.checks.map((check) => ({ ...check })),
     });
 }
-export function buildPreparationResource(rootPath, preparation, readiness, latestCompileRunId, latestTestRunId) {
+export function buildPreparationResource(rootPath, preparation, readiness, latestCompileRunId, latestTestRunId, artifacts = []) {
     const methodId = methodIdForSourcePreparationConfig(preparation);
     return PreparationResourceSchema.parse({
         id: preparation.name,
@@ -131,6 +131,7 @@ export function buildPreparationResource(rootPath, preparation, readiness, lates
         },
         latest_compile_run_id: latestCompileRunId,
         latest_test_run_id: latestTestRunId,
+        artifacts,
     });
 }
 export function buildMethodResource(resource) {
@@ -143,7 +144,7 @@ export function buildMethodResource(resource) {
         source_kind: resource.source_kind,
         built_in: resource.built_in,
         active_for_preparations: resource.active_for_preparations,
-        output_paths: resource.output_paths,
+        artifacts: resource.artifacts,
         stages: resource.stages,
     });
 }