@zq-silk/yui 0.8.3 → 0.8.7

package/dist/controller/clientRuntime.js

@@ -7,15 +7,12 @@ import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
 import { hasRuntimeLifecycleWork } from "../runtime/lifecycleReservation.js";
 import { assertControllerStatusIdentity } from "../runtime/exactControlPlane.js";
 import { EPHEMERAL_DOMAIN_ENVIRONMENT_NAMES } from "./domainIdentity.js";
-import { YUI_VERSION, yuiVersionIdentity } from "../version.js";
+import { yuiVersionIdentity } from "../version.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
 import { WorkspaceCleanupBlockedError } from "../repository/taskWorkspacePreparer.js";
+import { CONTROLLER_SHUTDOWN_TIMEOUT_MS, LIFECYCLE_REQUEST_TIMEOUT_MS } from "../runtime/runtimeDeadlines.js";
 const STARTUP_TIMEOUT_MS = 5_000;
-// A lifecycle RPC may legitimately occupy the Controller for 30 seconds.
-// Restart must allow that request to drain before deciding shutdown is stuck.
-const SHUTDOWN_TIMEOUT_MS = 45_000;
 const POLL_INTERVAL_MS = 50;
-const LIFECYCLE_REQUEST_TIMEOUT_MS = 30_000;
 const ENVIRONMENT_REFRESH_TIMEOUT_MS = 500;
 const CONFIGURATION_REFRESH_TIMEOUT_MS = 500;
 const CONTROLLER_OPERATIONAL_ENVIRONMENT = [
@@ -140,12 +137,8 @@ function assertCompatibleControllerStatus(status, expectedVersion) {
             + "Run `yui controller restart` before writing new task records.");
     }
     const actualVersion = statusRecord.version;
