@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/engine/lib/schema.js

@@ -1,15 +1,21 @@
 import { z } from "zod";
 import { ArtifactRefSchema, CompileRunSchema, CompileRunStatusSchema, InterfRunEventSchema, ProofRecordSchema, RunObservabilitySchema, } from "../execution/lib/schema.js";
 import { SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../../project/lib/schema.js";
-import { LocatorSchema, PreparationNameSchema, ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, } from "../../contracts/lib/schema.js";
+import { ArtifactSchema, ArtifactIdSchema, ArtifactPathShapeSchema, ArtifactStatusSchema, CheckSchema, LocatorSchema, PreparationNameSchema, ReadinessSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, TestTargetTypeSchema, } from "../../contracts/lib/schema.js";
 import { ReadinessCheckRunSchema, } from "../verify/lib/schema.js";
 const JsonObjectSchema = z.record(z.string(), z.unknown());
 // ───────────────────────────────────────────────────────────────────────────
 // 0.13 — preparation-first additions
 // ───────────────────────────────────────────────────────────────────────────
-/** Source binding shape on the API (only `local-folder` ships in 0.13). */
+/**
+ * Source binding shape on the API. `local-folder` is the only kind the
+ * local binary accepts in 0.17; `remote-folder` rides in the type
+ * plumbing for the future cloud variant (B4.4 cloud-variant seam) and
+ * is rejected at the validator branch in server.ts. See `TODO(cloud)`
+ * marker there.
+ */
 export const SourceBindingSchema = z.object({
-    kind: z.enum(["local-folder"]),
+    kind: z.enum(["local-folder", "remote-folder"]),
     locator: z.string().min(1),
 }).strict();
 /**
@@ -59,6 +65,12 @@ export const PreparationCreateRequestSchema = z.object({
 export const PreparationUpdateRequestSchema = z.object({
     method_id: MethodIdSchema.nullable().optional(),
     about: z.string().nullable().optional(),
+    /**
+     * Replace the full quality-check list. Use the empty array to clear
+     * every check. Each item is a `SourceReadinessCheck`
+     * (`{ question, answer?, strictness?, expect? }`).
+     */
+    checks: z.array(SourceReadinessCheckSchema).optional(),
 }).strict();
 /** Body of `POST /v1/methods` — install a Method package by path. */
 export const MethodInstallRequestSchema = z.object({
@@ -74,6 +86,15 @@ export const PreparationDeleteResponseSchema = z.object({
     deleted: z.boolean(),
     id: PreparationNameSchema,
 }).strict();
+export const PreparationWireShapeSchema = z.object({
+    id: PreparationNameSchema,
+    source: SourceBindingSchema,
+    method_id: MethodIdSchema.nullable(),
+    about: z.string().min(1).nullable(),
+    config_path: z.string().min(1),
+    portable_context: ArtifactLocatorSchema,
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+}).strict();
 /**
  * The local service must only ever bind to a loopback interface. Any other
  * host (LAN IP, 0.0.0.0, public address) lets a remote browser tab POST at
@@ -180,10 +201,15 @@ export const PreparationResourceSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
     portable_context: PortableContextMappingSchema,
     portable_context_path: z.string().min(1).nullable(),
-    readiness: ReadinessStateSchema,
+    readiness: ReadinessSchema,
     runs: PreparationRunLinkageSchema,
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
+    // 0.17 — per-Artifact status from the latest compile run, mirrored
+    // here so the UI/CLI can render artifact rows without a separate
+    // GET /v1/preparations/<id>/runs fetch. Empty when the Method
+    // no compile run has produced artifacts yet.
+    artifacts: z.array(ArtifactStatusSchema).default([]),
 }).strict();
 export const MethodResourceSchema = z.object({
     id: MethodIdSchema,
@@ -194,7 +220,7 @@ export const MethodResourceSchema = z.object({
     source_kind: z.enum(["builtin", "local"]).default("local"),
     built_in: z.boolean().default(false),
     active_for_preparations: z.array(PreparationNameSchema).default([]),
-    output_paths: z.array(z.string().min(1)).default([]),
+    artifacts: z.array(ArtifactSchema).default([]),
     stages: z.array(z.object({
         id: z.string().min(1),
         label: z.string().min(1),
@@ -209,7 +235,6 @@ export const MethodResourceSchema = z.object({
         role: z.string().min(1).default("general"),
         reads: z.array(z.string().min(1)).default([]),
         writes: z.array(z.string().min(1)).default([]),
-        acceptance: z.record(z.string(), z.unknown()).optional(),
     }).strict()).default([]),
 }).strict();
 export const CompileRunCreateRequestSchema = z.object({
@@ -391,6 +416,13 @@ export const ReadinessCheckDraftCreateRequestSchema = z.object({
 export const ReadinessCheckDraftResultSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
 }).strict();
+export const MethodAuthoringArtifactRequirementSchema = z.object({
+    id: ArtifactIdSchema,
+    description: z.string().min(1).optional(),
+    shape: ArtifactPathShapeSchema,
+    checks: z.array(CheckSchema).default([]),
+    stage_hint: z.string().min(1).optional(),
+}).strict();
 export const MethodAuthoringCreateRequestSchema = z.object({
     preparation: PreparationNameSchema.nullable().optional(),
     source_folder_path: z.string().min(1),
@@ -401,6 +433,7 @@ export const MethodAuthoringCreateRequestSchema = z.object({
     hint: z.string().min(1),
     task_prompt: z.string().min(1),
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    artifact_requirements: z.array(MethodAuthoringArtifactRequirementSchema).default([]),
 }).strict();
 export const MethodAuthoringResultSchema = z.object({
     status: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
@@ -440,16 +473,19 @@ export const LocalJobRunResourceSchema = z.object({
 }).strict();
 export const VerifyRunStatusSchema = RunStatusSchema;
 /**
- * 0.15 cleanup — `mode` was a 0.13 hold-over from when verify could
- * judge against either the source-files baseline or the compiled
- * portable context. 0.13.1 redirected every verify run to compiled-
- * only, which made `mode` a vestigial field. We drop it here so the
- * wire shape matches the runtime behavior. Older clients sending
- * `mode` get it ignored by the strict-but-tolerant runtime parser
- * upstream.
+ * 0.17 — verify runs choose their judge target. `compiled` (default)
+ * judges against the latest portable-context output; `source-files`
+ * judges against the raw source folder for a baseline that reveals
+ * how much value the Method actually adds. The 0.15 cleanup made
+ * verify compiled-only on the wire because the source-files branch
+ * had been retired in 0.13.1; 0.17 restores it because the QA tab and
+ * `verify/README.md` have always claimed the option exists, and the
+ * sandbox + spec builders for source-files have remained in tree
+ * since 0.13.
  */
 export const VerifyRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
+    target: TestTargetTypeSchema.default("compiled"),
 }).strict();
 export const VerifyRunResourceSchema = z.object({
     run_id: z.string().min(1),
@@ -460,7 +496,7 @@ export const VerifyRunResourceSchema = z.object({
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
     readiness_run: ReadinessCheckRunSchema.nullable(),
-    readiness: ReadinessStateSchema.nullable().optional(),
+    readiness: ReadinessSchema.nullable().optional(),
     events: z.array(InterfRunEventSchema).default([]),
     error: z.string().min(1).nullable().optional(),
 }).strict();
@@ -588,13 +624,13 @@ export const PortableContextResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
     exists: z.boolean(),
-    readiness: ReadinessStateSchema,
+    readiness: ReadinessSchema,
     method: MethodIdSchema.nullable().optional(),
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
     artifacts: z.array(ArtifactRefSchema).default([]),
 }).strict();
