@interf/compiler 0.13.0 → 0.18.0

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

@@ -1,37 +1,43 @@
 import { existsSync, mkdirSync, rmSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { CompileRunSchema, } from "../execution/lib/schema.js";
-import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
-import { loadState, } from "../compiler/state.js";
-import { actionProposalPath, actionProposalsRoot, byCreatedAtDesc, compileRunPath, compileRunsRoot, listJsonFiles, localJobPath, localJobsRoot, newestFirst, readActionProposalAt, readCompileRunAt, readLocalJobRunAt, readRuntimeRunHistory, readTestRunAt, testRunPath, testRunsRoot, timestampKey, writeJsonFile, } from "./runtime-persistence.js";
+import { CompileRunSchema, } from "./execution/lib/schema.js";
+import { createRunEventId, createRunEventTimestamp, } from "./execution/events.js";
+import { loadState, } from "./compile/state.js";
+import { actionProposalPath, actionProposalsRoot, byCreatedAtDesc, compileRunPath, compileRunsRoot, listJsonFiles, localJobPath, localJobsRoot, newestFirst, readActionProposalAt, readCompileRunAt, readLocalJobRunAt, readRuntimeRunHistory, readVerifyRunAt, verifyRunPath, verifyRunsRoot, timestampKey, writeJsonFile, } from "./runtime-persistence.js";
 import { MethodListingCache, MtimeListingCache, ReadinessCache, RunListingCache, } from "./runtime-caches.js";
 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, testModeValue, } from "./runtime-proposal-helpers.js";