-    const expected = expectedVersion ?? YUI_VERSION;
-    const versionMismatch = expectedVersion === undefined
-        ? typeof actualVersion === "string" && actualVersion !== expected
-        : actualVersion !== expected;
-    if (versionMismatch) {
-        throw new Error(`Controller version is incompatible (expected ${expected}, found ${typeof actualVersion === "string" ? actualVersion : "unknown"}). `
+    if (expectedVersion !== undefined && actualVersion !== expectedVersion) {
+        throw new Error(`Controller version is incompatible (expected ${expectedVersion}, found ${typeof actualVersion === "string" ? actualVersion : "unknown"}). `
             + "Run `yui controller restart` before writing new task records.");
     }
     // Ordinary callers must authenticate the complete control-plane identity.
@@ -154,7 +147,11 @@ function assertCompatibleControllerStatus(status, expectedVersion) {
     // path authenticates its executable, argv, and version immediately after
     // readiness in ensureFileTaskControllerIdentity.
     if (expectedVersion === undefined) {
-        assertControllerStatusIdentity(status, yuiVersionIdentity());
+        const identity = yuiVersionIdentity();
+        assertControllerStatusIdentity(status, {
+            ...identity,
+            version: typeof actualVersion === "string" ? actualVersion : identity.version
+        });
     }
 }
 function spawnDetachedFileTaskController(home, environment) {
@@ -168,7 +165,7 @@ function spawnDetachedFileTaskController(home, environment) {
 /** Stops the per-home Controller and waits until its owned discovery is gone. */
 export async function stopFileTaskController(home, options = {}) {
     const call = options.call ?? callController;
-    const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
+    const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, CONTROLLER_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
     const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
     const expectedPid = options.expectedPid === undefined
         ? undefined
@@ -224,7 +221,7 @@ export async function stopFileTaskController(home, options = {}) {
 /** Restarts only the per-home Controller process; managed tmux sessions remain untouched. */
 export async function restartFileTaskController(home, options = {}) {
     const call = options.call ?? callController;
-    const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
+    const shutdownTimeoutMs = positive(options.shutdownTimeoutMs, CONTROLLER_SHUTDOWN_TIMEOUT_MS, "shutdownTimeoutMs");
     const pollMs = positive(options.pollIntervalMs, POLL_INTERVAL_MS, "pollIntervalMs");
     let current = null;
     let previousPid;
@@ -529,7 +526,10 @@ export class FileTaskWorkflowRuntime {
             && this.workspacePreparer !== undefined) {
             await this.workspacePreparer.prepareTaskWorkspace(taskId);
         }
-        await callFileTaskController(this.home, "scheduler.scan", {}, this.clientOptions);
+        await callFileTaskController(this.home, "scheduler.scan", {}, {
+            ...this.clientOptions,
+            requestTimeoutMs: LIFECYCLE_REQUEST_TIMEOUT_MS
+        });
     }
 }
 const MANAGED_RUNTIME_ENVIRONMENT = new Set(YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES);

package/dist/controller/controller.js

@@ -10,6 +10,7 @@ import { processOperatorInputNotifications } from "../scheduler/operatorInputNot
 import { startControllerServer } from "../core/controllerServer.js";
 import { monotonicMilliseconds } from "../core/controllerTelemetry.js";
 import { isProjectMaintenanceFenced } from "../repository/projectMaintenanceLock.js";
+import { isHandoverLockHeld } from "../release/runtimeRelease.js";
 import { KeyedWorkQueue } from "../coordination/keyedWorkQueue.js";
 import { MailboxScheduler } from "../coordination/mailboxScheduler.js";
 import { nearestDeadlineBatch } from "../coordination/deadlineScheduler.js";
@@ -45,7 +46,7 @@ const ZERO_DRAIN_METRICS = Object.freeze({
  * Runs one lean scheduler pass. Due native Turn completions are folded before
  * liveness, so a valid Hook boundary fences destructive process reconciliation.
  */
-export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), inputDeliveryRecoveryCutoff, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS) {
+export async function runControllerSchedulerPass(store, delivery, now, workspacePreparer, scope = { kind: "full" }, includeOperator = true, runtimeCleanupOutcomes = [], lifecycleHost, stallWindowMs = DEFAULT_STALL_WINDOW_MS, maintenanceFence, onMaintenanceFenceDefer, blockedTaskIds = new Set(), inputDeliveryRecoveryCutoff, diagnosticAfterMs = DEFAULT_WORKFLOW_STALL_CANDIDATE_AGE_MS, leaderWakeFence) {
     const compiledSelection = compileReconcileSelection(scope);
     const selection = includeOperator
         ? { ...compiledSelection, blockedTaskIds }
@@ -58,7 +59,9 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
     await controlEventLoopTurn();
     const failedCleanupRoles = await processSelectedRoleRuntimeCleanups(store, delivery, lifecycleHost, scope, now, runtimeCleanupOutcomes, blockedTaskIds);
     const roleSelection = selectionWithoutFailedCleanupRoles(store, selection, failedCleanupRoles);
-    const wakeupSelection = selectionWithoutFailedLeaderCleanupTasks(store, selection, failedCleanupRoles);
+    const availableWakeupSelection = () => (leaderWakeFence?.() === true
+        ? exactTaskSelection(new Set())
+        : selectionWithoutFailedLeaderCleanupTasks(store, selection, failedCleanupRoles));
     if (selection.full)
         repairOrphanedActiveTasks(store, now, selection);
     const claimedTaskMailboxes = claimSelectedTaskMailboxes(store, selection, now);
@@ -66,7 +69,7 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
         // Durable Leader work that already has a ready Task workspace belongs to
         // the control path. Dispatch it before any unrelated Task workspace I/O;
         // the processor itself retains the fail-closed workspace-ready guard.
-        const initialWakeups = selectedPendingWakeups(store, wakeupSelection);
+        const initialWakeups = selectedPendingWakeups(store, availableWakeupSelection());
         const initialWakeupResults = await processLeaderWakeups(store, delivery, now, exactTaskSelection(new Set(initialWakeups.keys())));
         // Preserve ready-Leader-first ordering, then bound the repeated state
         // projections that follow it in this pass.
@@ -134,7 +137,8 @@ export async function runControllerSchedulerPass(store, delivery, now, workspace
             && workspacePreparation.ready.has(result.taskId)
             ? [result.taskId]
             : [])));
-        const laterWakeupTaskIds = new Set([...selectedPendingWakeups(store, wakeupSelection)].flatMap(([taskId, wakeup]) => {
+        const laterWakeupTaskIds = new Set([...selectedPendingWakeups(store, availableWakeupSelection())]
+            .flatMap(([taskId, wakeup]) => {
             const initial = initialWakeups.get(taskId);
             return initial === undefined
                 || !pendingWakeupsMatch(initial, wakeup)
@@ -823,6 +827,7 @@ export class FileTaskController {
     #onExpiredEphemeralDomain;
     #maintenanceFence;
     #onMaintenanceFenceDefer;
+    #leaderWakeFence;
     #jobSupervisor;
     #continuationReconciler;
     #current;
@@ -867,6 +872,7 @@ export class FileTaskController {
         this.#onExpiredEphemeralDomain = options.onExpiredEphemeralDomain;
         this.#maintenanceFence = options.maintenanceFence;
         this.#onMaintenanceFenceDefer = options.onMaintenanceFenceDefer;
+        this.#leaderWakeFence = options.leaderWakeFence;
         this.#jobSupervisor = options.jobSupervisor;
         this.#continuationReconciler = options.continuationReconciler;
         this.#signalScheduler = new MailboxScheduler(async (keys) => { await this.#requestPass({ kind: "dirty", keys }); }, {
@@ -1118,7 +1124,7 @@ export class FileTaskController {
                     // processes Leader wakeups.
                     this.#jobSupervisor?.reconcile(this.#now());
                     if (scope.kind === "full") {
-                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#startedAt, this.#diagnosticAfterMs);
+                        result = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, scope, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, runtimeFailedTaskIds, this.#startedAt, this.#diagnosticAfterMs, this.#leaderWakeFence);
                     }
                     else {
                         const dirtyPass = await this.#runDirtySchedulerPass(scope, runtimeCleanupOutcomes, runtimeFailedTaskIds);
@@ -1216,7 +1222,7 @@ export class FileTaskController {
         const taskScopes = partition.taskScopes.filter((taskScope) => (!blockedTaskIds.has(taskScope.taskId)));
         const orderedResults = [];
         if (partition.globalKeys.length > 0) {
-            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs));
+            orderedResults.push(await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: partition.globalKeys }, false, runtimeCleanupOutcomes, this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs, this.#leaderWakeFence));
         }
         if (taskScopes.length === 0
             || this.#stopped
@@ -1249,7 +1255,7 @@ export class FileTaskController {
                     if (this.#stopped || this.#pendingFull)
                         continue;
                     try {
-                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs);
+                        taskResults[selected.index] = await runControllerSchedulerPass(this.store, this.delivery, this.#now(), this.#workspacePreparer, { kind: "dirty", keys: selected.taskScope.keys }, false, taskCleanupOutcomes[selected.index], this.#lifecycleHost, this.#stallWindowMs, this.#maintenanceFence, this.#onMaintenanceFenceDefer, blockedTaskIds, this.#startedAt, this.#diagnosticAfterMs, this.#leaderWakeFence);
                         this.#clearTaskPassRetry(selected.taskScope.taskId);
                     }
                     catch (error) {
@@ -1676,7 +1682,9 @@ export async function startFileTaskController(home, store, delivery, dispatcher,
     const runtime = new FileTaskController(store, delivery, {
         ...options,
         maintenanceFence: options.maintenanceFence
-            ?? ((projectId) => isProjectMaintenanceFenced(home, projectId))
+            ?? ((projectId) => isProjectMaintenanceFenced(home, projectId)),
+        leaderWakeFence: options.leaderWakeFence
+            ?? (() => isHandoverLockHeld(home))
     });
     let stopping = false;
     const lifecycleRequests = new Set();

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,10 +1,12 @@
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
-import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
+import { activeLiveRoleAgentSession, bindTaskRoleProviderRuntime, bindTaskRoleRun, clearTaskRoleProviderRuntimeForCleanup, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, prepareTaskRoleRunRedispatch, recordRoleAgentSession, recordTaskRoleTurnBoundary, rememberRoleAgentCompletedTurn, updateRoleAgentSessionStatus, updateTaskRoleProviderRuntime } from "../executor/agentExecutor.js";
 import { acceptProviderTurn, beginProviderTurn, createProviderRuntimeBinding, endProviderActivation, currentProviderActivation, currentProviderConversation, markProviderTurnDeliveryUnknown, rejectProviderTurn, settleProviderTurn, startProviderActivation, supersedeProviderConversation, updateProviderConversationRecoverability } from "../runtime/providerRuntimeIdentity.js";
 import { decideProviderRecovery } from "../runtime/providerRecoveryDecision.js";
+import { boundProviderRetryBeforeFirstProgress, projectFirstProgressStopLoss } from "../runtime/firstProgressStopLoss.js";
 import { hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { buildTaskWakeEnvelope } from "../context/wakeNotification.js";
 import { createTaskWake, fallbackWakeCursor, latestTaskWake } from "../scheduler/taskWake.js";
 import { rolloverTaskRoleSessionForContextBudget } from "../lifecycle/contextBudgetRollover.js";
@@ -595,7 +597,7 @@ export class FileSchedulerStoreAdapter {
             const latest = latestTaskWake(reader.listTaskWakes(taskId));
             const fromCursor = latest?.toCursor ?? fallbackWakeCursor({
                 taskCreatedAt: task.createdAt,
-                leaderRunCreatedAt: reader.listAgentRuns(taskId)
+                leaderRunCreatedAt: operationalTaskRecords(reader.listAgentRuns(taskId), reader.listEvents(taskId), "agent-run")
                     .filter((run) => run.roleName === "leader")
                     .at(-1)?.createdAt
             });
@@ -674,6 +676,9 @@ export class FileSchedulerStoreAdapter {
             : sessions?.sessions[agentId];
         return session === undefined ? null : mapSession(session);
     }
+    getTaskRoleSessionSet(taskId, roleName) {
+        return this.store.getTaskRoleSessionSet(taskId, roleName);
+    }
     listEvents(taskId) {
         return this.#taskReadProjection(taskId).events;
     }
@@ -1222,7 +1227,14 @@ export class FileSchedulerStoreAdapter {
                     startedAt: now.toISOString()
                 }), batchId);
             }
-            markRuntimeOwnerSessionStopped(store, runtimeOwnerFromTarget(target), now);
+            const owner = runtimeOwnerFromTarget(target);
+            markRuntimeOwnerSessionStopped(store, owner, now);
+            if (owner.scope === "task") {
+                const sessions = store.getTaskRoleSessionSet(owner.taskId, owner.roleName);
+                if (sessions !== null && sessions.providerBinding !== null) {
+                    store.saveTaskRoleSessionSet(clearTaskRoleProviderRuntimeForCleanup(sessions, now));
+                }
+            }
             saveRuntimeLifecycleMailbox(store, mailbox);
             return true;
         });
@@ -1288,6 +1300,40 @@ export class FileSchedulerStoreAdapter {
     clearPendingWakeup(taskId) { this.store.clearPendingWakeup(taskId); }
     getLeaderFailure(taskId) { return this.store.getLeaderFailure(taskId); }
     getOperatorNotification(taskId) { return this.store.getOperatorNotification(taskId); }
+    saveLeaderFirstProgressStopLoss(input) {
+        return this.store.transaction((store) => {
+            const task = store.getTask(input.taskId);
+            const role = store.getRole(input.taskId, input.roleName);
+            if (task === null || task.status !== "active" || role === null
+                || store.getLeaderFailure(input.taskId) !== null) {
+                return "state-changed";
+            }
+            const stopLoss = projectFirstProgressStopLoss({
+                sessions: store.getTaskRoleSessionSet(input.taskId, input.roleName),
+                events: store.listEvents(input.taskId),
+                workItems: store.listWorkItems(input.taskId),
+                reviewRounds: store.listReviewRounds(input.taskId),
+                integrations: store.listIntegrationAttempts(input.taskId)
+            });
+            if (!stopLoss.exhausted || stopLoss.fingerprint !== input.expectedFingerprint) {
+                return "state-changed";
+            }
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const lastSession = sessions === null
+                ? undefined
+                : [...(sessions.history ?? []), ...Object.values(sessions.sessions)]
+                    .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+                    .at(-1);
+            const message = `Leader first-progress stop-loss: ${stopLoss.reason}`;
+            store.saveRole(input.taskId, updateRoleStatus(role, "failed", input.now));
+            store.saveLeaderFailure(recordLeaderFailure(input.taskId, lastSession?.nativeSessionId ?? "(unregistered)", message, input.now, null));
+            store.saveOperatorNotification(createLeaderRecoveryNotification(input.taskId, message, input.now, store.getOperatorNotification(input.taskId)));
+            enqueueWork(store, { kind: "operator" }, "leader-first-progress-stop-loss", input.now, [
+                { type: "task", id: input.taskId }
+            ]);
+            return "recorded";
+        });
+    }
     saveLeaderDispatch(input) {
         return this.store.transaction((store) => {
             const task = store.getTask(input.task.id);
@@ -2241,7 +2287,7 @@ export class FileSchedulerStoreAdapter {
             failedNativeTurnId: input.nativeTurnId,
             lastErrorSummary: summary,
             ...(input.retryAfterMs === undefined ? {} : { retryAfterMs: input.retryAfterMs })
-        }, now, configuredProviderRetryPolicy(store));
+        }, now, configuredProviderRetryPolicy(store, input.taskId, input.roleName));
         if (retryDecision.outcome === "exhausted") {
             this.recordProviderRetryClassified(store, input, classification.errorClass, {
                 wouldRetry: "false",
@@ -2253,7 +2299,7 @@ export class FileSchedulerStoreAdapter {
             if (run.providerRetry === undefined)
                 return null;
             const finalized = finalizeProviderRetryDeadline(store, run, retryDecision.reason === "attempts"
-                ? `Provider retry failed after all ${config.delaysMs.length} in-Session continuation attempts.`
+                ? `Provider retry failed after all ${run.providerRetry.maxRetries} in-Session continuation attempts.`
                 : retryDecision.reason === "retry-after-window"
                     ? `Provider Retry-After exceeded the bounded ${config.maxWindowMs / 1_000}-second episode window.`
                     : `Provider retry did not recover within the bounded ${config.maxWindowMs / 1_000}-second episode window.`, retryDecision.reason === "attempts" ? "attempts-exhausted" : "episode-window-exhausted", now);
@@ -3616,6 +3662,7 @@ function mapSession(session) {
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
         ...(session.launchId === undefined ? {} : { launchId: session.launchId }),
+        ...(session.title === undefined ? {} : { title: session.title }),
         status: session.status,
         effective: session.effective,
         updatedAt: session.updatedAt
@@ -3629,6 +3676,7 @@ function saveTaskSession(store, role, session, status, now, launchId) {
         adapterId: session.adapterId,
         nativeSessionId: session.nativeSessionId,
         ...(launchId === undefined ? {} : { launchId }),
+        ...(session.title === undefined ? {} : { title: session.title }),
         policy: "fixed",
         status,
         effective: session.effective
@@ -3659,7 +3707,7 @@ function bindTaskRoleRunInFlight(store, role, run, now) {
         agentId,
         runId: run.id,
         receiptId: agentRunDeliveryReceiptId(run)
-    }, now);
+    }, now, run.mode);
     store.saveRoleSessionSet(updated);
 }
 function markTaskRoleRunPushedInFlight(store, role, run, now) {
@@ -4021,7 +4069,19 @@ function compareCanonicalObservationOrder(left, right) {
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
         || left.eventId.localeCompare(right.eventId);
 }
-function configuredProviderRetryPolicy(store) {
+function configuredProviderRetryPolicy(store, taskId, roleName) {
     const config = providerRetryConfig(store.getConfig());
+    if (taskId !== undefined && roleName === "leader") {
+        const progress = projectFirstProgressStopLoss({
+            sessions: store.getTaskRoleSessionSet(taskId, roleName),
+            events: store.listEvents(taskId),
+            workItems: store.listWorkItems(taskId),
+            reviewRounds: store.listReviewRounds(taskId),
+            integrations: store.listIntegrationAttempts(taskId)
+        });
+        if (progress.firstProgressAt === undefined) {
+            return boundProviderRetryBeforeFirstProgress(config, progress);
+        }
+    }
     return { delaysMs: config.delaysMs, maxWindowMs: config.maxWindowMs };
 }

package/dist/controller/handoverCandidate.js

@@ -19,6 +19,7 @@ import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { detectRunningRelease, isOwnerLive, readActiveReleasePointer, readHandoverFence, removeCandidateDiscovery, removeHandoverFence, writeCandidateDiscovery, writeHandoverFence, writeHandoverReceipt, writeRuntimeIdentity } from "../release/runtimeRelease.js";
 import { startFileTaskControllerRuntime } from "./runtime.js";
 import { readLinuxProcessStartIdentity } from "./domainIdentity.js";
+import { RELEASE_HANDOVER_OLD_OWNER_GRACE_MS } from "../runtime/runtimeDeadlines.js";
 export const CONTROLLER_CANDIDATE_ENV = "YUI_CONTROLLER_CANDIDATE";
 export const CONTROLLER_HANDOVER_ID_ENV = "YUI_CONTROLLER_HANDOVER_ID";
 const DEFAULT_POLL_INTERVAL_MS = 100;
@@ -29,7 +30,7 @@ const DEFAULT_POLL_INTERVAL_MS = 100;
  * a second independent grace (see `DEFAULT_DUAL_OWNER_GRACE_MS` in
  * `releaseHandover.ts`, which is only an optional confirmation debounce).
  */
-export const DEFAULT_DUAL_OWNER_GRACE_MS = 30_000;
+export const DEFAULT_DUAL_OWNER_GRACE_MS = RELEASE_HANDOVER_OLD_OWNER_GRACE_MS;
 /** Reads the candidate configuration from the process environment. */
 export function handoverCandidateFromEnvironment(environment) {
     if (environment[CONTROLLER_CANDIDATE_ENV] !== "1")
@@ -85,7 +86,6 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         dualOwner: false
     }));
     advanceFence(home, fence, "candidate-ready", now().toISOString());
-    const committedAt = Date.now();
     let dualOwnerReported = false;
     for (;;) {
         const current = readHandoverFence(home);
@@ -111,7 +111,7 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         }
         if (current.phase === "committed"
             && !oldDead
-            && Date.now() - committedAt > dualOwnerGraceMs
+            && committedFenceAgeMs(current, now()) > dualOwnerGraceMs
             && !dualOwnerReported) {
             // The old Controller was told to exit but is still live. Stay read-only
             // and make the dual-owner condition visible; never write concurrently.
@@ -129,6 +129,13 @@ export async function runHandoverCandidate(home, handoverId, options = {}) {
         await delay(pollIntervalMs);
     }
 }
+function committedFenceAgeMs(fence, observedAt) {
+    const committedAt = Date.parse(fence.updatedAt);
+    if (!Number.isFinite(committedAt)) {
+        throw new Error("Committed handover fence timestamp is invalid.");
+    }
+    return observedAt.getTime() - committedAt;
+}
 async function promote(home, fence, environment, now) {
     removeCandidateDiscovery(home);
     const controller = await startFileTaskControllerRuntime(home, { environment });

package/dist/controller/sessionNotify.js

@@ -1,6 +1,5 @@
 import { callController } from "../core/controllerClient.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
-import { yuiRunBodyFromInputMessage, yuiRunIdFromInputMessages } from "../run/runIdentity.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { setCodexThreadName } from "../execution/codexThreadNaming.js";
 import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
@@ -50,9 +49,11 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
     const nativeSessionId = requireText(payload["thread-id"], "Codex thread-id");
     const turnId = requireText(payload["turn-id"], "Codex turn-id");
     const lastAssistantMessage = requireAssistantMessage(payload["last-assistant-message"]);
-    const runId = yuiRunIdFromInputMessages(payload["input-messages"]);
+    const runId = environment.YUI_RUN_ID === undefined
+        ? undefined
+        : requireText(environment.YUI_RUN_ID, "YUI_RUN_ID");
     const title = environment.YUI_SESSION_TITLE === undefined
-        ? sessionTitleFromInputMessages(payload["input-messages"])
+        ? undefined
         : requireText(environment.YUI_SESSION_TITLE, "YUI_SESSION_TITLE");
     const scope = environment.YUI_SESSION_SCOPE;
     if (scope !== "task" && scope !== "global") {
@@ -117,19 +118,6 @@ function requireAssistantMessage(value) {
     }
     return text;
 }
-function sessionTitleFromInputMessages(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    for (const entry of value) {
-        if (typeof entry !== "string")
-            continue;
-        const body = yuiRunBodyFromInputMessage(entry);
-        const normalized = body.trim().replaceAll(/\s+/g, " ");
-        if (normalized.length > 0)
-            return truncateSessionText(normalized);
-    }
-    return undefined;
-}
 function shouldSetThreadName(home, params) {
     if (params.scope !== "task"
         || params.title === undefined
@@ -168,12 +156,6 @@ function threadNameRequest(params, environment) {
         return null;
     }
 }
-function truncateSessionText(value) {
-    const truncated = value.slice(0, 1_024);
-    return /[\uD800-\uDBFF]$/.test(truncated)
-        ? truncated.slice(0, -1)
-        : truncated;
-}
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/executor/agentAdapter.js

@@ -276,7 +276,7 @@ class ClaudeAdapter extends BaseAdapter {
         return ["--append-system-prompt-file", input.managedContextFile];
     }
     compileResume(input) {
-        const launch = super.compileNew(input);
+        const launch = this.compileNew(input);
         return { ...launch, argv: [...launch.argv, "--resume", nativeId(input.nativeSessionId)] };
     }
     compileManagedControl(input, mode, nativeSessionId) {
@@ -285,7 +285,7 @@ class ClaudeAdapter extends BaseAdapter {
         }
         const sessionId = nativeId(nativeSessionId);
         const launch = mode === "new"
-            ? super.compileNew(input)
+            ? this.compileNew(input)
             : this.compileResume({ ...input, nativeSessionId: sessionId });
         return {
             ...launch,

package/dist/executor/agentExecutor.js

@@ -173,9 +173,29 @@ export function retireTaskRoleSessionsForWorkspace(set, now) {
         // receive a fresh identity after the Role workspace changes.
         history: [...(set.history ?? []), ...Object.values(set.sessions)],
         sessions: {},
+        providerBinding: null,
         updatedAt: timestamp
     });
 }
+/**
+ * Clears the Provider transport identity after its physical runtime is proven
+ * stopped, without retiring workspace-bound Session records. Workspace
+ * retirement remains a separate, stricter transaction after every supported
+ * placeholder has been terminalized.
+ */
+export function clearTaskRoleProviderRuntimeForCleanup(set, now) {
+    validateRoleSessionSet(set);
+    if (set.inFlight !== null) {
+        throw new Error("Cannot clear a Task Role Provider runtime with unsettled Run state.");
+    }
+    if (set.providerBinding === null)
+        return set;
+    return validateRoleSessionSet({
+        ...set,
+        providerBinding: null,
+        updatedAt: requireDate(now, "Provider Runtime cleanup timestamp")
+    });
+}
 /**
  * Terminalizes only the aggregate-16 Claude placeholder shape after the
  * caller has fenced the Task store and proved that the exact Role has no live
@@ -261,18 +281,18 @@ export function roleAgentSessionResumeMode(set, agentId, desired, workspace) {
         }
         return "new";
     }
+    if (session.status === "stopped" || session.status === "broken") {
+        return "new";
+    }
     const compatible = set.owner.scope === "task"
         ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, desired, workspace)
         : effectiveLaunchSnapshotsCompatible(session.effective, desired);
     if (compatible)
         return "resume";
-    if (session.status !== "stopped" && session.status !== "broken") {
-        throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
-            + "Stop the existing native process before starting a fresh Session.");
-    }
-    return "new";
+    throw new Error(`Role Agent session is incompatible with the next effective launch: ${agentId}. `
+        + "Stop the existing native process before starting a fresh Session.");
 }
-export function bindTaskRoleRun(set, fence, preparedAt) {
+export function bindTaskRoleRun(set, fence, preparedAt, mode) {
     validateRoleSessionSet(set);
     assertTaskRoleSessionSet(set);
     const normalized = normalizeTaskRoleRunFence(fence);
@@ -285,9 +305,9 @@ export function bindTaskRoleRun(set, fence, preparedAt) {
         throw new Error("Task Role session set already has an in-flight Run.");
     }
     const timestamp = requireDate(preparedAt, "Task Role Run preparedAt");
-    const providerBinding = set.providerBinding === null
-        ? null
-        : rebindProviderRuntimeRun(set.providerBinding, normalized.runId);
+    const providerBinding = mode === "resume" && set.providerBinding !== null
+        ? rebindProviderRuntimeRun(set.providerBinding, normalized.runId)
+        : null;
     const updated = {
         ...set,
         inFlight: { ...normalized, preparedAt: timestamp },