@interf/compiler 0.13.0 → 0.16.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,14 +6,14 @@
  * Splitting these out keeps the runtime coordinator focused on
  * orchestration rather than payload formatting.
  */
-import { type ArtifactRef, type ProofRecord } from "../execution/lib/schema.js";
-import { type CompiledState } from "../compiler/state.js";
-import { type RuntimeRun } from "../compiler/lib/schema.js";
+import { type 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 TestRunTargetSummary } from "../testing/lib/schema.js";
-import { type SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type TestRunTargetSummary } from "./verify/lib/schema.js";
+import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type MethodResource, type PreparationResource } from "./lib/schema.js";
-export declare function createRunId(prefix: "compile" | "test" | "job"): string;
+export declare function createRunId(prefix: "compile" | "verify" | "job"): string;
 export declare function stageArtifactRefs(stageId: string, artifacts: string[] | undefined): ArtifactRef[];
 export declare function proofForStage(options: {
     runId: string;

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

@@ -1,5 +1,5 @@
 import { ReadinessStateSchema, } from "../contracts/lib/schema.js";
-import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project-model/source-config.js";
+import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project/source-config.js";
 import { MethodResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
 export function createRunId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;

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

@@ -1,8 +1,8 @@
-import { type ArtifactRef, type CompileRun, type InterfRunEvent, type ProofRecord } from "../execution/lib/schema.js";
-import { type RunEventSink } from "../execution/events.js";
+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 { SourcePreparationConfig } from "../project-model/lib/schema.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 TestRunCreateRequest, type TestRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type MethodChangeResult, type PreparationChangeResult, type PreparationSetupResult, type WorkspaceBootstrapResult, type ResetResult } from "./lib/schema.js";
+import type { SourcePreparationConfig } from "../project/lib/schema.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;
     sourcePath: string;
@@ -10,7 +10,7 @@ export interface LocalServiceCompileRunContext {
     preparationConfig: SourcePreparationConfig;
     events: RunEventSink;
 }
-export interface LocalServiceTestRunContext {
+export interface LocalServiceVerifyRunContext {
     runId: string;
     sourcePath: string;
     compiledPath: string;
@@ -41,7 +41,7 @@ export interface LocalServiceActionPlanningContext {
 export interface LocalServiceRunHandlers {
     planActionProposal(request: ActionProposalCreateRequest, context: LocalServiceActionPlanningContext): Promise<ActionProposalPlan>;
     createCompileRun(request: CompileRunCreateRequest, context: LocalServiceCompileRunContext): Promise<LocalRunHandlerResult>;
-    createTestRun(request: TestRunCreateRequest, context: LocalServiceTestRunContext): Promise<LocalRunHandlerResult>;
+    createVerifyRun(request: VerifyRunCreateRequest, context: LocalServiceVerifyRunContext): Promise<LocalRunHandlerResult>;
     createReadinessCheckDraft(request: ReadinessCheckDraftCreateRequest, context: LocalServiceJobRunContext): Promise<ReadinessCheckDraftResult>;
     createMethodAuthoringRun(request: MethodAuthoringCreateRequest, context: LocalServiceJobRunContext): Promise<MethodAuthoringResult>;
 }
@@ -60,9 +60,9 @@ export interface LocalServiceRuntimeOptions {
     authToken?: string;
 }
 /**
- * Per-workspace context tracked by the runtime. Multiple workspaces can be
- * registered against one running service; each one owns its rootPath and
- * activity timestamps. Routes pass the workspace explicitly to every
+ * Per-preparation context tracked by the runtime. Multiple preparations can
+ * be registered against one running service; each one owns its rootPath and
+ * activity timestamps. Routes pass the preparation explicitly to every
  * runtime method that needs one, so there is no swap-state to manage.
  */
 export interface PreparationContext {
@@ -89,10 +89,10 @@ export declare class LocalServiceRuntime {
      */
     readonly authToken: string | null;
     /** Map of prepDataDir -> PreparationContext. */
-    private workspaces;
-    /** Hook called whenever a workspace is registered or deregistered. */
+    private preparationContexts;
+    /** Hook called whenever a preparation is registered or deregistered. */
     private onRegistryChanged;
-    /** In-flight runs across all workspaces. Used for `idle_for_seconds`. */
+    /** In-flight runs across all preparations. Used for `idle_for_seconds`. */
     private activeRunCount;
     /**
      * Active compile-run cancellation handles, keyed by run id. Populated
@@ -103,10 +103,10 @@ export declare class LocalServiceRuntime {
     private activeCompileRuns;
     /**
      * 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`.
      */
     private idempotencyKeyCache;
@@ -118,53 +118,59 @@ export declare class LocalServiceRuntime {
      * matching write path. See {@link runtime-caches} for design notes.
      */
     private readonly compileRunCache;
-    private readonly testRunCache;
+    private readonly verifyRunCache;
     private readonly readinessCache;
     private readonly sourceFilesCache;
     private readonly methodListingCache;
     constructor(options: LocalServiceRuntimeOptions);
     setBoundPort(port: number): void;
-    /** Set a hook that fires whenever the registered workspaces change. */
+    /** Set a hook that fires whenever the registered preparations change. */
     setOnRegistryChanged(handler: (() => void) | null): void;
     /**
-     * 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: string): PreparationContext;
     /**
-     * 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: string): boolean;
     /**
-     * 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(): string;
-    /** Look up a workspace context by rootPath. */
+    /** Look up a preparation context by rootPath. */
     getPreparationContext(prepDataDir: string): PreparationContext | null;
-    /** All registered workspaces, ordered by registration time. */
+    /** All registered preparations, ordered by registration time. */
     listRegisteredPreparations(): PreparationContext[];
-    /** True when no workspaces are registered. */
-    hasNoWorkspaces(): boolean;
-    /** Number of registered workspaces. */
+    /** True when no preparations are registered. */
+    hasNoPreparations(): boolean;
+    /** Number of registered preparations. */
     registeredPreparationCount(): number;
     /** Increment in-flight run counter. Call when a long-running run starts. */
     beginActiveRun(): void;
     /** Decrement in-flight run counter. Pair with `beginActiveRun`. */
     endActiveRun(): void;
-    /** Sum of in-flight runs across all workspaces. */
+    /** Sum of in-flight runs across all preparations. */
     activeRuns(): number;
     /**
-     * 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: string): void;
-    /** 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(): ServiceRegistryWorkspace[];
-    /** Seconds since the most recent workspace activity (0 if active). */
+    /** Seconds since the most recent preparation activity (0 if active). */
     idleForSeconds(): number;
     health(prepDataDir?: string): LocalServiceHealth;
     listPreparations(prepDataDir: string): PreparationResource[];
@@ -184,25 +190,50 @@ export declare class LocalServiceRuntime {
     getJobEvents(prepDataDir: string, runId: string): LocalJobEvent[] | null;
     getExecutorStatus(): LocalExecutorStatus;
     selectExecutor(requestValue: unknown): LocalExecutorStatus;
+    /**
+     * Snapshot of the merged agents registry (built-in detected + custom)
+     * with the current role-map and resolved active agent.
+     */
+    getAgentsRegistry(): {
+        agents: import("../contracts/lib/schema.js").AgentRecord[];
+        role_map: import("../contracts/lib/schema.js").RoleMap;
+        active_agent: import("../contracts/lib/schema.js").AgentRecord | null;
+    };
+    registerCustomAgent(input: {
+        name: string;
+        display_name: string;
+        command: string;
+    }): {
+        agents: import("../contracts/lib/schema.js").AgentRecord[];
+        role_map: import("../contracts/lib/schema.js").RoleMap;
+        active_agent: import("../contracts/lib/schema.js").AgentRecord | null;
+    };
+    unregisterCustomAgent(name: string): {
+        agents: import("../contracts/lib/schema.js").AgentRecord[];
+        role_map: import("../contracts/lib/schema.js").RoleMap;
+        active_agent: import("../contracts/lib/schema.js").AgentRecord | null;
+    };
+    patchAgentsRoleMap(patch: Record<string, string>): {
+        role_map: import("../contracts/lib/schema.js").RoleMap;
+        active_agent: import("../contracts/lib/schema.js").AgentRecord | null;
+    };
     listActionProposals(prepDataDir: string): ActionProposalResource[];
     getActionProposal(prepDataDir: string, proposalId: string): ActionProposalResource | null;
     createActionProposal(prepDataDir: string, requestValue: unknown): Promise<ActionProposalResource>;
     decideActionProposal(prepDataDir: string, proposalId: string, requestValue: unknown): Promise<ActionProposalResource | null>;
     listRunObservability(prepDataDir: string): RunObservabilityResource[];
     getRunObservability(prepDataDir: string, runId: string): RunObservabilityResource | 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: string, methodId: string): RunObservabilityResource[];
     private createJobRun;
     private appendJobRunEvent;
     createReadinessCheckDraftRun(prepDataDir: string, requestValue: unknown): Promise<LocalJobRunResource>;
     applyMethodChange(prepDataDir: string, requestValue: unknown): MethodChangeResult;
-    /**
-     * 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: string, requestValue: unknown): WorkspaceBootstrapResult;
     applyPreparationSetup(prepDataDir: string, requestValue: unknown): PreparationSetupResult;
     applyPreparationChange(prepDataDir: string, requestValue: unknown): PreparationChangeResult;
     applyReset(prepDataDir: string, requestValue: unknown): ResetResult;
@@ -230,8 +261,8 @@ export declare class LocalServiceRuntime {
     /**
      * 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: string, key: string): string | null;
     /**
@@ -242,7 +273,7 @@ export declare class LocalServiceRuntime {
      * when the cache grows past {@link IDEMPOTENCY_PRUNE_THRESHOLD}.
      */
     recordIdempotentCompileRun(prepDataDir: string, key: string, runId: string): void;
-    /** Total cached idempotency entries across all workspaces. */
+    /** Total cached idempotency entries across all preparations. */
     private totalIdempotencyEntries;
     private pruneIdempotencyKeyCache;
     /**
@@ -253,10 +284,10 @@ export declare class LocalServiceRuntime {
      * unrelated runtime state.
      */
     expireIdempotencyKeyForTesting(prepDataDir: string, key: string): boolean;
-    listTestRuns(prepDataDir: string): TestRunResource[];
-    listTestRunsForPreparation(prepDataDir: string, preparationName: string): TestRunResource[];
-    getTestRun(prepDataDir: string, runId: string): TestRunResource | null;
-    createTestRun(prepDataDir: string, requestValue: unknown): Promise<TestRunResource>;
+    listVerifyRuns(prepDataDir: string): VerifyRunResource[];
+    listVerifyRunsForPreparation(prepDataDir: string, preparationName: string): VerifyRunResource[];
+    getVerifyRun(prepDataDir: string, runId: string): VerifyRunResource | null;
+    createVerifyRun(prepDataDir: string, requestValue: unknown): Promise<VerifyRunResource>;
     private runCompileInBackground;
     private runTestInBackground;
     private runReadinessCheckDraftInBackground;
@@ -282,6 +313,6 @@ export declare class LocalServiceRuntime {
     private readLatestReadinessRun;
     private checksEvaluatedEvent;
     private readinessUpdatedEvent;
-    private writeTestRun;
+    private writeVerifyRun;
 }
 export declare function createLocalServiceRuntime(options: LocalServiceRuntimeOptions): LocalServiceRuntime;