-import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
-import { discoverSourceFiles, } from "../compiler/discovery.js";
-import { resetCompiledGeneratedState, } from "../compiler/reset.js";
-import { ensurePortableContextScaffold, readInterfConfig, } from "../project-model/interf.js";
-import { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, removeSourcePreparationConfig, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project-model/source-config.js";
-import { listSourceFolderChoices, } from "../project-model/source-folders.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 { 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";
+import { findSourcePreparationConfig, fingerprintReadinessChecks, listSourcePreparationConfigs, loadSourceFolderConfig, DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, removeSourcePreparationConfig, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../project/source-config.js";
+import { listSourceFolderChoices, } from "../project/source-folders.js";
 import { asPreparationDataDir, preparationPortableContextPath, userMethodsRoot, preparationConfigPath, preparationMethodPackagePath, preparationMethodsRoot, } from "../contracts/lib/preparation-paths.js";
-import { getCompiledMethod, listCompiledMethodChoices, } from "../method-package/method-definitions.js";
-import { contextInterfaceArtifactPath, } from "../method-package/context-interface.js";
-import { methodDefinitionPath, resolveMethodPackageSourcePath, seedLocalDefaultMethod, } from "../method-package/local-methods.js";
-import { seedLocalMethodPackageFromBase, } from "../method-package/interf-method-package.js";
-import { PACKAGE_ROOT } from "../method-package/lib/package-root.js";
-import { resolveAgent, detectAgents, supportsAutomatedRuns, } from "../agents/lib/detection.js";
-import { loadUserConfig, saveUserConfig, } from "../agents/lib/user-config.js";
-import { readSavedReadinessCheckRun, } from "../testing/readiness-check-run.js";
-import { createCompiledTestTarget, } from "../testing/test-targets.js";
-import { ActionProposalApprovalRequestSchema, ActionProposalCreateRequestSchema, ActionProposalPlanSchema, ActionProposalResourceSchema, ActionProposalTypeSchema, CompileRunCreateRequestSchema, CompileRunResourceSchema, LocalExecutorStatusSchema, LocalExecutorSelectRequestSchema, LocalServiceHealthSchema, LocalRunHandlerResultSchema, LocalJobEventAppendRequestSchema, LocalJobRunCreateRequestSchema, LocalJobRunResourceSchema, SourceFileResourceSchema, WorkspaceFileResourceSchema, PortableContextResourceSchema, PreparationSetupCreateRequestSchema, PreparationSetupResultSchema, WorkspaceBootstrapCreateRequestSchema, WorkspaceBootstrapResultSchema, MethodChangeCreateRequestSchema, MethodChangeResultSchema, PreparationChangeCreateRequestSchema, PreparationChangeResultSchema, ReadinessCheckDraftCreateRequestSchema, ReadinessCheckDraftResultSchema, ResetRequestSchema, ResetResultSchema, ServiceRegistryWorkspaceSchema, TestRunCreateRequestSchema, TestRunResourceSchema, MethodAuthoringCreateRequestSchema, MethodAuthoringResultSchema, } from "./lib/schema.js";
+import { getCompiledMethod, listCompiledMethodChoices, } from "../methods/package/method-definitions.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";
+import { resolveAgent, detectAgents, supportsAutomatedRuns, } from "./agents/lib/detection.js";
+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/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";
-import { compileRunToObservability, jobRunToObservability, testRunToObservability, uniqueArtifacts, } from "./run-observability.js";
+import { compileRunToObservability, jobRunToObservability, verifyRunToObservability, uniqueArtifacts, } from "./run-observability.js";
 /** TTL for `POST /v1/compile-runs` idempotency-key dedupe entries. */
 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;
@@ -51,25 +57,35 @@ export class LocalServiceRuntime {
      */
     authToken;
     /** Map of prepDataDir -> PreparationContext. */
-    workspaces = new Map();
-    /** Hook called whenever a workspace is registered or deregistered. */
+    preparationContexts = new Map();
+    /** Hook called whenever a preparation is registered or deregistered. */
     onRegistryChanged = null;
-    /** In-flight runs across all workspaces. Used for `idle_for_seconds`. */
+    /** In-flight runs across all preparations. Used for `idle_for_seconds`. */
     activeRunCount = 0;
     /**
      * Active compile-run cancellation handles, keyed by run id. Populated
      * 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();
     /**
      * Idempotency-key cache for `POST /v1/compile-runs`. Outer key is the
-     * resolved workspace root; inner key is the client-supplied idempotency
-     * value. Namespacing per workspace prevents key collisions across
-     * tenants on the same engine (CSO finding: a malicious workspace could
-     * otherwise hijack another workspace's run id by reusing its key).
+     * resolved preparation root; inner key is the client-supplied idempotency
+     * value. Namespacing per preparation prevents key collisions across
+     * 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();
     /**
@@ -80,10 +96,26 @@ export class LocalServiceRuntime {
      * matching write path. See {@link runtime-caches} for design notes.
      */
     compileRunCache = new RunListingCache();
-    testRunCache = new RunListingCache();
+    verifyRunCache = new RunListingCache();
     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;
@@ -92,7 +124,10 @@ export class LocalServiceRuntime {
         this.handlers = options.handlers ?? {};
         this.authToken = options.authToken ?? null;
         this.rootPath = resolve(options.rootPath);
-        // Auto-register the initial workspace so single-workspace callers
+        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
         // `options.rootPath` plays; runtime methods take `prepDataDir`
@@ -102,18 +137,30 @@ export class LocalServiceRuntime {
     setBoundPort(port) {
         this.port = port;
     }
-    /** Set a hook that fires whenever the registered workspaces change. */
+    /**
+     * 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;
     }
     /**
-     * Register a workspace with this runtime. Returns the PreparationContext.
-     * Idempotent: re-registering an existing workspace updates `lastActivity`.
+     * Register a preparation with this runtime. Returns the PreparationContext.
+     * Idempotent: re-registering an existing preparation updates `lastActivity`.
      */
     registerPreparation(prepDataDir) {
         const resolved = resolve(prepDataDir);
         const now = new Date().toISOString();
-        const existing = this.workspaces.get(resolved);
+        const existing = this.preparationContexts.get(resolved);
         if (existing) {
             existing.lastActivity = now;
             this.onRegistryChanged?.();
@@ -124,57 +171,58 @@ export class LocalServiceRuntime {
             startedAt: now,
             lastActivity: now,
         };
-        this.workspaces.set(resolved, context);
+        this.preparationContexts.set(resolved, context);
+        this.finalizeInterruptedCompileRuns(resolved);
         this.onRegistryChanged?.();
         return context;
     }
     /**
-     * Remove a workspace from the runtime. Returns true if a workspace was
+     * Remove a preparation from the runtime. Returns true if a preparation was
      * removed.
      */
     deregisterPreparation(prepDataDir) {
         const resolved = resolve(prepDataDir);
-        const removed = this.workspaces.delete(resolved);
+        const removed = this.preparationContexts.delete(resolved);
         if (removed) {
             this.onRegistryChanged?.();
         }
         return removed;
     }
     /**
-     * Most recently active workspace, or the first registered if none has
+     * Most recently active preparation, or the first registered if none has
      * activity yet. Server code uses this as the fallback when a request
-     * omits the workspace header. Throws if no workspace is registered.
+     * does not specify a preparation. Throws if none are registered.
      */
     defaultPreparationDataDir() {
-        if (this.workspaces.size === 0) {
-            throw new Error("Local service has no registered workspaces.");
+        if (this.preparationContexts.size === 0) {
+            throw new Error("Local service has no registered preparations.");
         }
         let best = null;
         let bestKey = -Infinity;
-        for (const context of this.workspaces.values()) {
+        for (const context of this.preparationContexts.values()) {
             const key = Date.parse(context.lastActivity);
             if (Number.isFinite(key) && key > bestKey) {
                 best = context;
                 bestKey = key;
             }
         }
-        return (best ?? this.workspaces.values().next().value).rootPath;
+        return (best ?? this.preparationContexts.values().next().value).rootPath;
     }
-    /** Look up a workspace context by rootPath. */
+    /** Look up a preparation context by rootPath. */
     getPreparationContext(prepDataDir) {
-        return this.workspaces.get(resolve(prepDataDir)) ?? null;
+        return this.preparationContexts.get(resolve(prepDataDir)) ?? null;
     }
-    /** All registered workspaces, ordered by registration time. */
+    /** All registered preparations, ordered by registration time. */
     listRegisteredPreparations() {
-        return Array.from(this.workspaces.values()).sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
+        return Array.from(this.preparationContexts.values()).sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
     }
-    /** True when no workspaces are registered. */
-    hasNoWorkspaces() {
-        return this.workspaces.size === 0;
+    /** True when no preparations are registered. */
+    hasNoPreparations() {
+        return this.preparationContexts.size === 0;
     }
-    /** Number of registered workspaces. */
+    /** Number of registered preparations. */
     registeredPreparationCount() {
-        return this.workspaces.size;
+        return this.preparationContexts.size;
     }
     /** Increment in-flight run counter. Call when a long-running run starts. */
     beginActiveRun() {
@@ -185,22 +233,28 @@ export class LocalServiceRuntime {
         if (this.activeRunCount > 0)
             this.activeRunCount -= 1;
     }
-    /** Sum of in-flight runs across all workspaces. */
+    /** Sum of in-flight runs across all preparations. */
     activeRuns() {
         return this.activeRunCount;
     }
     /**
-     * Mark the workspace as recently active. Routes call this on entry so
+     * Mark the preparation as recently active. Routes call this on entry so
      * `idleForSeconds` and the registry snapshots stay in sync with the
      * actual request cadence.
      */
     touchPreparation(prepDataDir) {
-        const context = this.workspaces.get(resolve(prepDataDir));
+        const context = this.preparationContexts.get(resolve(prepDataDir));
         if (context) {
             context.lastActivity = new Date().toISOString();
         }
     }
-    /** Snapshot of registered workspaces for the registry / status output. */
+    /**
+     * Snapshot of registered preparations for the registry / status output.
+     * Wire shape (`ServiceRegistryWorkspace`) keeps the legacy
+     * "workspace" name for backward compatibility with the public health
+     * response and `~/.interf/services.json`. Synthetic-workspace bridge
+     * code; do not rename without coordinating an API break.
+     */
     registeredPreparationSnapshots() {
         return this.listRegisteredPreparations().map((context) => ServiceRegistryWorkspaceSchema.parse({
             control_path: context.rootPath,
@@ -208,7 +262,7 @@ export class LocalServiceRuntime {
             last_activity: context.lastActivity,
         }));
     }
-    /** Seconds since the most recent workspace activity (0 if active). */
+    /** Seconds since the most recent preparation activity (0 if active). */
     idleForSeconds() {
         const all = this.listRegisteredPreparations();
         if (all.length === 0)
@@ -249,9 +303,13 @@ export class LocalServiceRuntime {
         const config = loadSourceFolderConfig(prepDataDir);
         return listSourcePreparationConfigs(config).map((preparation) => {
             const compileRuns = this.listCompileRunsForPreparation(prepDataDir, preparation.name);
-            const testRuns = this.listTestRunsForPreparation(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, testRuns[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) {
@@ -282,7 +340,7 @@ export class LocalServiceRuntime {
         const compiledTarget = createCompiledTestTarget(compiledPath, preparation.name, methodIdForSourcePreparationConfig(preparation) ?? DEFAULT_METHOD_ID);
         const contextReady = compiledTarget.eligible;
         const compileRun = this.listCompileRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
-        const testRun = this.listTestRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
+        const verifyRun = this.listVerifyRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
         const readinessRun = this.readLatestReadinessRun(prepDataDir, preparation.name);
         const configuredChecks = preparation.checks.length;
         const currentFingerprint = configuredChecks > 0 ? fingerprintReadinessChecks(preparation.checks) : null;
@@ -369,7 +427,7 @@ export class LocalServiceRuntime {
         const status = (() => {
             if (compileRun?.status === "queued" || compileRun?.status === "running")
                 return "building";
-            if (testRun?.status === "queued" || testRun?.status === "running")
+            if (verifyRun?.status === "queued" || verifyRun?.status === "running")
                 return "checking";
             if (compileRun?.status === "failed" || compileRun?.status === "cancelled")
                 return "failed";
@@ -384,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,
@@ -394,7 +452,7 @@ export class LocalServiceRuntime {
             summary: readinessSummaryForStatus(status),
             portable_context_path: contextReady ? compiledPath : null,
             latest_compile_run_id: compileRun?.run_id ?? null,
-            latest_test_run_id: testRun?.run_id ?? null,
+            latest_test_run_id: verifyRun?.run_id ?? null,
             compile: compileCheck,
             check_results: {
                 configured: configuredChecks,
@@ -406,10 +464,16 @@ export class LocalServiceRuntime {
         });
     }
     listSourceFiles(prepDataDir, preparationName) {
-        const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))
+        const config = loadSourceFolderConfig(prepDataDir);
+        const preparations = listSourcePreparationConfigs(config)
             .filter((preparation) => !preparationName || preparation.name === preparationName);
+        // 0.13+ source binding: the source folder is the user-supplied
+        // absolute path on `source_folder.path`. `preparation.path` is the
+        // portable-context name inside `prepDataDir` (legacy field; in the
+        // synthetic-workspace bridge it equals `preparation.name`). Walk
+        // the actual source bytes, not the portable-context subdir.
+        const sourceFolderPath = resolveConfiguredSourceFolderPath(prepDataDir, config) ?? prepDataDir;
         return preparations.flatMap((preparation) => {
-            const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, preparation);
             const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
             // Cache by source-folder root mtime so identical UI polls do not
             // re-walk and re-stat the entire tree. The cache imposes a short
@@ -489,19 +553,16 @@ 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,
                         description: stage.description,
                         contract_type: stage.contractType,
                         skill_dir: stage.skillDir,
+                        role: stage.role && stage.role.trim().length > 0 ? stage.role : "general",
                         reads: stage.reads,
                         writes: stage.writes,
-                        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
                     })),
                 });
             });
@@ -587,8 +648,48 @@ export class LocalServiceRuntime {
             skillsInstalled: current?.skillsInstalled ?? false,
             initialized: current?.initialized ?? new Date().toISOString(),
         });
+        // Mirror the selection into the 0.15 role-map. `setActiveAgent`
+        // also sweeps any role still pointing at the previous active so
+        // single-active-agent setups stay coherent across CLIs.
+        try {
+            setActiveAgent(selected.name);
+        }
+        catch {
+            // Best effort — the registry update is convenience for the new
+            // role-aware path. The user_config.json write above is the
+            // source of truth for the legacy `getExecutorStatus()`.
+        }
         return this.getExecutorStatus();
     }
+    // ─── 0.15 connected-agents primitive ─────────────────────────────
+    /**
+     * Snapshot of the merged agents registry (built-in detected + custom)
+     * with the current role-map and resolved active agent.
+     */
+    getAgentsRegistry() {
+        const registry = loadAgentsRegistry();
+        return {
+            agents: registry.agents,
+            role_map: registry.roleMap,
+            active_agent: registry.activeAgent,
+        };
+    }
+    registerCustomAgent(input) {
+        registerCustomAgent(input);
+        return this.getAgentsRegistry();
+    }
+    unregisterCustomAgent(name) {
+        unregisterCustomAgent(name);
+        return this.getAgentsRegistry();
+    }
+    patchAgentsRoleMap(patch) {
+        patchRoleMap(patch);
+        const registry = loadAgentsRegistry();
+        return {
+            role_map: registry.roleMap,
+            active_agent: registry.activeAgent,
+        };
+    }
     listActionProposals(prepDataDir) {
         return byCreatedAtDesc(listJsonFiles(actionProposalsRoot(prepDataDir))
             .map(readActionProposalAt)
@@ -654,7 +755,7 @@ export class LocalServiceRuntime {
     listRunObservability(prepDataDir) {
         return [
             ...this.listCompileRuns(prepDataDir).map((resource) => compileRunToObservability(resource.run)),
-            ...this.listTestRuns(prepDataDir).map(testRunToObservability),
+            ...this.listVerifyRuns(prepDataDir).map(verifyRunToObservability),
             ...this.listJobs(prepDataDir).map(jobRunToObservability),
         ].sort((left, right) => {
             const leftTime = timestampKey(left.started_at ?? left.created_at ?? left.finished_at);
@@ -665,6 +766,20 @@ export class LocalServiceRuntime {
     getRunObservability(prepDataDir, runId) {
         return this.listRunObservability(prepDataDir).find((run) => run.run_id === runId) ?? null;
     }
+    /**
+     * Method-scoped runs: every method-authoring or method-improvement job
+     * whose `method` matches `methodId`. Surfaced through
+     * `GET /v1/methods/<id>/runs` so Method Detail can show the full audit
+     * trail of authoring + improvement work for a Method.
+     */
+    listMethodRuns(prepDataDir, methodId) {
+        return this.listRunObservability(prepDataDir).filter((run) => {
+            if (run.method !== methodId)
+                return false;
+            return (run.run_type === "method-authoring" ||
+                run.run_type === "method-improvement");
+        });
+    }
     createJobRun(prepDataDir, requestValue) {
         const request = LocalJobRunCreateRequestSchema.parse(requestValue);
         const runId = createRunId("job");
@@ -848,74 +963,6 @@ export class LocalServiceRuntime {
                 : `Removed Method ${request.method}.`,
         });
     }
-    /**
-     * Bootstrap the workspace's source-folder binding and seed the default
-     * Method. Idempotent: re-running with the same source folder preserves
-     * existing preparations and reports `changed: false`.
-     *
-     * The CLI calls this in place of writing `interf.json` directly, so the
-     * operation is recorded by the service (and visible to other clients).
-     */
-    bootstrapWorkspace(prepDataDir, requestValue) {
-        const request = WorkspaceBootstrapCreateRequestSchema.parse(requestValue);
-        const requestedPath = request.source_folder?.path?.trim() ?? null;
-        const existing = loadSourceFolderConfig(prepDataDir);
-        const existingSourcePath = existing?.source_folder?.path ?? null;
-        const preparations = existing?.preparations ?? [];
-        let sourceFolderPath = existingSourcePath;
-        let sourceChanged = false;
-        if (requestedPath && requestedPath.length > 0) {
-            // Validate that the source folder exists relative to the workspace.
-            const resolvedSourcePath = resolve(prepDataDir, requestedPath);
-            if (!existsSync(resolvedSourcePath) || !statSync(resolvedSourcePath).isDirectory()) {
-                throw new Error(`Source folder "${requestedPath}" is not available.`);
-            }
-            if (existingSourcePath !== requestedPath) {
-                sourceFolderPath = requestedPath;
-                sourceChanged = true;
-            }
-        }
-        const writeNeeded = !existing || sourceChanged;
-        if (writeNeeded) {
-            saveSourceFolderConfig(prepDataDir, {
-                ...(sourceFolderPath ? { source_folder: { path: sourceFolderPath } } : {}),
-                preparations,
-            });
-            // Source folder rebound: drop every cached read for this workspace.
-            this.readinessCache.invalidateWorkspace(prepDataDir);
-            this.compileRunCache.invalidateWorkspace(prepDataDir);
-            this.testRunCache.invalidateWorkspace(prepDataDir);
-            this.sourceFilesCache.invalidateAll();
-            this.methodListingCache.invalidate(prepDataDir);
-        }
-        let seededMethodId = null;
-        let seededDefaultMethod = false;
-        if (request.seed_default_method) {
-            const seeded = seedLocalDefaultMethod({ prepDataDir });
-            seededMethodId = seeded.methodId;
-            seededDefaultMethod = !seeded.alreadyExisted;
-            if (seededDefaultMethod) {
-                this.methodListingCache.invalidate(prepDataDir);
-            }
-        }
-        const changed = writeNeeded || seededDefaultMethod;
-        return WorkspaceBootstrapResultSchema.parse({
-            kind: "interf-workspace-bootstrap-result",
-            version: 1,
-            control_path: prepDataDir,
-            config_path: preparationConfigPath(asPreparationDataDir(prepDataDir)),
-            source_folder_path: sourceFolderPath,
-            preparations: preparations.length,
-            seeded_default_method: seededDefaultMethod,
-            default_method_id: seededMethodId,
-            changed,
-            message: changed
-                ? sourceFolderPath
-                    ? `Workspace ready. Source Folder: ${sourceFolderPath}.`
-                    : `Workspace ready.`
-                : `Workspace already initialized.`,
-        });
-    }
     applyPreparationSetup(prepDataDir, requestValue) {
         const request = PreparationSetupCreateRequestSchema.parse(requestValue);
         const preparationConfig = request.preparation;
@@ -934,7 +981,7 @@ export class LocalServiceRuntime {
         // caches so the next read reflects the new shape.
         this.readinessCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
         this.compileRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
-        this.testRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
+        this.verifyRunCache.invalidatePreparation(prepDataDir, normalizedPreparationConfig.name);
         this.methodListingCache.invalidate(prepDataDir);
         const operation = request.setup_mode === "select-method" ? "select-method" : "create";
         return PreparationSetupResultSchema.parse({
@@ -964,7 +1011,7 @@ export class LocalServiceRuntime {
         removeSourcePreparationConfig(prepDataDir, request.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, request.preparation);
         this.compileRunCache.invalidatePreparation(prepDataDir, request.preparation);
-        this.testRunCache.invalidatePreparation(prepDataDir, request.preparation);
+        this.verifyRunCache.invalidatePreparation(prepDataDir, request.preparation);
         this.methodListingCache.invalidate(prepDataDir);
         return PreparationChangeResultSchema.parse({
             kind: "interf-preparation-change-result",
@@ -991,7 +1038,7 @@ export class LocalServiceRuntime {
         resetCompiledGeneratedState(compiledPath, request.scope);
         // Reset wipes generated state, including saved compile/test/readiness records.
         this.compileRunCache.invalidatePreparation(prepDataDir, request.preparation);
-        this.testRunCache.invalidatePreparation(prepDataDir, request.preparation);
+        this.verifyRunCache.invalidatePreparation(prepDataDir, request.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, request.preparation);
         return ResetResultSchema.parse({
             kind: "interf-reset-result",
@@ -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);
@@ -1085,7 +1134,7 @@ export class LocalServiceRuntime {
         const path = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparation.name);
         const config = readInterfConfig(path);
         const compileRuns = this.listCompileRunsForPreparation(prepDataDir, preparation.name);
-        const testRuns = this.listTestRunsForPreparation(prepDataDir, preparation.name);
+        const verifyRuns = this.listVerifyRunsForPreparation(prepDataDir, preparation.name);
         const readiness = this.computePreparationReadiness(prepDataDir, preparation);
         const method = config?.method ?? methodIdForSourcePreparationConfig(preparation);
         return PortableContextResourceSchema.parse({
@@ -1095,7 +1144,7 @@ export class LocalServiceRuntime {
             readiness,
             method,
             latest_compile_run_id: compileRuns[0]?.run_id ?? null,
-            latest_test_run_id: testRuns[0]?.run_id ?? null,
+            latest_test_run_id: verifyRuns[0]?.run_id ?? null,
             artifacts: uniqueArtifacts(compileRuns[0]?.stages.flatMap((stage) => stage.artifacts) ?? []),
         });
     }
@@ -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,31 +1294,22 @@ 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 };
     }
     /**
      * Look up the run id previously associated with this idempotency key in
      * `prepDataDir`. Returns null when the key is unknown or its TTL has
-     * elapsed. The workspace argument is required so that the same key in
-     * two different workspaces always returns two different runs.
+     * elapsed. The preparation argument is required so that the same key in
+     * two different preparations always returns two different runs.
      */
     findIdempotentCompileRun(prepDataDir, key) {
         const resolvedRoot = resolve(prepDataDir);
@@ -1313,7 +1352,7 @@ export class LocalServiceRuntime {
             this.pruneIdempotencyKeyCache();
         }
     }
-    /** Total cached idempotency entries across all workspaces. */
+    /** Total cached idempotency entries across all preparations. */
     totalIdempotencyEntries() {
         let total = 0;
         for (const bucket of this.idempotencyKeyCache.values())
@@ -1348,46 +1387,45 @@ export class LocalServiceRuntime {
         entry.expiresAt = Date.now() - 1;
         return true;
     }
-    listTestRuns(prepDataDir) {
+    listVerifyRuns(prepDataDir) {
         return newestFirst(listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir))
-            .flatMap((preparation) => this.listTestRunsForPreparation(prepDataDir, preparation.name)));
+            .flatMap((preparation) => this.listVerifyRunsForPreparation(prepDataDir, preparation.name)));
     }
-    listTestRunsForPreparation(prepDataDir, preparationName) {
-        return this.testRunCache.get(prepDataDir, preparationName, () => {
+    listVerifyRunsForPreparation(prepDataDir, preparationName) {
+        return this.verifyRunCache.get(prepDataDir, preparationName, () => {
             const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
-            return newestFirst(listJsonFiles(testRunsRoot(compiledPath))
-                .map(readTestRunAt)
+            return newestFirst(listJsonFiles(verifyRunsRoot(compiledPath))
+                .map(readVerifyRunAt)
                 .filter((run) => run !== null));
         }, (run) => run.run_id);
     }
-    getTestRun(prepDataDir, runId) {
-        const known = this.testRunCache.preparationFor(prepDataDir, runId);
+    getVerifyRun(prepDataDir, runId) {
+        const known = this.verifyRunCache.preparationFor(prepDataDir, runId);
         if (known) {
-            const found = this.listTestRunsForPreparation(prepDataDir, known).find((run) => run.run_id === runId);
+            const found = this.listVerifyRunsForPreparation(prepDataDir, known).find((run) => run.run_id === runId);
             if (found)
                 return found;
         }
-        return this.listTestRuns(prepDataDir).find((run) => run.run_id === runId) ?? null;
+        return this.listVerifyRuns(prepDataDir).find((run) => run.run_id === runId) ?? null;
     }
-    async createTestRun(prepDataDir, requestValue) {
-        const request = TestRunCreateRequestSchema.parse(requestValue);
+    async createVerifyRun(prepDataDir, requestValue) {
+        const request = VerifyRunCreateRequestSchema.parse(requestValue);
         const preparationConfig = this.resolvePreparationConfig(prepDataDir, request.preparation);
         const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationConfig.name);
         const compiledTarget = createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID);
-        const runId = createRunId("test");
+        const runId = createRunId("verify");
         const now = new Date().toISOString();
-        const initial = TestRunResourceSchema.parse({
+        const initial = VerifyRunResourceSchema.parse({
             run_id: runId,
             status: "running",
             preparation: preparationConfig.name,
-            mode: request.mode,
             source_path: prepDataDir,
             portable_context_path: compiledTarget.eligible ? compiledPath : null,
             started_at: now,
             readiness_run: null,
             events: [],
         });
-        this.writeTestRun(prepDataDir, compiledPath, initial);
+        this.writeVerifyRun(prepDataDir, compiledPath, initial);
         void this.runTestInBackground(prepDataDir, request, {
             runId,
             sourcePath: prepDataDir,
@@ -1434,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, {
@@ -1453,15 +1494,15 @@ export class LocalServiceRuntime {
     async runTestInBackground(prepDataDir, request, context, initial) {
         this.beginActiveRun();
         try {
-            if (!this.handlers.createTestRun) {
-                throw new Error("No test-run handler is configured for this local service.");
+            if (!this.handlers.createVerifyRun) {
+                throw new Error("No verify-run handler is configured for this local service.");
             }
-            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createTestRun(request, context));
+            const result = LocalRunHandlerResultSchema.parse(await this.handlers.createVerifyRun(request, context));
             const readinessRun = result.readiness_run ?? this.readLatestReadinessRun(prepDataDir, context.preparationConfig.name);
             const resultEvent = readinessRun
                 ? this.checksEvaluatedEvent(context.runId, readinessRun)
                 : null;
-            const nextWithoutReadiness = TestRunResourceSchema.parse({
+            const nextWithoutReadiness = VerifyRunResourceSchema.parse({
                 ...initial,
                 status: result.ok ? "succeeded" : "failed",
                 finished_at: new Date().toISOString(),
@@ -1469,9 +1510,9 @@ export class LocalServiceRuntime {
                 events: resultEvent ? [resultEvent] : [],
                 ...(!result.ok ? { error: result.error ?? "Readiness check failed." } : {}),
             });
-            this.writeTestRun(prepDataDir, context.compiledPath, nextWithoutReadiness);
+            this.writeVerifyRun(prepDataDir, context.compiledPath, nextWithoutReadiness);
             const readiness = this.computePreparationReadiness(prepDataDir, context.preparationConfig);
-            const next = TestRunResourceSchema.parse({
+            const next = VerifyRunResourceSchema.parse({
                 ...nextWithoutReadiness,
                 readiness,
                 events: [
@@ -1479,23 +1520,23 @@ export class LocalServiceRuntime {
                     this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness),
                 ],
             });
-            this.writeTestRun(prepDataDir, context.compiledPath, next);
+            this.writeVerifyRun(prepDataDir, context.compiledPath, next);
         }
         catch (error) {
-            const failedWithoutReadiness = TestRunResourceSchema.parse({
+            const failedWithoutReadiness = VerifyRunResourceSchema.parse({
                 ...initial,
                 status: "failed",
                 finished_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
             });
-            this.writeTestRun(prepDataDir, context.compiledPath, failedWithoutReadiness);
+            this.writeVerifyRun(prepDataDir, context.compiledPath, failedWithoutReadiness);
             const readiness = this.computePreparationReadiness(prepDataDir, context.preparationConfig);
-            const next = TestRunResourceSchema.parse({
+            const next = VerifyRunResourceSchema.parse({
                 ...failedWithoutReadiness,
                 readiness,
                 events: [this.readinessUpdatedEvent(context.runId, context.preparationConfig.name, readiness)],
             });
-            this.writeTestRun(prepDataDir, context.compiledPath, next);
+            this.writeVerifyRun(prepDataDir, context.compiledPath, next);
         }
         finally {
             this.endActiveRun();
@@ -1931,10 +1972,11 @@ export class LocalServiceRuntime {
                 };
             }
             if (actionType === "test") {
-                const defaultMode = hasCompiledTestTarget(prepDataDir, preparationConfig) ? "both" : "source-files";
+                // 0.15 — verify runs always judge against the compiled
+                // portable context. The legacy `mode` field is gone from the
+                // wire request shape.
                 return {
                     preparation: preparationConfig.name,
-                    mode: testModeValue(proposalValues, defaultMode),
                 };
             }
             if (actionType === "readiness-check-draft") {
@@ -1984,9 +2026,7 @@ export class LocalServiceRuntime {
                 return "Ask the configured local executor to draft saved readiness checks.";
             return "Ask the configured local executor to create a reusable local Method.";
         })();
-        const previewValues = proposalActionType === "test"
-            ? { mode: actionRequest.mode }
-            : proposalValues;
+        const previewValues = proposalValues;
         const commandPreview = plan.command_preview ?? actionCommandPreview(proposalActionType, preparationConfig.name, methodId, previewValues);
         return ActionProposalResourceSchema.parse({
             kind: "interf-action-proposal",
@@ -2023,10 +2063,10 @@ export class LocalServiceRuntime {
             };
         }
         if (proposal.action_type === "test") {
-            const resource = await this.createTestRun(prepDataDir, proposal.request);
+            const resource = await this.createVerifyRun(prepDataDir, proposal.request);
             return {
                 runId: resource.run_id,
-                runType: "test-run",
+                runType: "verify-run",
             };
         }
         if (proposal.action_type === "readiness-check-draft") {
@@ -2068,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));
@@ -2158,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) {
@@ -2221,10 +2349,10 @@ export class LocalServiceRuntime {
             readiness,
         };
     }
-    writeTestRun(prepDataDir, compiledPath, run) {
-        mkdirSync(testRunsRoot(compiledPath), { recursive: true });
-        writeJsonFile(testRunPath(compiledPath, run.run_id), TestRunResourceSchema.parse(run));
-        this.testRunCache.invalidatePreparation(prepDataDir, run.preparation);
+    writeVerifyRun(prepDataDir, compiledPath, run) {
+        mkdirSync(verifyRunsRoot(compiledPath), { recursive: true });
+        writeJsonFile(verifyRunPath(compiledPath, run.run_id), VerifyRunResourceSchema.parse(run));
+        this.verifyRunCache.invalidatePreparation(prepDataDir, run.preparation);
         this.readinessCache.invalidatePreparation(prepDataDir, run.preparation);
     }
 }