-export const ReadinessResourceSchema = ReadinessStateSchema;
+export const ReadinessResourceSchema = ReadinessSchema;
 export const SourceFileResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
@@ -649,7 +685,7 @@ export const OpenPathResponseSchema = z.object({
     path: z.string().min(1),
 }).strict();
 export const PreparationListResponseSchema = z.object({
-    preparations: z.array(PreparationResourceSchema),
+    preparations: z.array(PreparationWireShapeSchema),
 }).strict();
 export const MethodListResponseSchema = z.object({
     methods: z.array(MethodResourceSchema),

package/dist/packages/engine/native-run-handlers.js

@@ -14,7 +14,7 @@ import { createRunEventId, createRunEventTimestamp, } from "./execution/events.j
 import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../project/source-config.js";
 import { runMethodImprovementLoop } from "../methods/authoring/method-improvement.js";
 import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "./compile/compiled-paths.js";
-import { readCompiledSchemaFile } from "./compile/compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compile/compiled-schema.js";
 import { initializeCompiledRuntimeState } from "./compile/state.js";
 import { readinessPassRate, runReadinessChecksForExecutor, runSavedPortableContextCheck, } from "./verify/readiness-check-run.js";
 import { runMethodAuthoringDraft, } from "../methods/authoring/method-authoring.js";
@@ -87,9 +87,9 @@ function printSavedReadinessOutcome(prefix, outcome) {
 }
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zonePaths = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.path);
+    const artifactPaths = (schema ? listCompiledSchemaArtifacts(schema) : [])
+        .filter((artifact) => artifact.kind !== "runtime")
+        .map((artifact) => artifact.path);
     return [
         "AGENTS.md",
         "CLAUDE.md",
@@ -99,7 +99,7 @@ function bestVariationRestorePaths(compiledPath) {
         ".cursor",
         ".interf/interf.json",
         ".interf/method",
-        ...zonePaths,
+        ...artifactPaths,
     ];
 }
 function copyRelativePathIfPresent(sourceRoot, targetRoot, relativePath) {
@@ -598,12 +598,19 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 preparationConfig: context.preparationConfig,
                 portableContextPath: context.compiledPath,
                 executor,
+                target: request.target,
             });
