@interf/compiler 0.13.0 → 0.16.0

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

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