@interf/compiler 0.16.0 → 0.21.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 { aggregateArtifactVerdict, 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,15 +25,38 @@ 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";
 import { compileRunToObservability, jobRunToObservability, verifyRunToObservability, uniqueArtifacts, } from "./run-observability.js";
+import { artifactRequirementsFromRequestedArtifacts } from "./requested-artifacts.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.";
+const INTERRUPTED_JOB_RUN_MESSAGE = "Job interrupted because the Interf engine stopped before the job reached a terminal state.";
+function isTerminalCompileRunStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+function isTerminalJobStatus(status) {
+    return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+function countsFromCompiledState(state) {
+    const counts = {};
+    for (const stage of Object.values(state.stages ?? {})) {
+        for (const [key, value] of Object.entries(stage.counts ?? {})) {
+            if (Number.isFinite(value))
+                counts[key] = Math.max(counts[key] ?? 0, value);
+        }
+        for (const [key, value] of Object.entries(stage.artifact_counts ?? {})) {
+            if (Number.isFinite(value))
+                counts[key] = Math.max(counts[key] ?? 0, value);
+        }
+    }
+    return counts;
+}
 export class LocalServiceRuntime {
     host;
     port;
@@ -62,6 +86,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 +100,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 +119,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 +143,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 +156,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 +191,8 @@ export class LocalServiceRuntime {
             lastActivity: now,
         };
         this.preparationContexts.set(resolved, context);
+        this.finalizeInterruptedCompileRuns(resolved);
+        this.finalizeInterruptedJobRuns(resolved);
         this.onRegistryChanged?.();
         return context;
     }
@@ -258,7 +325,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) {
@@ -291,6 +362,13 @@ export class LocalServiceRuntime {
         const compileRun = this.listCompileRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
         const verifyRun = this.listVerifyRunsForPreparation(prepDataDir, preparation.name)[0] ?? null;
         const readinessRun = this.readLatestReadinessRun(prepDataDir, preparation.name);
+        const artifactStatuses = compileRun?.artifacts ?? [];
+        const hasArtifactContract = artifactStatuses.length > 0;
+        const artifactVerdict = aggregateArtifactVerdict(artifactStatuses);
+        const artifactFailures = artifactStatuses.filter((artifact) => artifact.status !== "ready");
+        const artifactProofs = artifactStatuses.flatMap((artifact) => artifact.proofs ?? []);
+        const requiredArtifactProofs = artifactProofs.filter((proof) => proof.required !== false);
+        const passedArtifactProofs = requiredArtifactProofs.filter((proof) => proof.passed);
         const configuredChecks = preparation.checks.length;
         const currentFingerprint = configuredChecks > 0 ? fingerprintReadinessChecks(preparation.checks) : null;
         const readinessRunFingerprint = readinessRun?.checks_fingerprint ?? null;
@@ -356,13 +434,25 @@ export class LocalServiceRuntime {
                 artifact_path: contextReady ? compiledPath : null,
             },
             compileCheck,
+            {
+                gate: "artifact-checks",
+                ok: !hasArtifactContract || artifactVerdict === "ready",
+                status: !hasArtifactContract
+                    ? "not-configured"
+                    : artifactVerdict === "ready" ? "ready" : "not-ready",
+                summary: !hasArtifactContract
+                    ? "No Artifacts are declared by the selected Build Plan."
+                    : artifactVerdict === "ready"
+                        ? `${artifactStatuses.length} Artifact${artifactStatuses.length === 1 ? "" : "s"} ready; ${passedArtifactProofs.length}/${requiredArtifactProofs.length} required Artifact check${requiredArtifactProofs.length === 1 ? "" : "s"} passed.`
+                        : `${artifactFailures.length} Artifact${artifactFailures.length === 1 ? "" : "s"} not ready.`,
+            },
             {
                 gate: "readiness-checks",
-                ok: configuredChecks > 0,
+                ok: true,
                 status: configuredChecks > 0 ? "built" : "not-configured",
                 summary: configuredChecks > 0
                     ? `${configuredChecks} readiness check${configuredChecks === 1 ? "" : "s"} configured.`
-                    : "No readiness checks are configured.",
+                    : "No optional readiness checks are configured.",
             },
             {
                 gate: "checks-current",
@@ -382,16 +472,18 @@ export class LocalServiceRuntime {
                 return "failed";
             if (!compileRun || !contextReady)
                 return "not-built";
-            if (configuredChecks === 0)
-                return "not-configured";
+            if (hasArtifactContract && artifactVerdict !== "ready")
+                return "not-ready";
             if (checksStale)
                 return "stale";
+            if (configuredChecks === 0)
+                return hasArtifactContract ? "ready" : "built";
             if (!contextResult)
                 return "built";
             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,
@@ -484,7 +576,7 @@ export class LocalServiceRuntime {
         // method roots. Key the cache off mtimes for the three roots; if
         // any of them changes (a new local Method, an edit to the user
         // library, etc.) the cache misses and we re-resolve.
-        const builtinRoot = join(PACKAGE_ROOT, "builtin-methods");
+        const builtinRoot = join(PACKAGE_ROOT, "public-repo", "methods");
         const localRoot = preparationMethodsRoot(asPreparationDataDir(prepDataDir));
         const userRoot = userMethodsRoot();
         return this.methodListingCache.get(prepDataDir, [builtinRoot, localRoot, userRoot], () => {
@@ -499,13 +591,12 @@ export class LocalServiceRuntime {
                     path: resolveMethodPackageSourcePath(prepDataDir, method.id) ?? method.id,
                     label: method.label,
                     hint: method.hint,
+                    purpose: method.purpose,
+                    inputs: method.inputs,
                     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 +606,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 } : {}),
                     })),
                 });
             });