-            if (!result.compiledOutcome) {
+            const outcome = request.target === "source-files"
+                ? result.sourceFilesOutcome
+                : result.compiledOutcome;
+            if (!outcome) {
+                const targetLabel = request.target === "source-files"
+                    ? "Source files"
+                    : "Portable Context";
                 return {
                     ok: false,
                     readiness_run: result.readinessRun,
-                    error: "Portable Context is not ready for readiness checks.",
+                    error: `${targetLabel} is not ready for readiness checks.`,
                 };
             }
             return {
@@ -653,6 +660,7 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 hint: request.hint,
                 taskPrompt: request.task_prompt,
                 checks: request.checks,
+                artifactRequirements: request.artifact_requirements,
                 executor,
                 onStatus: (line) => context.emit({
                     type: "log.appended",

package/dist/packages/engine/preparation-store.d.ts

@@ -42,6 +42,12 @@ export interface PreparationCreateInput {
 export interface PreparationUpdateInput {
     method_id?: string | null;
     about?: string | null;
+    checks?: Array<{
+        question: string;
+        answer?: string;
+        strictness?: string;
+        expect?: string;
+    }>;
 }
 export interface StoredPreparation {
     id: string;

package/dist/packages/engine/preparation-store.js

@@ -154,6 +154,14 @@ export function updateStoredPreparation(prepId, patch) {
             : patch.method_id !== undefined
                 ? { method: patch.method_id }
                 : {}),
+        ...(patch.checks !== undefined
+            ? { checks: patch.checks.map((check) => ({
+                    question: check.question,
+                    ...(check.answer ? { answer: check.answer } : {}),
+                    ...(check.strictness ? { strictness: check.strictness } : {}),
+                    ...(check.expect ? { expect: check.expect } : {}),
+                })) }
+            : {}),
     };
     const aboutPatch = patch.about === undefined ? stored.about : patch.about;
     const preparationWithAbout = aboutPatch

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

@@ -42,6 +42,12 @@ export declare const PREPARATION_SUBRESOURCES: {
      *   GET /v1/preparations/<id>/files/<relpath>
      */
     readonly files: "files";
+    /**
+     * 0.17 — per-Artifact detail. Returns the latest status, contributing
+     * stages, and proof refs for a Method-declared Artifact:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    readonly artifacts: "artifacts";
 };
 /** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
 export declare const METHOD_SUBRESOURCES: {

package/dist/packages/engine/routes.js

@@ -43,6 +43,12 @@ export const PREPARATION_SUBRESOURCES = {
      *   GET /v1/preparations/<id>/files/<relpath>
      */
     files: "files",
+    /**
+     * 0.17 — per-Artifact detail. Returns the latest status, contributing
+     * stages, and proof refs for a Method-declared Artifact:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    artifacts: "artifacts",
 };
 /** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
 export const METHOD_SUBRESOURCES = {

package/dist/packages/engine/run-observability.js

@@ -79,7 +79,7 @@ function buildTraceStreamChunks(runId, events) {
         time: event.timestamp ?? null,
         type: event.type,
         scope: event.stage_id ?? event.step_id ?? event.type,
-        message: event.message ?? event.summary ?? event.error ?? event.type,
+        message: event.message ?? event.summary ?? event.error ?? event.reason ?? event.type,
     }), event));
 }
 function proofChecksForCompileRun(run) {
@@ -164,7 +164,6 @@ export function compileRunToObservability(run) {
                 stage_total: stage.stage_total ?? null,
                 reads: stage.contract?.reads ?? [],
                 writes: stage.contract?.writes ?? [],
-                acceptance: stage.contract?.acceptance ?? null,
                 executor: stage.executor ?? null,
             },
         }, stage.stage_id));

package/dist/packages/engine/runtime-event-applier.js

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

package/dist/packages/engine/runtime-proposal-helpers.js

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

package/dist/packages/engine/runtime-resource-builders.d.ts

@@ -9,7 +9,7 @@
 import { type ArtifactRef, type ProofRecord } from "./execution/lib/schema.js";
 import { type CompiledState } from "./compile/state.js";
 import { type RuntimeRun } from "./compile/lib/schema.js";
-import { type ReadinessState, type ReadinessTargetResult } from "../contracts/lib/schema.js";
+import { type Artifact, type Readiness, type VerifyTargetResult } from "../contracts/lib/schema.js";
 import { type TestRunTargetSummary } from "./verify/lib/schema.js";
 import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type MethodResource, type PreparationResource } from "./lib/schema.js";
@@ -35,10 +35,10 @@ export declare function logsForRuntimeRun(run: RuntimeRun | undefined): {
     prompt_path?: string | undefined;
 } | undefined;
 export declare function passRate(passed: number, total: number): number | null;
-export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): ReadinessTargetResult | null;
-export declare function readinessSummaryForStatus(status: ReadinessState["status"]): string;
-export declare function readinessStateToPreparationReadiness(readiness: ReadinessState): ReadinessState;
-export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: ReadinessState, latestCompileRunId: string | null, latestTestRunId: string | null): PreparationResource;
+export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): VerifyTargetResult | null;
+export declare function readinessSummaryForStatus(status: Readiness["status"]): string;
+export declare function readinessStateToPreparationReadiness(readiness: Readiness): Readiness;
+export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: Readiness, latestCompileRunId: string | null, latestTestRunId: string | null, artifacts?: PreparationResource["artifacts"]): PreparationResource;
 export declare function buildMethodResource(resource: {
     id: string;
     path: string;
@@ -47,6 +47,6 @@ export declare function buildMethodResource(resource: {
     source_kind: "builtin" | "local";
     built_in: boolean;
     active_for_preparations: string[];
-    output_paths: string[];
+    artifacts: Artifact[];
     stages: MethodResource["stages"];
 }): MethodResource;

package/dist/packages/engine/runtime-resource-builders.js

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

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

@@ -1,7 +1,9 @@
 import { type ArtifactRef, type CompileRun, type InterfRunEvent, type ProofRecord } from "./execution/lib/schema.js";
 import { type RunEventSink } from "./execution/events.js";
-import { type ReadinessState } from "../contracts/lib/schema.js";
+import { type Readiness } from "../contracts/lib/schema.js";
 import type { SourcePreparationConfig } from "../project/lib/schema.js";
+import { type BillingEventSink } from "./compile/billing-events.js";
+import type { IdempotencyStore, RunLeaseStore, TokenValidator } from "./cloud-seams.js";
 import { type ActionProposalCreateRequest, type ActionProposalPlan, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunResource, type MethodResource, type LocalServiceHealth, type LocalJobEvent, type LocalJobEventAppendRequest, type LocalExecutorStatus, type LocalJobRunResource, type LocalRunHandlerResult, type PortableContextResource, type PreparationResource, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type RunObservabilityResource, type ServiceRegistryWorkspace, type SourceFileResource, type WorkspaceFileResource, type VerifyRunCreateRequest, type VerifyRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type MethodChangeResult, type PreparationChangeResult, type PreparationSetupResult, type ResetResult } from "./lib/schema.js";
 export interface LocalServiceCompileRunContext {
     runId: string;
@@ -58,6 +60,21 @@ export interface LocalServiceRuntimeOptions {
      * skip generating one; production startup always provides a token.
      */
     authToken?: string;
+    /**
+     * 0.17 — optional injection point for the per-Artifact billing event
+     * sink. Local default writes a JSONL file alongside the run record;
+     * cloud variants will inject a Metronome HTTP sender once the
+     * Stripe/Metronome integration ships in 0.18+.
+     */
+    billingEventSink?: BillingEventSink;
+    /**
+     * 0.17 — cloud-variant interface seams. Local default: in-process
+     * Maps on the runtime (current behavior). Cloud variants pass shared
+     * implementations so multi-replica engines coordinate. See
+     * `cloud-seams.ts` for the contract.
+     */
+    idempotencyStore?: IdempotencyStore;
+    runLeaseStore?: RunLeaseStore;
 }
 /**
  * Per-preparation context tracked by the runtime. Multiple preparations can
@@ -99,6 +116,11 @@ export declare 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.
      */
     private activeCompileRuns;
     /**
@@ -108,6 +130,11 @@ export declare 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.
      */
     private idempotencyKeyCache;
     /**
@@ -122,8 +149,32 @@ export declare class LocalServiceRuntime {
     private readonly readinessCache;
     private readonly sourceFilesCache;
     private readonly 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.
+     */
+    private readonly 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.
+     */
+    readonly cloudIdempotencyStore: IdempotencyStore | null;
+    readonly cloudRunLeaseStore: RunLeaseStore | null;
+    private cloudTokenValidator;
     constructor(options: LocalServiceRuntimeOptions);
     setBoundPort(port: number): void;
+    /**
+     * 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: TokenValidator | null): void;
+    getTokenValidator(): TokenValidator | null;
     /** Set a hook that fires whenever the registered preparations change. */
     setOnRegistryChanged(handler: (() => void) | null): void;
     /**
@@ -175,11 +226,11 @@ export declare class LocalServiceRuntime {
     health(prepDataDir?: string): LocalServiceHealth;
     listPreparations(prepDataDir: string): PreparationResource[];
     getPreparation(prepDataDir: string, preparationName: string): PreparationResource | null;
-    listPreparationReadiness(prepDataDir: string): ReadinessState[];
-    getPreparationReadiness(prepDataDir: string, preparationName: string): ReadinessState | null;
-    listReadiness(prepDataDir: string): ReadinessState[];
-    getReadiness(prepDataDir: string, preparationName: string): ReadinessState | null;
-    computePreparationReadiness(prepDataDir: string, preparation: SourcePreparationConfig): ReadinessState;
+    listPreparationReadiness(prepDataDir: string): Readiness[];
+    getPreparationReadiness(prepDataDir: string, preparationName: string): Readiness | null;
+    listReadiness(prepDataDir: string): Readiness[];
+    getReadiness(prepDataDir: string, preparationName: string): Readiness | null;
+    computePreparationReadiness(prepDataDir: string, preparation: SourcePreparationConfig): Readiness;
     private computePreparationReadinessUncached;
     listSourceFiles(prepDataDir: string, preparationName?: string | null): SourceFileResource[];
     listWorkspaceFiles(prepDataDir: string): WorkspaceFileResource[];
@@ -249,7 +300,7 @@ export declare class LocalServiceRuntime {
     createCompileRun(prepDataDir: string, requestValue: unknown): Promise<CompileRunResource>;
     /**
      * 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.
@@ -303,6 +354,15 @@ export declare class LocalServiceRuntime {
     private resolvePreparationConfig;
     private ensureCompiledForRun;
     private readCompileRun;
+    private finalizeInterruptedCompileRuns;
+    /**
+     * 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.
+     */
+    private emitBillingEventsForRun;
     private writeCompileRun;
     private writeJobRun;
     private writeActionProposal;