@zq-silk/yui 0.15.12 → 0.16.0

package/dist/controller/jobClient.js

@@ -1,4 +1,4 @@
-import { resolveJobCaller } from "../commands/taskActor.js";
+import { resolveJobCaller } from "../task/taskAuthority.js";
 import { callFileTaskController } from "./clientRuntime.js";
 export async function startDurableJob(home, params, clientOptions = {}) {
     // rr6/f2: Route through callFileTaskController so an Integration-issued
@@ -7,8 +7,8 @@ export async function startDurableJob(home, params, clientOptions = {}) {
     const result = await callFileTaskController(home, "job.start", params, clientOptions);
     return parseStartResult(result);
 }
-export async function getDurableJob(home, taskId, jobId, clientOptions = {}) {
-    const result = await callFileTaskController(home, "job.get", { taskId, jobId }, clientOptions);
+export async function getDurableJob(home, taskId, jobId, caller, clientOptions = {}) {
+    const result = await callFileTaskController(home, "job.get", { taskId, jobId, caller }, clientOptions);
     return parseJobResult(result);
 }
 export async function acknowledgeDurableJob(home, taskId, jobId, caller, clientOptions = {}) {
@@ -89,7 +89,7 @@ export function createControllerIntegrationJobPort(home, clientOptions = {}) {
             return job;
         },
         async getJob(taskId, jobId) {
-            return getDurableJob(home, taskId, jobId, clientOptions);
+            return getDurableJob(home, taskId, jobId, resolveJobCaller(clientOptions.environment, taskId), clientOptions);
         },
         async cancelJob(taskId, jobId) {
             // rr8/rr12: Bind the cancel request to the caller's managed identity.

package/dist/controller/jobControl.js

@@ -3,18 +3,22 @@
  * record is created or cancel-requested. The Controller socket layer calls
  * this port for `job.*` requests; nothing else writes queued jobs.
  *
- * Creation is idempotent per (owner, project, head, steps, workspace, env):
- * a repeated `job.start` with the same inputs returns the existing job with
- * `created: false`, so a Leader retry can never spawn duplicate runners.
+ * Creation is idempotent per authenticated actor and explicit request ID.
+ * Repeating that request with identical inputs returns the original Job;
+ * changing its input is a conflict. Integration owner identity additionally
+ * preserves its admitted Job across authorized Session replacement.
  */
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { resolve, sep } from "node:path";
-import { acknowledgeUnknownDurableJob, createDurableJob, durableJobIdempotencyKey, isDurableJobTerminal, requestDurableJobCancel, retryDurableJobIdempotencyKey } from "../job/durableJob.js";
 import { activeLiveRoleAgentSession } from "../executor/agentExecutor.js";
+import { acknowledgeUnknownDurableJob, createDurableJob, durableJobIdempotencyKey, isDurableJobTerminal, requestDurableJobCancel, retryDurableJobIdempotencyKey } from "../job/durableJob.js";
 import { CallAuthority } from "../kernel/callAuthority.js";
 import { redactLaunchText } from "../runtime/launchDiagnostics.js";
-import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
+import { requireManagedTaskCaller, ManagedRuntimeDriftError } from "../runtime/managedCaller.js";
+import { CliError } from "../errors/cliError.js";
+import { assertJobAssignmentScope, JobAssignmentScopeError } from "../job/jobAssignmentScope.js";
+import { assertContextRecordReadable } from "../context/taskContext.js";
 export function createDurableJobControl(store) {
     const authority = createJobCallAuthority(store);
     return {
@@ -25,6 +29,7 @@ export function createDurableJobControl(store) {
             // startJob with the same key create a duplicate job.
             return store.transaction((tx) => {
                 const context = authority.authenticate(Object.freeze({ ...params.caller }), params.taskId);
+                requireJobAssignment(tx, params, params.caller);
                 assertNonSecretJobInput(params);
                 const baseKey = durableJobIdempotencyKey({
                     owner: params.owner,
@@ -37,8 +42,7 @@ export function createDurableJobControl(store) {
                 const inputDigest = params.retryOf === undefined
                     ? baseKey
                     : retryDurableJobIdempotencyKey(baseKey, params.retryOf);
-                const requestId = params.requestId === undefined ? inputDigest
-                    : requiredId(params.requestId, "job.start requestId");
+                const requestId = requiredId(params.requestId, "job.start requestId");
                 // An IntegrationAttempt already is a durable operation identity.
                 // Recovery by another authorized Role must find its original Job,
                 // including the window before Integration persisted the returned id.
@@ -68,12 +72,6 @@ export function createDurableJobControl(store) {
                     }
                     return { job: existing, created: false };
                 }
-                // A historical content-addressed request has no attributable caller.
-                // Do not silently execute it again under a newly attributed identity.
-                const historical = tx.findDurableJobByIdempotencyKey(params.taskId, inputDigest);
-                if (params.requestId === undefined && historical !== null) {
-                    throw jobDomainError(`Historical request already exists: ${historical.id}; inspect it or select an explicit new requestId.`);
-                }
                 authority.authorize(context, params.taskId);
                 validateStartParams(tx, params);
                 const id = tx.nextDurableJobId(params.taskId);
@@ -97,7 +95,21 @@ export function createDurableJobControl(store) {
                 return { job, created: true };
             });
         },
-        getJob(taskId, jobId) {
+        getJob(taskId, jobId, caller) {
+            if (caller === undefined)
+                throw jobControlError("UNAUTHORIZED", "Job reads require an explicit caller.");
+            try {
+                assertContextRecordReadable(store, taskId, "job", jobId, caller.scope === "user" ? {} : {
+                    YUI_SESSION_SCOPE: caller.scope, YUI_TASK_ID: caller.taskId, YUI_ROLE: caller.role,
+                    YUI_AGENT_ID: caller.agentId, YUI_ADAPTER_ID: caller.adapterId, YUI_NATIVE_SESSION_ID: caller.nativeSessionId
+                });
+            }
+            catch (error) {
+                if (error instanceof ManagedRuntimeDriftError || (error instanceof CliError && error.code === "USAGE_ERROR")) {
+                    throw jobControlError("UNAUTHORIZED", error.message);
+                }
+                throw error;
+            }
             return store.getDurableJob(taskId, jobId);
         },
         cancelJob(taskId, jobId, now, caller) {
@@ -108,6 +120,7 @@ export function createDurableJobControl(store) {
                 // rr8: Bind the cancel request to the caller's managed identity. The
                 // same rules as job.start apply, checked against the job's owner.
                 assertCallerAuthorized(tx, caller, taskId);
+                requireJobAssignment(tx, current, caller);
                 const next = requestDurableJobCancel(current, now);
                 if (next !== current)
                     tx.saveDurableJob(taskId, next);
@@ -120,6 +133,7 @@ export function createDurableJobControl(store) {
                 if (current === null)
                     return null;
                 assertCallerAuthorized(tx, caller, taskId);
+                requireJobAssignment(tx, current, caller);
                 const next = acknowledgeUnknownDurableJob(current, now);
                 if (next !== current)
                     tx.saveDurableJob(taskId, next);
@@ -152,8 +166,19 @@ export function authorizeJobStart(store, job) {
     if (jobAuthorityBinding(store, scope, role, job.taskId) !== job.operation.authorityRef) {
         throw jobDomainError("Job caller binding was revoked; no execution was started.");
     }
+    requireJobAssignment(store, job, { scope, role });
     validateJobTarget(store, job);
 }
+function requireJobAssignment(store, target, caller) {
+    try {
+        assertJobAssignmentScope(store, target, caller);
+    }
+    catch (error) {
+        if (error instanceof JobAssignmentScopeError)
+            throw jobControlError("UNAUTHORIZED", error.message);
+        throw error;
+    }
+}
 function jobAuthorityBinding(store, scope, roleName, taskId) {
     // A Host detach/reattach preserves the native Session and its queued work.
     // Authenticate the live launch at ingress, but bind accepted Jobs to the
@@ -328,8 +353,8 @@ function validateJobTarget(store, params) {
  * - `task` + mismatched taskId: rejected.
  * - A non-Leader Task caller requires its current active Assignment.
  * - A Leader Task caller requires its current, unrevoked native Session.
- * - `task`: authority inside the matching Task after current Session and
- *   native Session verification; Role does not narrow it.
+ * - Non-Leader Task callers additionally pass the shared exact Assignment
+ *   check for every Job operation and before a queued Job starts.
  */
 /**
  * Verify the caller's current native Session and Task scope. This local Home
@@ -470,28 +495,26 @@ export function parseDurableJobStartParams(value) {
         env,
         steps,
         caller,
-        ...(record.requestId === undefined ? {} : {
-            requestId: requiredId(record.requestId, "job.start requestId")
-        }),
+        requestId: requiredId(record.requestId, "job.start requestId"),
         ...(retryOf === undefined ? {} : { retryOf })
     };
 }
 export function parseDurableJobRefParams(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)
-        || Object.keys(value).length !== 2) {
+        || Object.keys(value).length !== 3) {
         throw jobControlError("INVALID_PARAMS", "DurableJob ref params are invalid.");
     }
     const record = value;
     return {
         taskId: requiredId(record.taskId, "DurableJob taskId"),
-        jobId: requiredId(record.jobId, "DurableJob jobId")
+        jobId: requiredId(record.jobId, "DurableJob jobId"),
+        caller: parseCaller(record.caller)
     };
 }
 /**
  * rr8: `job.cancel` params carry the caller identity so the Controller can
- * bind the cancel request to the caller's managed scope. Distinct from
- * `parseDurableJobRefParams` (used by `job.get`) because cancel requires the
- * third `caller` key.
+ * bind the cancel request to the caller's managed scope. Reads also carry
+ * an explicit caller but use Context's read authority rather than write authority.
  */
 export function parseDurableJobCancelParams(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)
@@ -551,7 +574,7 @@ function parseSteps(value) {
             throw jobControlError("INVALID_PARAMS", "job.start steps are invalid.");
         }
         const record = entry;
-        const allowed = new Set(["name", "command", "timeoutMs"]);
+        const allowed = new Set(["name", "command", "argv", "cwd", "env", "timeoutMs"]);
         for (const key of Object.keys(record)) {
             if (!allowed.has(key)) {
                 throw jobControlError("INVALID_PARAMS", "job.start steps are invalid.");
@@ -559,6 +582,15 @@ function parseSteps(value) {
         }
         const name = requiredId(record.name, "job.start step name");
         const command = requiredId(record.command, "job.start step command");
+        const argv = record.argv === undefined ? undefined : record.argv;
+        if (argv !== undefined && (!Array.isArray(argv) || argv.length === 0
+            || argv.some(value => typeof value !== "string" || value.length === 0 || value.includes("\0")))) {
+            throw jobControlError("INVALID_PARAMS", `job.start step argv is invalid: ${name}.`);
+        }
+        const cwd = record.cwd === undefined ? undefined : requiredId(record.cwd, "job.start step cwd");
+        if (cwd !== undefined && !cwd.startsWith("/")) {
+            throw jobControlError("INVALID_PARAMS", `job.start step cwd must be absolute: ${name}.`);
+        }
         if (names.has(name)) {
             throw jobControlError("INVALID_PARAMS", `job.start step names must be unique: ${name}.`);
         }
@@ -572,6 +604,9 @@ function parseSteps(value) {
         const step = {
             name,
             command,
+            ...(argv === undefined ? {} : { argv: argv }),
+            ...(cwd === undefined ? {} : { cwd }),
+            ...(record.env === undefined ? {} : { env: parseStringMap(record.env, "job.start step env") }),
             ...(record.timeoutMs === undefined ? {} : { timeoutMs: record.timeoutMs })
         };
         steps.push(step);

package/dist/controller/jobSupervisor.js

@@ -12,14 +12,14 @@
  *  cancelRequestedAt -> write cancel fence + SIGTERM
  */
 import { spawn } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, statSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { writeTextFileAtomically } from "../storage/durableFile.js";
 import { cancelQueuedDurableJob, completeDurableJob, isDurableJobTerminal, markDurableJobUnknown, markDurableJobWakeupNotified, rejectQueuedDurableJob, startDurableJob, touchDurableJobHeartbeat } from "../job/durableJob.js";
-import { readLinuxProcessStartIdentity } from "./domainIdentity.js";
-import { wakeReason } from "../scheduler/wakeReason.js";
 import { recordOperationEvidence } from "../kernel/operationFacts.js";
+import { wakeReason } from "../scheduler/wakeReason.js";
+import { writeTextFileAtomically } from "../storage/durableFile.js";
+import { readLinuxProcessStartIdentity } from "./domainIdentity.js";
 const DEFAULT_STEP_TIMEOUT_MS = 30 * 60_000;
 const HEARTBEAT_STALE_MS = 2 * 60_000;
 const SIGKILL_GRACE_MS = 30_000;

package/dist/controller/providerRetryDelivery.js

@@ -1,14 +1,14 @@
 import { performance } from "node:perf_hooks";
 import { runTaskCommand } from "../commands/taskCommands.js";
-import { retryIntentBlocker } from "./providerRetryAdmission.js";
-import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending } from "../runtime/providerRetry.js";
-import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
-import { runtimeLifecycleTarget, hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
-import { sendAgentHostRunControl, inspectAgentHostSocket, agentHostControlSocketPath, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
-import { redactAgentErrorText } from "../runtime/agentError.js";
-import { createTaskEvent } from "../event/taskEvent.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
+import { createTaskEvent } from "../event/taskEvent.js";
 import { settleGlobalRetryInput } from "../message/globalProviderRetry.js";
+import { redactAgentErrorText } from "../runtime/agentError.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, agentHostControlSocketPath, inspectAgentHostSocket, sendAgentHostRunControl } from "../runtime/agentHost.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { cancelProviderRetry, providerRetryAttemptId, providerRetryPending } from "../runtime/providerRetry.js";
+import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
+import { retryIntentBlocker } from "./providerRetryAdmission.js";
 /** Hooks in the existing Controller pass and nearest-deadline timer. SQLite's
  * current Provider input is the only pending intent; nothing is queued here. */
 export function createProviderRetryHooks(home, store, ports = {}) {

package/dist/controller/runtime.js

@@ -1,59 +1,60 @@
-import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveRuntimeHealth, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { isDeepStrictEqual } from "node:util";
-import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
-import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { agentProcessReadinessProbe, ExecutorRegistry } from "../executor/executorRegistry.js";
-import { activeLiveRoleAgentSession, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
-import { roleSessionMayContinue, effectiveLaunchConfig, resolveEffectiveLaunch } from "../executor/effectiveLaunch.js";
+import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
+import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveRuntimeHealth, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { controllerSocketPath } from "../core/controllerEndpoint.js";
+import { createTaskEvent } from "../event/taskEvent.js";
 import { AgentConfigurationCatalogService, validateAgentLaunchConfiguration } from "../executor/agentConfigurationCatalog.js";
-import { isTaskOwnedWorkspace, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
+import { activeLiveRoleAgentSession, roleAgentSessionResumeMode } from "../executor/agentExecutor.js";
+import { effectiveLaunchConfig, resolveEffectiveLaunch, roleSessionMayContinue } from "../executor/effectiveLaunch.js";
+import { agentProcessReadinessProbe, ExecutorRegistry } from "../executor/executorRegistry.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
+import { createKernelPorts } from "../kernel/kernelPorts.js";
+import { createGlobalRoleMessage } from "../message/message.js";
+import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
+import { createResourceAutoGc } from "../resources/autoResourceGc.js";
+import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
+import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
+import { appendGlobalProcessExitObservation } from "../runtime/globalProcessExitStore.js";
+import { AgentHostPromptPushAdapter, FileTaskRuntimeIsolation, ProviderContinuationReconciliationService, TmuxSessionHost } from "../runtime/index.js";
+import { launchBrokerForHome } from "../runtime/launchBroker.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
+import { replayRuntimeProcessExitOutbox } from "../runtime/processExitOutbox.js";
+import { providerRetryPrompt } from "../runtime/providerRetry.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { managedRuntimeRoot } from "../storage/homeLayout.js";
 import { SqliteTaskStore } from "../storage/sqliteStore.js";
 import { AsyncTaskStoreClient, resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
-import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
+import { SurfaceContributions } from "../surface/surfaceContributions.js";
+import { taskOwnsManagedWorkspace } from "../task/task.js";
+import { openSchedulerTelemetry } from "../telemetry/telemetryWiring.js";
 import { NodeCommandExecutor } from "../tmux/commandExecutor.js";
 import { TmuxManager, yuiTmuxServerName } from "../tmux/tmuxManager.js";
-import { AgentHostPromptPushAdapter, FileTaskRuntimeIsolation, TmuxSessionHost, ProviderContinuationReconciliationService } from "../runtime/index.js";
-import { startFileTaskController } from "./controller.js";
-import { AgentHostProviderTurnFenceError, AgentHostProviderSessionBusyError, FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
-import { openSchedulerTelemetry } from "../telemetry/telemetryWiring.js";
-import { createFileArtifactPort, createLinuxProcessPort, DurableJobSupervisor } from "./jobSupervisor.js";
-import { authorizeJobStart } from "./jobControl.js";
-import { createKernelPorts } from "../kernel/kernelPorts.js";
-import { createCapabilityDispatcher } from "./capabilityBridge.js";
 import { createControllerWeb } from "../web/controllerWeb.js";
-import { createWebTaskSurface } from "../web/webTaskSurface.js";
-import { SurfaceContributions } from "../surface/surfaceContributions.js";
 import { TmuxWebTerminalService } from "../web/tmuxWebTerminal.js";
-import { FileTaskWorkflowRuntime } from "./clientRuntime.js";
-import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
+import { createWebTaskSurface } from "../web/webTaskSurface.js";
+import { isTaskOwnedWorkspace, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { AgentRuntimeObserver } from "./agentRuntimeObserver.js";
-import { AsyncRuntimeEventProcessor, FileRuntimeEventProcessor, createAsyncRuntimeObserver } from "./runtimeEventProcessor.js";
-import { RuntimeLaunchCoordinator } from "./runtimeLaunchCoordinator.js";
+import { createCapabilityDispatcher } from "./capabilityBridge.js";
+import { FileTaskWorkflowRuntime } from "./clientRuntime.js";
+import { startFileTaskController } from "./controller.js";
 import { ephemeralDomainFromEnvironment, recordEphemeralTmuxTarget } from "./domainIdentity.js";
 import { createEphemeralResourceReaper } from "./ephemeralResourceReaper.js";
+import { AgentHostProviderSessionBusyError, AgentHostProviderTurnFenceError, FileSchedulerStoreAdapter } from "./fileSchedulerStoreAdapter.js";
+import { deliverGlobalInputs } from "./globalInputDelivery.js";
+import { authorizeJobStart } from "./jobControl.js";
+import { createFileArtifactPort, createLinuxProcessPort, DurableJobSupervisor } from "./jobSupervisor.js";
+import { createProviderRetryHooks } from "./providerRetryDelivery.js";
+import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
 import { scanControllerResourceInventory } from "./resourceInventoryLinux.js";
 import { ResourceInventoryClient } from "./resourceInventoryRpc.js";
-import { createResourceAutoGc } from "../resources/autoResourceGc.js";
-import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
+import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
+import { AsyncRuntimeEventProcessor, createAsyncRuntimeObserver, FileRuntimeEventProcessor } from "./runtimeEventProcessor.js";
+import { RuntimeLaunchCoordinator } from "./runtimeLaunchCoordinator.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
-import { launchBrokerForHome } from "../runtime/launchBroker.js";
-import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
-import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
-import { replayRuntimeProcessExitOutbox } from "../runtime/processExitOutbox.js";
-import { appendGlobalProcessExitObservation } from "../runtime/globalProcessExitStore.js";
-import { deliverGlobalInputs } from "./globalInputDelivery.js";
-import { providerRetryPrompt } from "../runtime/providerRetry.js";
-import { createProviderRetryHooks } from "./providerRetryDelivery.js";
-import { createGlobalRoleMessage } from "../message/message.js";
-import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { createTaskEvent } from "../event/taskEvent.js";
-import { runPurposeAdmitsTaskState } from "../agentRun/agentRun.js";
-import { taskOwnsManagedWorkspace } from "../task/task.js";
+import { readTaskAgentCapabilities } from "./agentCapabilities.js";
 /** Production composition root for the current SQLite TaskStore + tmux Controller. */
 export async function startFileTaskControllerRuntime(home, options = {}) {
     // The current Home always uses SQLite. The persistence worker is enabled by
@@ -86,9 +87,13 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         : undefined;
     let closeKernel = async () => { };
     let closeWeb = async () => { };
+    let closeTelemetry = async () => { };
     try {
+        const telemetry = options.schedulerStore === undefined
+            ? openSchedulerTelemetry(home, store.getConfig(), asyncStoreClient) : null;
+        closeTelemetry = () => telemetry?.sink.close() ?? Promise.resolve();
         const schedulerStore = options.schedulerStore
-            ?? new FileSchedulerStoreAdapter(store, openSchedulerTelemetry(home, store.getConfig()));
+            ?? new FileSchedulerStoreAdapter(store, telemetry);
         const domainIdentity = options.domainIdentity
             ?? ephemeralDomainFromEnvironment(options.environment ?? process.env);
         const planner = options.planner ?? new FileRoleLaunchPlanner(home, store, {
@@ -387,7 +392,6 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             environment: options.environment ?? process.env, onError: options.onError
         });
         const webSurface = createWebTaskSurface(store, { runtime: {
-                notifyStateChanged: (taskId) => runningRuntime?.signal(`task:${taskId}`),
                 notifyMailboxChanged: (target) => {
                     if (target.kind === "role")
                         runningRuntime?.signal(`role:${target.taskId}/${target.roleName}`);
@@ -454,8 +458,10 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         const continuationReconciler = options.continuationMetadata === undefined
             ? undefined
             : new ProviderContinuationReconciliationService(store, schedulerStore, options.continuationMetadata);
-        const running = await startFileTaskController(home, schedulerStore, delivery, (method, params) => method === "web.start" || method === "web.stop" || method === "web.status"
-            ? web.dispatch(method, params) : lifecycleDispatcher(method, params), {
+        const running = await startFileTaskController(home, schedulerStore, delivery, (method, params) => method === "task.role-capabilities"
+            ? readTaskAgentCapabilities(store, catalogs, params)
+            : method === "web.start" || method === "web.stop" || method === "web.status"
+                ? web.dispatch(method, params) : lifecycleDispatcher(method, params), {
             intervalMs: options.intervalMs
                 ?? reconciliationIntervalMilliseconds(store.getConfig().reconciliationIntervalSeconds),
             signalWindowMs: options.signalWindowMs,
@@ -543,12 +549,12 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
         }
         let resourceClose;
         const closeResources = () => {
-            resourceClose ??= Promise.all([
+            resourceClose ??= closeTelemetry().finally(() => Promise.all([
                 web.close(),
                 kernel.close(),
                 asyncStoreClient?.close() ?? Promise.resolve(),
                 inventoryClient?.close() ?? Promise.resolve()
-            ]).then(() => undefined).finally(() => {
+            ])).then(() => undefined).finally(() => {
                 ownedStore?.close();
             });
             return resourceClose;
@@ -583,6 +589,7 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
     catch (error) {
         // The socket may never have opened. Startup failure must still release
         // this attempt's workers/instances instead of leaving an uncallable process.
+        await closeTelemetry().catch(() => undefined);
         await Promise.allSettled([
             closeWeb(),
             closeKernel(),

package/dist/controller/runtimeEventProcessor.js

@@ -1,18 +1,15 @@
 import { isRuntimeTokenEvidence } from "../runtime/runtimeObservation.js";
-import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 const DEFAULT_MAX_RUNTIME_EVENTS_PER_DRAIN = 64;
 /** Folds immutable Hook facts in one bounded transaction before acknowledging them. */
 export class FileRuntimeEventProcessor {
     inbox;
     observer;
     options;
-    drivers;
     drainLaneCursor = 0;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
         this.options = options;
-        this.drivers = options.drivers ?? builtinAgentDriverRegistry();
     }
     drain(now) {
         const acknowledgedEventIds = [];
@@ -540,13 +537,11 @@ export class AsyncRuntimeEventProcessor {
     inbox;
     observer;
     options;
-    drivers;
     drainLaneCursor = 0;
     constructor(inbox, observer, options = {}) {
         this.inbox = inbox;
         this.observer = observer;
         this.options = options;
-        this.drivers = options.drivers ?? builtinAgentDriverRegistry();
     }
     async drainAsync(now) {
         const acknowledgedEventIds = [];

package/dist/controller/sessionOwnerReconciliation.js

@@ -132,6 +132,11 @@ export class SessionOwnerReconciliation {
         }
         const result = await terminateSessionOwners(owner, records, this.#terminationPorts(), options);
         if (result.outcome === "stop-confirmed") {
+            // A signalled Host exits into a retained tmux pane. Explicit release
+            // removes that window too, after physical exit proof, not on observation.
+            if (records.length > 0) {
+                this.#tmux?.killRole(owner.scope === "task" ? owner.taskId : "operator", owner.roleName);
+            }
             for (const record of result.confirmed) {
                 this.#store.removeSessionOwner(sessionOwnerProcessKey(record));
             }

package/dist/controller/taskAgentError.js

@@ -0,0 +1,35 @@
+import { createTaskEvent } from "../event/taskEvent.js";
+import { redactAgentErrorText } from "../runtime/agentError.js";
+import { captureAgentFailureContext } from "../runtime/agentFailureContext.js";
+/** One persistence boundary. Ingress owns Provider classification, execution
+ * fences and routing; this writer never invents an execution or recovery plan. */
+export function recordTaskAgentError(store, input, now) {
+    return store.transaction(tx => {
+        const error = input.error;
+        const payload = {
+            ...Object.fromEntries(Object.entries(input.evidence ?? {}).filter((entry) => typeof entry[1] === "string" && (entry[0] === "lastOutput" || entry[1].trim().length > 0))),
+            sourceEventId: input.sourceEventId, roleName: input.roleName,
+            agentId: input.agentId, adapterId: input.adapterId, driverId: input.driverId,
+            source: error.source, phase: error.phase, category: error.category, code: error.code,
+            message: redactAgentErrorText(error.message), raw: redactAgentErrorText(error.raw),
+            inputDisposition: error.inputDisposition, sessionDisposition: error.sessionDisposition,
+            ...(error.retryAfterMs === undefined ? {} : { retryAfterMs: String(error.retryAfterMs) })
+        };
+        const identity = ["sourceEventId", "roleName", "agentId", "adapterId", "driverId",
+            "source", "phase", "category", "code", "inputDisposition", "sessionDisposition",
+            "runId", "attemptId", "nativeSessionId", "nativeTurnId", "observationEventId",
+            "message", "errorName", "causeName", "hostState", "registrationDisposition",
+            "retryAfterMs", "lastOutput", ...(payload.attemptId === undefined ? ["raw"] : [])];
+        const duplicate = [...tx.listEventsByType(input.taskId, ["runtime.agent-error"])].reverse().find(event => identity.every(key => event.payload[key] === payload[key]));
+        // Keep the first original raw cause/configuration for a fixed failure.
+        // Changed normalized facts are distinct evidence, not a replay.
+        if (duplicate !== undefined)
+            return { event: duplicate, created: false };
+        const event = createTaskEvent(tx.nextEventId(input.taskId), input.taskId, "runtime.agent-error", {
+            ...payload,
+            capabilityContext: captureAgentFailureContext(input.effective, input.effective === undefined ? null : tx.getConfiguredAgent(input.effective.agentId))
+        }, now);
+        tx.saveEvent(input.taskId, event);
+        return { event, created: true };
+    });
+}

package/dist/coordination/workMailboxQueue.js

@@ -1,18 +1,11 @@
 import { completeProcessing, consumePendingBatch, createWorkMailbox, enqueueSignal, mailboxBatches, mailboxEntityRefKey } from "./workMailbox.js";
-const LEGACY_ROLE_RUN_DISPATCH_REASONS = new Set([
-    "turn-dispatched",
-    "turn-retried",
-    "review-requested",
-    "workitem-synthesis-ready",
-    "review-synthesis-ready"
-]);
 /** Atomically useful when called inside the caller's TaskStore transaction. */
 export function enqueueWork(store, target, reason, occurredAt, refs = [], metadata = {}) {
     const mailbox = store.getWorkMailbox(target) ?? createWorkMailbox(target);
     // Archive is an admission boundary, not an acknowledgement of old input.
     // Runtime cleanup mailboxes remain usable for exact-owner recovery.
     if ((target.kind === "task" || target.kind === "role")
-        && store.getTask?.(target.taskId)?.status === "archived")
+        && store.getTask(target.taskId)?.status === "archived")
         return mailbox;
     const queued = enqueueSignal(mailbox, {
         reason,
@@ -79,26 +72,11 @@ export function captureRoleRunDispatch(mailbox, input) {
             };
         }
     }
-    // Valid earlier dispatches used sequence-generated dedupe keys and could
-    // include a companion WorkItem ref. Consume that complete legacy batch once
-    // the exact AgentRun reaches an accepted or terminal boundary.
-    if (pending.requestCount === 1
-        && pending.sources.length === 1
-        && pending.sources[0] === "yui"
-        && pending.reasons.some((reason) => LEGACY_ROLE_RUN_DISPATCH_REASONS.has(reason))
-        && pending.refs.some((ref) => (mailboxEntityRefKey(ref) === mailboxEntityRefKey(exactRef)))) {
-        return {
-            kind: "pending",
-            fromSequence: pending.fromSequence,
-            toSequence: pending.toSequence
-        };
-    }
     return null;
 }
 /**
  * Settles one exact ordinary Role AgentRun dispatch. Provider acceptance is the
- * normal boundary; terminalization calls the same operation for conclusively
- * unaccepted and valid earlier dispatches.
+ * normal boundary; terminalization uses the same exact dispatch identity.
  */
 export function settleRoleRunDispatch(store, input, expected) {
     if (expected === null)

package/dist/core/controllerClient.js

@@ -2,10 +2,10 @@ import { randomUUID } from "node:crypto";
 import { lstat, readFile } from "node:fs/promises";
 import { createConnection } from "node:net";
 import { join } from "node:path";
-import { CONTROLLER_DISCOVERY_PATH, FILE_TASK_CONTROLLER_PROTOCOL_VERSION, MAX_CONTROLLER_MESSAGE_BYTES, ControllerProtocolError, encodeControllerRequest, parseControllerDiscovery, parseControllerResponse } from "./protocol.js";
 import { isControllerSocketPathForHome } from "./controllerEndpoint.js";
-import { readHomeFilesystemId } from "./homeFilesystemIdentity.js";
 import { findLiveControllerProcessForHome, inspectLiveControllerProcess } from "./controllerProcessIdentity.js";
+import { readHomeFilesystemId } from "./homeFilesystemIdentity.js";
+import { CONTROLLER_DISCOVERY_PATH, ControllerProtocolError, encodeControllerRequest, FILE_TASK_CONTROLLER_PROTOCOL_VERSION, MAX_CONTROLLER_MESSAGE_BYTES, parseControllerDiscovery, parseControllerResponse } from "./protocol.js";
 export class ControllerClientError extends Error {
     code;
     constructor(code, message) {