@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/engine/runtime.js

@@ -8,7 +8,7 @@ import { MethodListingCache, MtimeListingCache, ReadinessCache, RunListingCache,
 import { applyEventToCompileRun, applyEventToLocalJob, } from "./runtime-event-applier.js";
 import { buildMethodResource, buildPreparationResource, createRunId, logsForRuntimeRun, logsForStageRun, proofForStage, readinessStateToPreparationReadiness, readinessSummaryForStatus, readinessTargetResult, stageArtifactRefs, } from "./runtime-resource-builders.js";
 import { ACTION_PLANNER_CLARIFICATION_MESSAGE, actionAssistantMessage, actionCommandPreview, actionTypeFromValues, actionValueMethodTaskPrompt, configuredAgentName, createActionProposalId, detachMethodFromPreparation, detectedExecutorOptions, directServiceEndpointForAction, hasCompiledTestTarget, methodAuthoringHintFromPrompt, methodAuthoringPromptFallback, methodIdForProposal, methodLabelFromId, numberValue, requireSelectedMethod, sanitizeActionProposalPlan, stringValue, testModeFromValues, } from "./runtime-proposal-helpers.js";
-import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
+import { ReadinessSchema, } from "../contracts/lib/schema.js";
 import { discoverSourceFiles, } from "./compile/discovery.js";
 import { resetCompiledGeneratedState, } from "./compile/reset.js";
 import { ensurePortableContextScaffold, readInterfConfig, } from "../project/interf.js";
@@ -16,7 +16,8 @@ import { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePrep
 import { listSourceFolderChoices, } from "../project/source-folders.js";
 import { asPreparationDataDir, preparationPortableContextPath, userMethodsRoot, preparationConfigPath, preparationMethodPackagePath, preparationMethodsRoot, } from "../contracts/lib/preparation-paths.js";
 import { getCompiledMethod, listCompiledMethodChoices, } from "../methods/package/method-definitions.js";
-import { contextInterfaceArtifactPath, } from "../methods/package/context-interface.js";
+import { computeArtifactStatuses, } from "./compile/artifact-status.js";
+import { JsonlBillingEventSink, buildCompilationEventsForRun, defaultBillingEventLogPath, } from "./compile/billing-events.js";
 import { methodDefinitionPath, resolveMethodPackageSourcePath, } from "../methods/package/local-methods.js";
 import { seedLocalMethodPackageFromBase, } from "../methods/package/interf-method-package.js";
 import { PACKAGE_ROOT } from "../methods/package/lib/package-root.js";
@@ -24,7 +25,7 @@ import { resolveAgent, detectAgents, supportsAutomatedRuns, } from "./agents/lib
 import { loadUserConfig, saveUserConfig, } from "./agents/lib/user-config.js";
 import { loadAgentsRegistry, registerCustomAgent, unregisterCustomAgent, patchRoleMap, setActiveAgent, } from "./agents/registry.js";
 import { readSavedReadinessCheckRun, } from "./verify/readiness-check-run.js";
-import { createCompiledTestTarget, } from "./verify/test-targets.js";
+import { createCompiledTestTarget, } from "./verify/verify-targets.js";
 import { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalTypeSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, ServiceRegistryWorkspaceSchema, VerifyRunCreateRequestSchema, VerifyRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
 import { buildLocalServiceUrl, } from "./routes.js";
 import { MethodAuthoringActionValuesSchema, PreparationSetupActionValuesSchema, } from "./action-values.js";
@@ -33,6 +34,10 @@ import { compileRunToObservability, jobRunToObservability, verifyRunToObservabil
 const IDEMPOTENCY_TTL_MS = 60 * 60 * 1000;
 /** Idempotency cache size at which to schedule an opportunistic prune. */
 const IDEMPOTENCY_PRUNE_THRESHOLD = 64;
+const INTERRUPTED_COMPILE_RUN_MESSAGE = "Compile run interrupted because the Interf engine stopped before the run reached a terminal state.";
+function isTerminalCompileRunStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}
 export class LocalServiceRuntime {
     host;
     port;
@@ -62,6 +67,11 @@ export class LocalServiceRuntime {
      * when a compile run is launched and cleared once the run reaches a
      * terminal state. Each entry remembers where the persisted record lives
      * so cancel can mark it without re-resolving the Preparation.
+     *
+     * TODO(cloud): when the cloud variant lands, wire `RunLeaseStore`
+     * (see `cloud-seams.ts` B4.2) through this map. Multi-replica engines
+     * need a shared lease store so a replica can take over a run whose
+     * owning replica died.
      */
     activeCompileRuns = new Map();
     /**
@@ -71,6 +81,11 @@ export class LocalServiceRuntime {
      * tenants on the same engine (CSO finding: a malicious preparation could
      * otherwise hijack another preparation's run id by reusing its key).
      * Entries expire after `IDEMPOTENCY_TTL_MS`.
+     *
+     * TODO(cloud): when the cloud variant lands, wire `IdempotencyStore`
+     * (see `cloud-seams.ts` B4.1) through this map. Multi-replica engines
+     * need a shared store so retries that land on a different replica
+     * still hit the same dedupe entry.
      */
     idempotencyKeyCache = new Map();
     /**
@@ -85,6 +100,22 @@ export class LocalServiceRuntime {
     readinessCache = new ReadinessCache();
     sourceFilesCache = new MtimeListingCache();
     methodListingCache = new MethodListingCache();
+    /**
+     * 0.17 — sink for per-Artifact billing events. Set once at construction.
+     * Lazy-defaults to a per-run JSONL writer when no override was injected.
+     */
+    billingEventSink;
+    /**
+     * 0.17 — cloud-variant injection points. The local engine accepts
+     * these on the options surface but does not consume them yet — the
+     * in-process Maps remain authoritative for idempotency and
+     * run-lease state. The cloud variant fork will swap to these stores;
+     * the option-fields are documented here so the cloud build has a
+     * stable target. See `cloud-seams.ts` for the contracts.
+     */
+    cloudIdempotencyStore;
+    cloudRunLeaseStore;
+    cloudTokenValidator = null;
     constructor(options) {
         this.host = options.host;
         this.port = options.port;
@@ -93,6 +124,9 @@ export class LocalServiceRuntime {
         this.handlers = options.handlers ?? {};
         this.authToken = options.authToken ?? null;
         this.rootPath = resolve(options.rootPath);
+        this.billingEventSink = options.billingEventSink ?? null;
+        this.cloudIdempotencyStore = options.idempotencyStore ?? null;
+        this.cloudRunLeaseStore = options.runLeaseStore ?? null;
         // Auto-register the initial preparation so single-preparation callers
         // (existing tests, the current `interf web` command) work without
         // additional bootstrapping. The constructor seed is the only role
@@ -103,6 +137,18 @@ export class LocalServiceRuntime {
     setBoundPort(port) {
         this.port = port;
     }
+    /**
+     * 0.17 — token validator setter for cloud variants. Stored on the
+     * runtime so `isAuthorizedMutation` in `server.ts` can opt into the
+     * async per-account check when present. Local default: never set —
+     * the static bearer-token check runs.
+     */
+    setTokenValidator(validator) {
+        this.cloudTokenValidator = validator;
+    }
+    getTokenValidator() {
+        return this.cloudTokenValidator;
+    }
     /** Set a hook that fires whenever the registered preparations change. */
     setOnRegistryChanged(handler) {
         this.onRegistryChanged = handler;
@@ -126,6 +172,7 @@ export class LocalServiceRuntime {
             lastActivity: now,
         };
         this.preparationContexts.set(resolved, context);
+        this.finalizeInterruptedCompileRuns(resolved);
         this.onRegistryChanged?.();
         return context;
     }
@@ -258,7 +305,11 @@ export class LocalServiceRuntime {
             const compileRuns = this.listCompileRunsForPreparation(prepDataDir, preparation.name);
             const verifyRuns = this.listVerifyRunsForPreparation(prepDataDir, preparation.name);
             const readiness = this.computePreparationReadiness(prepDataDir, preparation);
-            return buildPreparationResource(prepDataDir, preparation, readiness, compileRuns[0]?.run_id ?? null, verifyRuns[0]?.run_id ?? null);
+            return buildPreparationResource(prepDataDir, preparation, readiness, compileRuns[0]?.run_id ?? null, verifyRuns[0]?.run_id ?? null, 
+            // 0.17 — surface per-Artifact status from the latest compile
+            // run so the UI can render artifact rows on the Preparation
+            // page without a separate fetch.
+            compileRuns[0]?.artifacts ?? []);
         });
     }
     getPreparation(prepDataDir, preparationName) {
@@ -391,7 +442,7 @@ export class LocalServiceRuntime {
             return contextResult.total > 0 && contextResult.passed === contextResult.total ? "ready" : "not-ready";
         })();
         const ready = status === "ready";
-        return ReadinessStateSchema.parse({
+        return ReadinessSchema.parse({
             kind: "interf-readiness-state",
             version: 1,
             generated_at: generatedAt,
@@ -502,10 +553,7 @@ export class LocalServiceRuntime {
                     source_kind: method.scope === "builtin" ? "builtin" : "local",
                     built_in: method.scope === "builtin",
                     active_for_preparations: activeForPreparations,
-                    output_paths: (method.contextInterface?.zones ?? [])
-                        .filter((zone) => zone.role === "output")
-                        .map((zone) => contextInterfaceArtifactPath(zone))
-                        .sort(),
+                    artifacts: method.contextInterface?.artifacts ?? [],
                     stages: method.stages.map((stage) => ({
                         id: stage.id,
                         label: stage.label,
@@ -515,7 +563,6 @@ export class LocalServiceRuntime {
                         role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
                         reads: stage.reads,
                         writes: stage.writes,
-                        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
                     })),
                 });
             });
@@ -1030,6 +1077,7 @@ export class LocalServiceRuntime {
                         method_id: request.method_id,
                         label: request.label,
                         task_prompt: request.task_prompt,
+                        artifact_requirements: request.artifact_requirements.length,
                     },
                 },
                 {
@@ -1068,6 +1116,7 @@ export class LocalServiceRuntime {
                 method_id: request.method_id,
                 label: request.label,
                 task_prompt: request.task_prompt,
+                artifact_requirements: request.artifact_requirements.length,
             },
         });
         void this.runMethodAuthoringInBackground(prepDataDir, request, job.run_id);
@@ -1187,7 +1236,6 @@ export class LocalServiceRuntime {
                         stage_total: stageTotal,
                         reads: stage.reads,
                         writes: stage.writes,
-                        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
                     },
                     artifacts: [],
                 };
@@ -1226,7 +1274,7 @@ export class LocalServiceRuntime {
     }
     /**
      * Cancel an in-flight compile run. Marks the persisted record as
-     * `cancelled`, emits a `run.failed` event to capture the cancellation in
+     * `cancelled`, emits a `run.cancelled` event to capture the cancellation in
      * the run timeline, and clears the active handle so retries may start a
      * fresh run. If the run already finished, returns
      * `{ cancelled: false, reason: "already finished" }` and persists nothing.
@@ -1246,23 +1294,14 @@ export class LocalServiceRuntime {
         handle.cancelled = true;
         handle.cancelledAt = cancelledAt;
         const current = this.readCompileRun(handle.compiledPath, runId);
-        if (current && current.status !== "succeeded" && current.status !== "failed" && current.status !== "cancelled") {
-            const cancelledRun = {
-                ...current,
-                status: "cancelled",
-                finished_at: current.finished_at ?? cancelledAt,
-                events: [
-                    ...current.events,
-                    {
-                        type: "run.failed",
-                        event_id: createRunEventId("event"),
-                        run_id: runId,
-                        timestamp: cancelledAt,
-                        error: "Compile run cancelled by request.",
-                    },
-                ],
-            };
-            this.writeCompileRun(handle.prepDataDir, handle.compiledPath, cancelledRun);
+        if (current && !isTerminalCompileRunStatus(current.status)) {
+            this.writeCompileRun(handle.prepDataDir, handle.compiledPath, applyEventToCompileRun(current, {
+                type: "run.cancelled",
+                event_id: createRunEventId("event"),
+                run_id: runId,
+                timestamp: cancelledAt,
+                reason: "Compile run cancelled by request.",
+            }));
         }
         return { cancelled: true };
     }
@@ -1433,6 +1472,9 @@ export class LocalServiceRuntime {
                 });
             }
             await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, this.computePreparationReadiness(prepDataDir, context.preparationConfig)));
+            // 0.17 — emit per-Artifact billing events (stub form: JSONL).
+            // Production sink (Metronome HTTP) wires in 0.18+.
+            this.emitBillingEventsForRun(prepDataDir, context);
         }
         catch (error) {
             await this.recordCompileRunEvent(prepDataDir, context.compiledPath, context.runId, {
@@ -2066,6 +2108,81 @@ export class LocalServiceRuntime {
     readCompileRun(compiledPath, runId) {
         return readCompileRunAt(compileRunPath(compiledPath, runId));
     }
+    finalizeInterruptedCompileRuns(prepDataDir) {
+        let preparations;
+        try {
+            preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
+        }
+        catch {
+            return;
+        }
+        for (const preparation of preparations) {
+            const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
+            for (const run of listJsonFiles(compileRunsRoot(compiledPath))
+                .map(readCompileRunAt)
+                .filter((entry) => entry !== null)) {
+                if (isTerminalCompileRunStatus(run.status) || this.activeCompileRuns.has(run.run_id))
+                    continue;
+                const timestamp = createRunEventTimestamp();
+                const interruptedRun = {
+                    ...run,
+                    stages: run.stages.map((stage) => {
+                        if (stage.status !== "running")
+                            return stage;
+                        return {
+                            ...stage,
+                            status: "failed",
+                            finished_at: stage.finished_at ?? timestamp,
+                            summary: stage.summary ?? INTERRUPTED_COMPILE_RUN_MESSAGE,
+                            failure: stage.failure ?? INTERRUPTED_COMPILE_RUN_MESSAGE,
+                        };
+                    }),
+                };
+                this.writeCompileRun(prepDataDir, compiledPath, applyEventToCompileRun(interruptedRun, {
+                    type: "run.cancelled",
+                    event_id: createRunEventId("event"),
+                    run_id: run.run_id,
+                    timestamp,
+                    reason: INTERRUPTED_COMPILE_RUN_MESSAGE,
+                }));
+            }
+        }
+    }
+    /**
+     * 0.17 — emit per-Artifact billing events when a compile run reaches
+     * a terminal state. STUB FORM: writes a JSONL file alongside the run
+     * record by default. Production sink (Metronome HTTP) wires in 0.18+.
+     * The JSONL output is observability/dev fixture, NOT production
+     * billing data.
+     */
+    emitBillingEventsForRun(prepDataDir, context) {
+        try {
+            const run = this.readCompileRun(context.compiledPath, context.runId);
+            if (!run || run.artifacts.length === 0)
+                return;
+            const sink = this.billingEventSink ?? new JsonlBillingEventSink(defaultBillingEventLogPath({
+                preparationDataDir: prepDataDir,
+                preparationName: run.preparation,
+                runId: context.runId,
+            }));
+            const events = buildCompilationEventsForRun({
+                runId: context.runId,
+                preparation: run.preparation,
+                methodId: run.method,
+                accountId: null, // 0.17 — loopback only; cloud variant fills via tokenValidator (B4.3).
+                artifacts: run.artifacts,
+                startedAt: run.started_at ?? null,
+                finishedAt: run.finished_at ?? null,
+            });
+            for (const event of events) {
+                sink.emit(event);
+            }
+        }
+        catch {
+            // Billing is observability-only in 0.17; never let stub failures
+            // block a successful compile.
+        }
+    }
     writeCompileRun(prepDataDir, compiledPath, run) {
         mkdirSync(compileRunsRoot(compiledPath), { recursive: true });
         writeJsonFile(compileRunPath(compiledPath, run.run_id), CompileRunSchema.parse(run));
@@ -2156,6 +2273,19 @@ export class LocalServiceRuntime {
             }),
         };
         next.latest_proof = [...next.stages].reverse().find((stage) => Boolean(stage.latest_proof))?.latest_proof ?? next.latest_proof;
+        // Recompute per-Artifact status whenever the compile run is
+        // refreshed from runtime state.
+        try {
+            const method = getCompiledMethod(current.method, { prepDataDir });
+            next.artifacts = computeArtifactStatuses({
+                method,
+                compiledPath,
+                stageRuns: next.stages,
+            });
+        }
+        catch {
+            next.artifacts = current.artifacts ?? [];
+        }
         this.writeCompileRun(prepDataDir, compiledPath, next);
     }
     async emitRuntimeDerivedEvents(prepDataDir, compiledPath, runId) {

package/dist/packages/engine/server.d.ts

@@ -1,5 +1,7 @@
 import { type Server } from "node:http";
 import { type LocalServiceRunHandlers, type LocalServiceRuntime } from "./runtime.js";
+import type { IdempotencyStore, RunLeaseStore, TokenValidator } from "./cloud-seams.js";
+import type { BillingEventSink } from "./compile/billing-events.js";
 /** Generate a fresh per-instance bearer token. */
 export declare function createLocalServiceAuthToken(): string;
 export interface StartLocalServiceOptions {
@@ -21,6 +23,29 @@ export interface StartLocalServiceOptions {
      * and any caller that explicitly opts in).
      */
     authToken?: string | null | "auto";
+    /**
+     * 0.17 — cloud-variant auth seam (B4.3). When provided, every
+     * mutating request runs through this validator instead of the local
+     * constant-time bearer check, and the resulting `account_id` is
+     * stashed on the runtime context for billing-event attribution.
+     * Local default: `undefined` — fall back to `runtime.authToken`
+     * comparison.
+     */
+    tokenValidator?: TokenValidator;
+    /**
+     * 0.17 — cloud-variant interface seams forwarded to
+     * `LocalServiceRuntime`. Local default: in-process `Map`s on the
+     * runtime. Cloud variants pass shared implementations (Redis,
+     * Cassandra, etc.) so multi-replica engines coordinate. See
+     * `cloud-seams.ts` for the contracts.
+     */
+    idempotencyStore?: IdempotencyStore;
+    runLeaseStore?: RunLeaseStore;
+    /**
+     * 0.17 — billing event sink. Local default writes per-run JSONL.
+     * Cloud variants inject a Metronome HTTP sender once 0.18+ ships.
+     */
+    billingEventSink?: BillingEventSink;
 }
 export interface StartedLocalService {
     runtime: LocalServiceRuntime;

package/dist/packages/engine/server.js

@@ -309,9 +309,18 @@ function sendFile(res, filePath) {
     try {
         if (!statSync(filePath).isFile())
             return false;
-        writeHeaders(res, 200, {
-            "content-type": contentType(filePath),
-        });
+        const type = contentType(filePath);
+        const headers = { "content-type": type };
+        // 0.17 — never cache HTML responses. UI deploys ship a fresh
+        // dist via `npm run web:build` and a restart; without `no-store`,
+        // a browser sitting on a stale `index.html` would keep loading
+        // hashed asset paths that no longer exist. Hashed Next.js bundles
+        // under `_next/static/<hash>/` keep the default long-cache
+        // because the filename itself changes when content changes.
+        if (type.startsWith("text/html")) {
+            headers["cache-control"] = "no-store";
+        }
+        writeHeaders(res, 200, headers);
         res.end(readFileSync(filePath));
         return true;
     }
@@ -497,6 +506,17 @@ async function routeApi(req, res, runtime) {
                 sendError(res, 400, "Missing required field: source.locator");
                 return true;
             }
+            // TODO(cloud): activate remote-folder validator branch when the
+            // cloud variant lands. The local binary only knows how to read
+            // bytes from a local path; a `remote-folder` binding requires
+            // the cloud variant's per-account object-storage mount layer.
+            // Until then, reject any kind other than `local-folder` so the
+            // wire shape and runtime stay consistent.
+            const requestedKind = typeof body.source.kind === "string" ? body.source.kind : "local-folder";
+            if (requestedKind !== "local-folder") {
+                sendError(res, 400, `Unsupported source kind: ${requestedKind}. The local engine only accepts local-folder bindings; remote-folder requires the cloud variant.`);
+                return true;
+            }
             const stored = createStoredPreparation(runtime, {
                 id: body.id,
                 source: { kind: "local-folder", locator: body.source.locator },
@@ -544,6 +564,7 @@ async function routeApi(req, res, runtime) {
                     const updated = updateStoredPreparation(decodedPrepId, {
                         method_id: body.method_id,
                         about: body.about,
+                        ...(body.checks !== undefined ? { checks: body.checks } : {}),
                     });
                     sendJson(res, 200, preparationWireShape(updated));
                 }
@@ -738,6 +759,29 @@ async function routeApi(req, res, runtime) {
                 return true;
             }
         }
+        else if (subPath.startsWith(`${PREPARATION_SUBRESOURCES.artifacts}/`)) {
+            // GET /v1/preparations/<id>/artifacts/<artifact-id> — per-Artifact
+            // status from the latest compile run. 0.17.
+            if (method === "GET") {
+                const rawArtifactId = subPath.slice(PREPARATION_SUBRESOURCES.artifacts.length + 1);
+                let artifactId;
+                try {
+                    artifactId = decodeURIComponent(rawArtifactId);
+                }
+                catch {
+                    sendError(res, 400, "Artifact id is not valid URI-encoded UTF-8.");
+                    return true;
+                }
+                const preparation = runtime.getPreparation(storedPrep.prepDataDir, storedPrep.id);
+                const status = preparation?.artifacts.find((entry) => entry.artifact_id === artifactId);
+                if (!status) {
+                    sendError(res, 404, `Artifact not found: ${artifactId}`);
+                    return true;
+                }
+                sendJson(res, 200, status);
+                return true;
+            }
+        }
         sendError(res, 404, `Unknown preparation sub-route: ${subPath}`);
         return true;
     }
@@ -1181,7 +1225,22 @@ export async function startLocalService(options = {}) {
         packageVersion: options.packageVersion,
         handlers: options.handlers,
         ...(authToken ? { authToken } : {}),
+        // 0.17 — forward cloud-variant injection points. Local default
+        // ignores idempotencyStore / runLeaseStore (the runtime's
+        // in-process maps stay authoritative); they're accepted on the
+        // options surface so cloud forks have a stable target.
+        ...(options.billingEventSink ? { billingEventSink: options.billingEventSink } : {}),
+        ...(options.idempotencyStore ? { idempotencyStore: options.idempotencyStore } : {}),
+        ...(options.runLeaseStore ? { runLeaseStore: options.runLeaseStore } : {}),
     });
+    // 0.17 — token validator (B4.3). Local default: undefined. Cloud
+    // variants pass an async per-account validator. Stashed on the
+    // runtime via `setTokenValidator` so `isAuthorizedMutation` can
+    // pick it up; the local engine ignores it (the static bearer
+    // check still runs).
+    if (options.tokenValidator) {
+        runtime.setTokenValidator(options.tokenValidator);
+    }
     // Rehydrate 0.13 preparations as synthetic workspaces so subsequent
     // compile / test / readiness calls find them after a service restart.
     try {

package/dist/packages/engine/verify/index.d.ts

@@ -1,13 +1,13 @@
 export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
+export * as verify from "./verify.js";
+export * as execution from "./verify-execution.js";
+export * as paths from "./verify-paths.js";
+export * as profilePresets from "./verify-profile-presets.js";
 export * as readinessCheckRun from "./readiness-check-run.js";
-export * as sandbox from "./test-sandbox.js";
-export * as specs from "./test-specs.js";
-export * as targets from "./test-targets.js";
-export * as types from "./test-types.js";
+export * as sandbox from "./verify-sandbox.js";
+export * as specs from "./verify-specs.js";
+export * as targets from "./verify-targets.js";
+export * as types from "./verify-types.js";
 export type { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, ReadinessCheckRun, TestTargetType, } from "./lib/schema.js";
-export type { LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
-export type { TestSandboxRetentionMode, } from "./test-sandbox.js";
+export type { LoadedTestSpec, TestTargetCandidate, } from "./verify-types.js";
+export type { TestSandboxRetentionMode, } from "./verify-sandbox.js";

package/dist/packages/engine/verify/index.js

@@ -1,10 +1,10 @@
 export * as schema from "./lib/schema.js";
-export * as test from "./test.js";
-export * as execution from "./test-execution.js";
-export * as paths from "./test-paths.js";
-export * as profilePresets from "./test-profile-presets.js";
+export * as verify from "./verify.js";
+export * as execution from "./verify-execution.js";
+export * as paths from "./verify-paths.js";
+export * as profilePresets from "./verify-profile-presets.js";
 export * as readinessCheckRun from "./readiness-check-run.js";
-export * as sandbox from "./test-sandbox.js";
-export * as specs from "./test-specs.js";
-export * as targets from "./test-targets.js";
-export * as types from "./test-types.js";
+export * as sandbox from "./verify-sandbox.js";
+export * as specs from "./verify-specs.js";
+export * as targets from "./verify-targets.js";
+export * as types from "./verify-types.js";

package/dist/packages/engine/verify/readiness-check-run.d.ts

@@ -1,7 +1,8 @@
 import type { MethodExecutor } from "../agents/lib/executors.js";
 import type { SourcePreparationConfig } from "../../project/lib/schema.js";
-import { type TestTargetCandidate, type TestTargetResult } from "./test.js";
-import type { TestSandboxRetentionMode } from "./test-sandbox.js";
+import type { TestTargetType } from "../../contracts/lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "./verify.js";
+import type { TestSandboxRetentionMode } from "./verify-sandbox.js";
 import { type ReadinessCheckRun } from "./lib/schema.js";
 export interface SavedReadinessCheckOutcome {
     runPath: string;
@@ -14,8 +15,9 @@ export interface ReadinessCheckRunResult {
     preparationConfig: SourcePreparationConfig;
     portableContextPath: string | null;
     /**
-     * 0.15 — `sourceFilesOutcome` is always `null`. Kept on the type so
-     * older readers parse cleanly during the rollout; remove in 0.16+.
+     * 0.17 — restored. Populated when the verify run targets
+     * `source-files`; null when targeting `compiled`. Aggregates back
+     * onto the saved `ReadinessCheckRun` payload's `source_files` field.
      */
     sourceFilesOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
@@ -39,6 +41,7 @@ export declare function saveReadinessCheckRun(options: {
     portableContextPath: string | null;
     preparationName: string;
     checksFingerprint: string;
+    sourceFilesOutcome?: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
 }): string;
 export declare function runSavedPortableContextCheck(options: {
@@ -49,6 +52,20 @@ export declare function runSavedPortableContextCheck(options: {
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedReadinessCheckOutcome | null>;
+/**
+ * 0.17 — restored. Runs the saved readiness checks against the source
+ * folder baseline (no portable-context indirection) so users can see how
+ * much value the Method actually adds. The lower-level `verify-execution`
+ * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
+ * this is the orchestrator hook that was missing.
+ */
+export declare function runSavedSourceFilesCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
 export declare function runReadinessChecksForExecutor(options: {
     sourcePath: string;
     preparationConfig: SourcePreparationConfig;
@@ -57,4 +74,10 @@ export declare function runReadinessChecksForExecutor(options: {
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
     saveLatest?: boolean;
+    /**
+     * 0.17 — selects which target the readiness checks judge against.
+     * Defaults to `compiled` for backward compatibility with existing
+     * callers.
+     */
+    target?: TestTargetType;
 }): Promise<ReadinessCheckRunResult>;