@@ -707,7 +797,10 @@ export class LocalServiceRuntime {
     }
     listRunObservability(prepDataDir) {
         return [
-            ...this.listCompileRuns(prepDataDir).map((resource) => compileRunToObservability(resource.run)),
+            ...this.listCompileRuns(prepDataDir).map((resource) => compileRunToObservability({
+                ...resource.run,
+                readiness: this.getReadiness(prepDataDir, resource.run.preparation),
+            })),
             ...this.listVerifyRuns(prepDataDir).map(verifyRunToObservability),
             ...this.listJobs(prepDataDir).map(jobRunToObservability),
         ].sort((left, right) => {
@@ -720,7 +813,7 @@ export class LocalServiceRuntime {
         return this.listRunObservability(prepDataDir).find((run) => run.run_id === runId) ?? null;
     }
     /**
-     * Method-scoped runs: every method-authoring or method-improvement job
+     * Method Activity 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.
@@ -919,11 +1012,16 @@ export class LocalServiceRuntime {
     applyPreparationSetup(prepDataDir, requestValue) {
         const request = PreparationSetupCreateRequestSchema.parse(requestValue);
         const preparationConfig = request.preparation;
-        const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
-        const normalizedPreparationConfig = {
-            ...preparationConfig,
-            method: methodId,
-        };
+        const methodId = methodIdForSourcePreparationConfig(preparationConfig);
+        if (request.setup_mode === "select-method" && !methodId) {
+            throw new Error("Build Plan is required when selecting a Build Plan for a Preparation.");
+        }
+        const normalizedPreparationConfig = methodId
+            ? { ...preparationConfig, method: methodId }
+            : (() => {
+                const { method: _method, ...withoutMethod } = preparationConfig;
+                return withoutMethod;
+            })();
         const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, normalizedPreparationConfig);
         if (!existsSync(sourceFolderPath) || !statSync(sourceFolderPath).isDirectory()) {
             throw new Error(`Source folder "${preparationConfig.path}" is not available.`);
@@ -942,14 +1040,16 @@ export class LocalServiceRuntime {
             version: 1,
             operation,
             preparation: normalizedPreparationConfig.name,
-            method: methodId,
+            method: methodId ?? null,
             source_folder_path: sourceFolderPath,
             config_path: preparationConfigPath(asPreparationDataDir(prepDataDir)),
             portable_context_path: preparationPortableContextPath(asPreparationDataDir(prepDataDir), normalizedPreparationConfig.name),
             changed: true,
             message: operation === "select-method"
-                ? `Preparation ${normalizedPreparationConfig.name} now uses Method ${methodId}.`
-                : `Preparation ${normalizedPreparationConfig.name} is saved.`,
+                ? `Preparation ${normalizedPreparationConfig.name} now uses Build Plan ${methodId}.`
+                : methodId
+                    ? `Preparation ${normalizedPreparationConfig.name} is saved with Build Plan ${methodId}.`
+                    : `Preparation ${normalizedPreparationConfig.name} is saved. Draft or select a Build Plan before compiling.`,
         });
     }
     applyPreparationChange(prepDataDir, requestValue) {
@@ -1004,7 +1104,17 @@ export class LocalServiceRuntime {
         });
     }
     async createMethodAuthoringRun(prepDataDir, requestValue, jobType = "method-authoring") {
-        const request = MethodAuthoringCreateRequestSchema.parse(requestValue);
+        const parsedRequest = MethodAuthoringCreateRequestSchema.parse(requestValue);
+        const savedPreparation = parsedRequest.preparation
+            ? findSourcePreparationConfig(loadSourceFolderConfig(prepDataDir), parsedRequest.preparation)
+            : null;
+        const request = {
+            ...parsedRequest,
+            requested_artifacts: parsedRequest.requested_artifacts.length > 0
+                ? parsedRequest.requested_artifacts
+                : savedPreparation?.requested_artifacts ?? [],
+            source_profile: parsedRequest.source_profile ?? savedPreparation?.source_profile ?? null,
+        };
         const isImprovement = jobType === "method-improvement";
         const job = this.createJobRun(prepDataDir, {
             job_type: jobType,
@@ -1021,6 +1131,7 @@ export class LocalServiceRuntime {
                         preparation: request.preparation ?? null,
                         source_folder_path: request.source_folder_path,
                         checks: request.checks.length,
+                        requested_artifacts: request.requested_artifacts.length,
                     },
                 },
                 {
@@ -1030,6 +1141,8 @@ export class LocalServiceRuntime {
                         method_id: request.method_id,
                         label: request.label,
                         task_prompt: request.task_prompt,
+                        requested_artifacts: request.requested_artifacts.length,
+                        artifact_requirements: request.artifact_requirements.length,
                     },
                 },
                 {
@@ -1049,6 +1162,7 @@ export class LocalServiceRuntime {
                 preparation: request.preparation ?? null,
                 source_folder_path: request.source_folder_path,
                 checks: request.checks.length,
+                requested_artifacts: request.requested_artifacts.length,
             },
         });
         this.appendJobRunEvent(prepDataDir, job.run_id, {
@@ -1058,6 +1172,7 @@ export class LocalServiceRuntime {
             output: {
                 source_folder_path: request.source_folder_path,
                 checks: request.checks.length,
+                requested_artifacts: request.requested_artifacts.length,
             },
         });
         this.appendJobRunEvent(prepDataDir, job.run_id, {
@@ -1068,6 +1183,8 @@ export class LocalServiceRuntime {
                 method_id: request.method_id,
                 label: request.label,
                 task_prompt: request.task_prompt,
+                requested_artifacts: request.requested_artifacts.length,
+                artifact_requirements: request.artifact_requirements.length,
             },
         });
         void this.runMethodAuthoringInBackground(prepDataDir, request, job.run_id);
@@ -1108,7 +1225,7 @@ export class LocalServiceRuntime {
             const compiledPath = preparationPortableContextPath(asPreparationDataDir(prepDataDir), preparationName);
             return byCreatedAtDesc(listJsonFiles(compileRunsRoot(compiledPath))
                 .map(readCompileRunAt)
-                .filter((run) => run !== null));
+                .filter((run) => run !== null)).map((run) => this.hydrateCompileRunFromRuntime(prepDataDir, compiledPath, run));
         }, (run) => run.run_id);
     }
     getCompileRun(prepDataDir, runId) {
@@ -1187,7 +1304,6 @@ export class LocalServiceRuntime {
                         stage_total: stageTotal,
                         reads: stage.reads,
                         writes: stage.writes,
-                        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
                     },
                     artifacts: [],
                 };
@@ -1226,7 +1342,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 +1362,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 +1540,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, {
@@ -1591,18 +1701,35 @@ export class LocalServiceRuntime {
                 },
             });
             if (result.status === "updated" || result.status === "no-change") {
+                let selectedPreparation = null;
+                if (request.preparation) {
+                    const selected = this.resolvePreparationConfig(prepDataDir, request.preparation, {
+                        method: request.method_id,
+                    });
+                    upsertSourcePreparationConfig(prepDataDir, selected);
+                    this.readinessCache.invalidatePreparation(prepDataDir, selected.name);
+                    this.compileRunCache.invalidatePreparation(prepDataDir, selected.name);
+                    this.verifyRunCache.invalidatePreparation(prepDataDir, selected.name);
+                    this.methodListingCache.invalidate(prepDataDir);
+                    selectedPreparation = selected.name;
+                }
                 this.appendJobRunEvent(prepDataDir, runId, {
                     type: "step.completed",
                     step_id: "validate-package",
-                    message: result.summary,
+                    message: selectedPreparation
+                        ? `${result.summary} Selected Build Plan ${request.method_id} for Preparation ${selectedPreparation}.`
+                        : result.summary,
                     output: {
                         status: result.status,
                         validation: result.validation ?? null,
+                        selected_preparation: selectedPreparation,
                     },
                 });
                 this.appendJobRunEvent(prepDataDir, runId, {
                     type: "job.completed",
-                    message: result.summary,
+                    message: selectedPreparation
+                        ? `${result.summary} Selected Build Plan ${request.method_id} for Preparation ${selectedPreparation}.`
+                        : result.summary,
                 });
             }
             else {
@@ -1658,7 +1785,7 @@ export class LocalServiceRuntime {
             return ActionProposalPlanSchema.parse({
                 action_type: "clarification",
                 ...(request.preparation ? { preparation: request.preparation } : {}),
-                assistant_message: "No local action planner is configured for this Interf Workspace.",
+                assistant_message: "No local action planner is configured for this Interf instance.",
             });
         }
         const preparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
@@ -1843,6 +1970,9 @@ export class LocalServiceRuntime {
                 hint,
                 task_prompt: taskPrompt,
                 checks: preparationConfig?.checks ?? [],
+                requested_artifacts: preparationConfig?.requested_artifacts ?? [],
+                source_profile: preparationConfig?.source_profile ?? null,
+                artifact_requirements: artifactRequirementsFromRequestedArtifacts(preparationConfig?.requested_artifacts ?? []),
             };
             const commandPreview = (usePlannerText ? plan.command_preview : undefined) ??
                 actionCommandPreview(actionType, preparationConfig?.name ?? null, methodId, proposalValues);
@@ -1960,6 +2090,9 @@ export class LocalServiceRuntime {
                 hint,
                 task_prompt: taskPrompt,
                 checks: preparationConfig.checks ?? [],
+                requested_artifacts: preparationConfig.requested_artifacts ?? [],
+                source_profile: preparationConfig.source_profile ?? null,
+                artifact_requirements: artifactRequirementsFromRequestedArtifacts(preparationConfig.requested_artifacts ?? []),
             };
         })();
         const title = (() => {
@@ -2066,6 +2199,114 @@ export class LocalServiceRuntime {
     readCompileRun(compiledPath, runId) {
         return readCompileRunAt(compileRunPath(compiledPath, runId));
     }
+    hydrateCompileRunFromRuntime(prepDataDir, compiledPath, run) {
+        if (!isTerminalCompileRunStatus(run.status))
+            return run;
+        this.refreshCompileRunFromRuntime(prepDataDir, compiledPath, run.run_id);
+        return this.readCompileRun(compiledPath, run.run_id) ?? run;
+    }
+    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,
+                }));
+            }
+        }
+    }
+    finalizeInterruptedJobRuns(prepDataDir) {
+        for (const run of this.listJobs(prepDataDir)) {
+            if (isTerminalJobStatus(run.status))
+                continue;
+            const timestamp = createRunEventTimestamp();
+            const interruptedRun = LocalJobRunResourceSchema.parse({
+                ...run,
+                steps: run.steps.map((step) => {
+                    if (step.status !== "running")
+                        return step;
+                    return {
+                        ...step,
+                        status: "failed",
+                        finished_at: step.finished_at ?? timestamp,
+                        summary: step.summary ?? INTERRUPTED_JOB_RUN_MESSAGE,
+                    };
+                }),
+            });
+            this.writeJobRun(prepDataDir, applyEventToLocalJob(interruptedRun, {
+                type: "job.failed",
+                event_id: createRunEventId("event"),
+                run_id: run.run_id,
+                timestamp,
+                message: INTERRUPTED_JOB_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 +2397,20 @@ 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,
+                counts: countsFromCompiledState(state),
+            });
+        }
+        catch {
+            next.artifacts = current.artifacts ?? [];
+        }
         this.writeCompileRun(prepDataDir, compiledPath, next);
     }
     async emitRuntimeDerivedEvents(prepDataDir, compiledPath, runId) {