@zq-silk/yui 0.6.0 → 0.6.2

package/dist/controller/controllerMain.js

@@ -1,9 +1,22 @@
+import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveYuiHome } from "../storage/taskStore.js";
+import { handoverCandidateFromEnvironment, runHandoverCandidate } from "./handoverCandidate.js";
 import { startFileTaskControllerRuntime } from "./runtime.js";
 export async function runFileTaskControllerProcess(environment = process.env) {
     const home = resolveYuiHome(environment);
+    // Issue 02: a handover candidate runs the read-only prelude and promotes
+    // itself once the old owner exits. It never binds the main socket first.
+    const candidate = handoverCandidateFromEnvironment(environment);
+    if (candidate !== null) {
+        const result = await runHandoverCandidate(home, candidate.handoverId, { environment });
+        if (result.outcome === "aborted") {
+            process.stderr.write(`Controller handover candidate aborted: ${result.reason}\n`);
+            process.exitCode = 5;
+        }
+        return;
+    }
     const controller = await startFileTaskControllerRuntime(home, {
         environment,
         onError: (error) => {
@@ -25,8 +38,18 @@ export async function runFileTaskControllerProcess(environment = process.env) {
     }
 }
 function isEntrypoint() {
-    return process.argv[1] !== undefined
-        && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+    // Node's ESM loader resolves symlinks for import.meta.url, while
+    // process.argv[1] keeps the path as invoked. A release installed under a
+    // symlinked Home (e.g. /home -> /data00/home) must still detect itself as
+    // the entrypoint, so compare realpaths on both sides.
+    if (process.argv[1] === undefined)
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+    }
 }
 if (isEntrypoint()) {
     void runFileTaskControllerProcess().catch((error) => {

package/dist/controller/domainIdentity.js

@@ -297,18 +297,26 @@ export function ephemeralDomainFingerprint(identity, fileFingerprint) {
         fileFingerprint ?? ""
     ].join(":");
 }
+/**
+ * Parses the process start identity (field 20, `starttime`) from the content
+ * of a Linux `/proc/<pid>/stat` file. Shared by every reader so the parsing
+ * (including the `comm` field's embedded spaces/parentheses) is defined once.
+ * Returns undefined when the content is not a recognizable stat line.
+ */
+export function parseLinuxProcessStartIdentity(statContent) {
+    const closing = statContent.lastIndexOf(")");
+    if (closing < 0)
+        return undefined;
+    const identity = statContent.slice(closing + 1).trim().split(/\s+/u)[19];
+    return identity !== undefined && /^[0-9]{1,32}$/u.test(identity)
+        ? identity
+        : undefined;
+}
 export function readLinuxProcessStartIdentity(pid) {
     if (!Number.isSafeInteger(pid) || pid <= 0)
         return undefined;
     try {
-        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
-        const closing = stat.lastIndexOf(")");
-        if (closing < 0)
-            return undefined;
-        const identity = stat.slice(closing + 1).trim().split(/\s+/u)[19];
-        return identity !== undefined && /^[0-9]{1,32}$/u.test(identity)
-            ? identity
-            : undefined;
+        return parseLinuxProcessStartIdentity(readFileSync(`/proc/${pid}/stat`, "utf8"));
     }
     catch {
         return undefined;

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1,12 +1,17 @@
 import { isDeepStrictEqual } from "node:util";
+import { routeProviderProgress } from "../telemetry/telemetryRouter.js";
+import { NullTelemetrySink } from "../telemetry/telemetryStore.js";
 import { activeLiveRoleAgentSession, bindTaskRoleRun, clearTaskRoleRun, createRoleSessionSet, markTaskRoleRunDelivered, markTaskRoleRunPushed, recordObservedTaskRoleCompletion, recordRoleAgentSession, rememberRoleAgentCompletedTurn, settleTaskRoleCompletion, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
 import { createPendingTurnCompletion, hasRecentTurnId } from "../executor/turnCompletion.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { answerInputRequest } from "../input/inputRequest.js";
 import { activeRoleAgentBinding, updateRoleStatus } from "../role/role.js";
-import { effectiveLaunchSnapshotsCompatible, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchWithTaskMainWorkspace, effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain, resolveEffectiveLaunch, validateEffectiveLaunchSnapshot } from "../executor/effectiveLaunch.js";
 import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-import { failAgentRun, markAgentRunDelivered, markAgentRunPushed } from "../run/agentRun.js";
+import { failAgentRun, markAgentRunDelivered, markAgentRunPushed, reopenRunForProviderRetry, withProviderRetry } from "../run/agentRun.js";
+import { classifyProviderError, isRetryableProviderErrorClass } from "../lifecycle/providerErrorClass.js";
+import { providerRetryIsDue, scheduleProviderRetry } from "../run/providerRetry.js";
+import { providerRetryConfig } from "../run/providerRetryConfig.js";
 import { terminalizeExactTaskRun } from "../lifecycle/exactRunTerminalization.js";
 import { foldCanonicalLifecycleEvent } from "../lifecycle/canonicalLifecycleEvent.js";
 import { mapNativeLifecycleSignal } from "../lifecycle/providerLifecycleMapping.js";
@@ -14,7 +19,7 @@ import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
 import { createLeaderRecoveryNotification, createLeaderStallNotification } from "../scheduler/operatorNotification.js";
 import { pendingWakeupsMatch } from "../scheduler/pendingWakeup.js";
 import { queueLeaderWakeup } from "../scheduler/wakeupQueue.js";
-import { latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_RESOURCE_SUPPRESSED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
+import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, isRoleRunStalled, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_RESOURCE_SUPPRESSED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { formatAgentRunReceiptId, formatTaskRecordReference } from "../task/taskRecordReference.js";
@@ -22,11 +27,68 @@ import { bindExecution, claimPending, completeProcessing, releaseProcessing } fr
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { RUNTIME_CLEANUP_REQUIRED_REASON, RUNTIME_LAUNCH_RESERVED_REASON, RUNTIME_LIFECYCLE_OWNER, hasRuntimeCleanupObligation, hasRuntimeLifecycleWork, isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { nativeSessionIdForLaunch } from "../runtime/preallocatedNativeSession.js";
+const NULL_TELEMETRY_SINK = new NullTelemetrySink();
 /** Maps the authoritative FileTaskStore records to the scheduler's narrow port. */
 export class FileSchedulerStoreAdapter {
     store;
-    constructor(store) {
+    telemetry;
+    /**
+     * @param telemetry Optional sidecar wiring (Issue 09). Absent or `legacy`
+     * keeps master behavior (semantic progress events only); `dual` also
+     * upserts progress to the sidecar; `bounded` routes progress to the
+     * sidecar only and feeds the scheduler projection synthesized latest
+     * progress from the reader.
+     */
+    constructor(store, telemetry = null) {
         this.store = store;
+        this.telemetry = telemetry;
+    }
+    /**
+     * Revision-scoped read projection. Keyed by the store's durable revision;
+     * any committed mutation (ours or an external writer's) advances it and the
+     * next read rebuilds. A store without getStateRevision disables caching.
+     */
+    #readProjection = null;
+    #taskReadProjection(taskId) {
+        const revision = typeof this.store.getStateRevision === "function"
+            ? this.store.getStateRevision()
+            : Number.NaN;
+        const telemetryRevision = this.telemetry?.mode === "bounded"
+            ? this.telemetry.reader.revision()
+            : 0;
+        if (this.#readProjection === null
+            || this.#readProjection.revision !== revision
+            || this.#readProjection.telemetryRevision !== telemetryRevision) {
+            this.#readProjection = { revision, telemetryRevision, tasks: new Map() };
+        }
+        const tasks = this.#readProjection.tasks;
+        let task = tasks.get(taskId);
+        if (task === undefined) {
+            const semanticEvents = this.store.listEvents(taskId);
+            // In bounded mode progress lives only in the sidecar; merge the latest
+            // observation per Run so liveness/stall folds keep working. In legacy
+            // and dual modes semantic history already carries progress.
+            const events = this.telemetry?.mode === "bounded"
+                ? [...semanticEvents, ...this.telemetry.reader.latestProgressEvents(taskId)]
+                : semanticEvents;
+            task = {
+                events,
+                runFacts: foldRunProgressFacts(events),
+                agentRuns: this.store.listAgentRuns(taskId),
+                workItems: this.store.listWorkItems(taskId),
+                reviewRounds: this.store.listReviewRounds(taskId),
+                changeSets: this.store.listChangeSets(taskId),
+                integrationAttempts: this.store.listIntegrationAttempts(taskId),
+                inputRequests: this.store.listInputRequests(taskId),
+                durableJobs: this.store.listDurableJobs(taskId),
+                messages: this.store.listMessages(taskId)
+            };
+            tasks.set(taskId, task);
+        }
+        return task;
+    }
+    withRuntimeEventTransaction(execute) {
+        return this.store.withRuntimeEventTransaction(execute);
     }
     getPresentationContext() {
         return { timeZone: this.store.getConfig().timeZone };
@@ -98,10 +160,51 @@ export class FileSchedulerStoreAdapter {
         return session === undefined ? null : mapSession(session);
     }
     listEvents(taskId) {
-        return this.store.listEvents(taskId);
+        return this.#taskReadProjection(taskId).events;
+    }
+    listAgentRuns(taskId) {
+        return this.#taskReadProjection(taskId).agentRuns;
+    }
+    listWorkItems(taskId) {
+        return this.#taskReadProjection(taskId).workItems;
+    }
+    listReviewRounds(taskId) {
+        return this.#taskReadProjection(taskId).reviewRounds;
+    }
+    listIntegrationAttempts(taskId) {
+        return this.#taskReadProjection(taskId).integrationAttempts;
+    }
+    listDurableJobs(taskId) {
+        return this.#taskReadProjection(taskId).durableJobs;
+    }
+    listInputRequests(taskId) {
+        return this.#taskReadProjection(taskId).inputRequests;
+    }
+    listMessages(taskId) {
+        return this.#taskReadProjection(taskId).messages;
+    }
+    getRunProgressFacts(taskId, runId) {
+        return this.#taskReadProjection(taskId).runFacts.get(runId);
     }
     getRunDurableProgress(taskId, roleName, runId) {
-        return latestRunDurableProgressAt(this.store, taskId, roleName, runId);
+        const projected = this.#taskReadProjection(taskId);
+        // Serve the related-record fold from the same revision's projection: the
+        // event history and the WorkItem/Review/ChangeSet/Integration/Input lists
+        // are read once per Task per revision, and the per-Run checkpoint/activity
+        // facts come from the one-pass fold instead of per-candidate scans.
+        const view = {
+            getAgentRun: (id, agentRunId) => this.store.getAgentRun(id, agentRunId),
+            listEvents: () => projected.events,
+            getWorkItem: (id, workItemId) => this.store.getWorkItem(id, workItemId),
+            listReviewRounds: () => projected.reviewRounds,
+            listChangeSets: () => projected.changeSets,
+            listIntegrationAttempts: () => projected.integrationAttempts,
+            listInputRequests: () => projected.inputRequests
+        };
+        // A missing fold entry is an authoritative empty fold, not a signal to
+        // re-scan the whole history. Pass {} so latestRunDurableProgressAt treats
+        // the fold as present and skips the per-candidate fallback scans.
+        return latestRunDurableProgressAt(view, taskId, roleName, runId, projected.runFacts.get(runId) ?? {});
     }
     recordRoleRunStall(input) {
         return this.store.transaction((store) => {
@@ -241,8 +344,9 @@ export class FileSchedulerStoreAdapter {
         // A provider-ready fact for this exact generation is proven by a folded
         // runtime.provider-session-lifecycle event with preInputReady true and a
         // matching agent/launch/nativeSession fence. This reads durable folded truth
-        // only — no liveness, screen, or pane/PID inference.
-        return this.store.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-session-lifecycle"
+        // only — no liveness, screen, or pane/PID inference. Served from the
+        // revision projection: a stale miss only repeats an idempotent first push.
+        return this.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-session-lifecycle"
             && event.payload.roleName === input.roleName
             && event.payload.agentId === input.agentId
             && event.payload.preInputReady === "true"
@@ -265,6 +369,32 @@ export class FileSchedulerStoreAdapter {
     enqueueLeaderWakeup(taskId, reason, now) {
         return this.store.transaction((store) => (queueLeaderWakeup(store, taskId, reason, now)));
     }
+    listAllDurableJobs() {
+        return this.store.listAllDurableJobs();
+    }
+    /**
+     * Apply one durable-job transition and, in the SAME transaction, enqueue
+     * the Leader wakeup. A terminal job without its wakeup enqueued is a lost
+     * wakeup, so the two writes commit together or not at all.
+     *
+     * f6: The wakeup targets the Leader role mailbox (not the Task mailbox)
+     * and also queues a pending wakeup so processLeaderWakeups dispatches
+     * the Leader Run with the exact job-finished reason.
+     */
+    transitionDurableJob(taskId, jobId, transition, now, wakeup) {
+        return this.store.transaction((store) => {
+            const current = store.getDurableJob(taskId, jobId);
+            if (current === null)
+                return null;
+            const next = transition(current);
+            store.saveDurableJob(taskId, next);
+            if (wakeup !== undefined) {
+                enqueueWork(store, { kind: "role", taskId, roleName: "leader" }, wakeup.reason, now, [...wakeup.refs]);
+                queueLeaderWakeup(store, taskId, wakeup.reason, now);
+            }
+            return next;
+        });
+    }
     releaseLeaderWakeupAndEnqueue(taskId, batchId, reason, now) {
         const target = { kind: "role", taskId, roleName: "leader" };
         return this.store.transaction((store) => {
@@ -1383,6 +1513,11 @@ export class FileSchedulerStoreAdapter {
                 return { disposition: "obsolete", runId: input.runId };
             }
             const summary = claudeStopFailureSummary(input);
+            // Issue 04: a classified transient Provider failure keeps the exact Run
+            // and Native Session and is retried in place instead of terminalizing.
+            const retryDecision = this.providerRetryDecision(store, input, summary, now);
+            if (retryDecision !== null)
+                return retryDecision;
             const result = terminalizeExactTaskRun(store, {
                 taskId: input.taskId,
                 roleName: input.roleName,
@@ -1442,6 +1577,218 @@ export class FileSchedulerStoreAdapter {
             return { disposition: "applied", runId: input.runId };
         });
     }
+    /**
+     * Issue 04 in-place retry decision for one classified Provider failure.
+     * Returns an observation when the failure was handled without terminalizing
+     * the Run, or `null` to fall through to the existing terminalization path.
+     */
+    providerRetryDecision(store, input, summary, now) {
+        const config = providerRetryConfig();
+        if (config.mode === "off")
+            return null;
+        const classification = classifyProviderError({
+            adapterId: input.adapterId,
+            error: input.error,
+            errorDetails: input.errorDetails,
+            summary: input.lastAssistantMessage
+        });
+        const adapterEnabled = config.adapters.includes(input.adapterId);
+        const retryable = adapterEnabled
+            && isRetryableProviderErrorClass(classification.errorClass);
+        const shadow = config.mode === "shadow";
+        // Shadow mode records the classification and "would retry" fact without
+        // changing any behavior; the Run still terminalizes below.
+        if (shadow || !retryable) {
+            if (adapterEnabled) {
+                this.recordProviderRetryClassified(store, input, classification.errorClass, {
+                    wouldRetry: String(retryable),
+                    shadow: String(shadow)
+                }, now);
+            }
+            if (!shadow && classification.errorClass === "policy-denied") {
+                const blocked = this.applyProviderPolicyBlock(store, input, summary, now);
+                if (blocked !== null)
+                    return blocked;
+            }
+            return null;
+        }
+        // transport-uncertain: the Provider may have accepted the turn. If a
+        // native completion is already durable, the completion path owns the
+        // yield; do not resend.
+        if (classification.errorClass === "transport-uncertain") {
+            const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+            const pending = sessions?.pendingTurnCompletion;
+            if (pending !== null
+                && pending !== undefined
+                && pending.runId === input.runId
+                && pending.agentId === input.agentId) {
+                this.recordProviderRetryClassified(store, input, classification.errorClass, {
+                    wouldRetry: "false",
+                    shadow: "false",
+                    note: "native-turn-completion-durable"
+                }, now);
+                return { disposition: "applied", runId: input.runId };
+            }
+        }
+        const run = store.getAgentRun(input.taskId, input.runId);
+        if (run === null || run.status !== "active")
+            return null;
+        const retry = scheduleProviderRetry(run.providerRetry, {
+            errorClass: classification.errorClass,
+            launchId: input.launchId,
+            nativeSessionId: input.nativeSessionId,
+            lastErrorSummary: summary
+        }, now);
+        store.saveAgentRun(withProviderRetry(run, retry));
+        // Clear the in-flight fence so the original Session can be re-bound and
+        // re-pushed by the delivery path; the Session itself stays alive.
+        const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+        if (sessions !== null) {
+            store.saveTaskRoleSessionSet(clearTaskRoleRun(sessions, {
+                agentId: input.agentId,
+                runId: input.runId,
+                receiptId: `agent-run:${input.taskId}/${input.runId}`
+            }, now));
+        }
+        // Settle the delivery claim so the retry push can re-claim the mailbox.
+        const target = runtimeLifecycleTarget({
+            scope: "task",
+            taskId: input.taskId,
+            roleName: input.roleName
+        });
+        const mailbox = store.getWorkMailbox(target);
+        if (mailbox !== null && mailbox.processing !== null) {
+            const settled = completeProcessing(mailbox, mailbox.processing.batchId);
+            if (settled.processing === null && settled.pending === null) {
+                store.removeWorkMailbox(target);
+            }
+            else {
+                store.saveWorkMailbox(settled);
+            }
+        }
+        this.recordProviderRetryClassified(store, input, classification.errorClass, {
+            wouldRetry: "true",
+            shadow: "false",
+            attempt: String(retry.attempt),
+            nextAttemptAt: retry.nextAttemptAt
+        }, now);
+        return { disposition: "applied", runId: input.runId };
+    }
+    /**
+     * Issue 04 policy-denied handling: the Run stays active on its original
+     * Session, no retry is scheduled, and the Leader receives a bounded blocker.
+     * Yui never works around a policy denial by switching Session or widening
+     * permission.
+     */
+    applyProviderPolicyBlock(store, input, summary, now) {
+        const run = store.getAgentRun(input.taskId, input.runId);
+        if (run === null || run.status !== "active")
+            return null;
+        const retry = scheduleProviderRetry(run.providerRetry, {
+            errorClass: "policy-denied",
+            launchId: input.launchId,
+            nativeSessionId: input.nativeSessionId,
+            lastErrorSummary: summary,
+            scheduleNextAttempt: false
+        }, now);
+        store.saveAgentRun(withProviderRetry(run, retry));
+        this.recordProviderRetryClassified(store, input, "policy-denied", {
+            wouldRetry: "false",
+            shadow: "false",
+            note: "policy-denied-blocker"
+        }, now);
+        if (input.roleName !== "leader") {
+            enqueueWork(store, { kind: "role", taskId: input.taskId, roleName: "leader" }, "provider-policy-blocked", now, [{ type: "run", taskId: input.taskId, id: input.runId }]);
+        }
+        return { disposition: "applied", runId: input.runId };
+    }
+    recordProviderRetryClassified(store, input, errorClass, extra, now) {
+        store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-retry-classified", {
+            eventId: input.eventId,
+            runId: input.runId,
+            roleName: input.roleName,
+            errorClass,
+            ...extra
+        }, now));
+    }
+    /**
+     * Issue 04 durable retry timer: lists active Runs whose in-place retry is
+     * due. The Controller arms its deadline timer from this projection, so a
+     * Controller restart resumes the same attempt lineage.
+     */
+    listPendingProviderRetries() {
+        return this.store.listPendingProviderRetries();
+    }
+    /**
+     * Issue 04: reopens each due retry on its original Native Session. A Run
+     * whose Session is proven dead terminalizes with an exact replacement
+     * blocker; a live Session is reset for the existing delivery path, which
+     * re-pushes the exact same input in the same pass.
+     */
+    resolveDueProviderRetries(now, taskIds) {
+        const due = this.listPendingProviderRetries().filter((entry) => (Date.parse(entry.nextAttemptAt) <= now.getTime()
+            && (taskIds === undefined || taskIds.has(entry.taskId))));
+        const reopened = [];
+        for (const entry of due) {
+            this.store.transaction((store) => {
+                const run = store.getAgentRun(entry.taskId, entry.runId);
+                if (run === null
+                    || run.status !== "active"
+                    || run.providerRetry === undefined
+                    || run.providerRetry.nextAttemptAt === undefined
+                    || !providerRetryIsDue(run.providerRetry, now)) {
+                    return;
+                }
+                const sessions = store.getTaskRoleSessionSet(entry.taskId, entry.roleName);
+                const session = sessions?.sessions[run.effective.agentId];
+                const identityMatches = session !== undefined
+                    && session.adapterId === run.effective.adapterId
+                    && (run.providerRetry.nativeSessionId === undefined
+                        || session.nativeSessionId === run.providerRetry.nativeSessionId)
+                    && (run.providerRetry.launchId === undefined
+                        || session.launchId === run.providerRetry.launchId);
+                const sessionAlive = identityMatches
+                    && session.status !== "stopped"
+                    && session.status !== "broken";
+                if (!sessionAlive) {
+                    // Session-dead: stop in-place retry and raise a precise, actionable
+                    // replacement blocker for the Leader.
+                    const summary = `Provider retry stopped: the original Session is gone `
+                        + `(run ${run.id}, attempt ${run.providerRetry.attempt}, `
+                        + `last error: ${run.providerRetry.lastErrorSummary}). `
+                        + `A replacement Session requires an explicit Leader recovery decision.`;
+                    const result = terminalizeExactTaskRun(store, {
+                        taskId: entry.taskId,
+                        roleName: entry.roleName,
+                        agentId: run.effective.agentId,
+                        runId: run.id,
+                        receiptId: formatAgentRunReceiptId(entry.taskId, run.id),
+                        ...(run.providerRetry.nativeSessionId === undefined
+                            ? {}
+                            : { nativeSessionId: run.providerRetry.nativeSessionId }),
+                        ...(run.providerRetry.launchId === undefined
+                            ? {}
+                            : { launchId: run.providerRetry.launchId }),
+                        outcome: { status: "failed", summary }
+                    }, now);
+                    if (result.disposition !== "applied")
+                        return;
+                    store.saveEvent(entry.taskId, createTaskEvent(store.nextEventId(entry.taskId), entry.taskId, "runtime.provider-retry-session-dead", { runId: run.id, attempt: String(run.providerRetry.attempt) }, now));
+                    enqueueWork(store, { kind: "role", taskId: entry.taskId, roleName: "leader" }, "role-run-failed", now, [{ type: "run", taskId: entry.taskId, id: run.id }]);
+                    return;
+                }
+                // Reopen the Run on its original Session: reset transport markers,
+                // switch to resume, and mark the projection in-flight. The delivery
+                // pass re-pushes the exact same input in this same pass.
+                store.saveAgentRun(reopenRunForProviderRetry(run, now));
+                // The retry decision settled the original delivery claim; re-queue the
+                // Role mailbox so the delivery pass can claim and re-push the Run.
+                enqueueWork(store, { kind: "role", taskId: entry.taskId, roleName: entry.roleName }, "provider-retry-repush", now, [{ type: "run", taskId: entry.taskId, id: run.id }]);
+                reopened.push(formatTaskRecordReference(entry.taskId, run.id, "agentRun"));
+            });
+        }
+        return reopened;
+    }
     /**
      * Folds a provider SessionStart lifecycle fact
      * through the canonical contract. Session-started/ready never advance Run
@@ -1596,22 +1943,29 @@ export class FileSchedulerStoreAdapter {
                 case "apply":
                     if (decision.outcome.outcome !== "advance-progress")
                         return "obsolete";
-                    if (store.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-turn-progress"
-                        && event.payload.eventId === input.eventId)))
-                        return "applied";
-                    store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-turn-progress", {
-                        eventId: input.eventId,
-                        roleName: input.roleName,
-                        agentId: input.agentId,
-                        adapterId: input.adapterId,
-                        launchId: input.launchId,
-                        nativeSessionId: input.nativeSessionId,
-                        runId: input.runId,
-                        progressId: input.progressId,
-                        progressAt: input.receivedAt,
-                        ...(input.sequence === undefined ? {} : { sequence: String(input.sequence) })
-                    }, now));
-                    return "applied";
+                    return routeProviderProgress({
+                        mode: this.telemetry?.mode ?? "legacy",
+                        entry: toTelemetryEntry(input),
+                        semanticExists: this.telemetry?.mode === "bounded"
+                            ? false
+                            : store.listEvents(input.taskId).some((event) => (event.type === "runtime.provider-turn-progress"
+                                && event.payload.eventId === input.eventId)),
+                        writeSemantic: () => {
+                            store.saveEvent(input.taskId, createTaskEvent(store.nextEventId(input.taskId), input.taskId, "runtime.provider-turn-progress", {
+                                eventId: input.eventId,
+                                roleName: input.roleName,
+                                agentId: input.agentId,
+                                adapterId: input.adapterId,
+                                launchId: input.launchId,
+                                nativeSessionId: input.nativeSessionId,
+                                runId: input.runId,
+                                progressId: input.progressId,
+                                progressAt: input.receivedAt,
+                                ...(input.sequence === undefined ? {} : { sequence: String(input.sequence) })
+                            }, now));
+                        },
+                        sink: this.telemetry?.sink ?? NULL_TELEMETRY_SINK
+                    });
             }
         });
     }
@@ -2102,7 +2456,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
     const effective = input.effective === undefined
         ? resolvedEffective
         : validateEffectiveLaunchSnapshot(input.effective);
-    if (!effectiveLaunchSnapshotsCompatible(resolvedEffective, effective)) {
+    if (!effectiveLaunchSnapshotsCompatibleForTaskMain(resolvedEffective, effective, store.getTaskWorkspace(input.taskId))) {
         throw new Error("Reserved native Session effective launch changed before persistence.");
     }
     if (effective.agentId !== input.agentId || effective.adapterId !== input.adapterId) {
@@ -2115,7 +2469,7 @@ function recordTaskRuntimeNativeSession(store, input, now) {
         ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
         policy: "fixed",
         status: "running",
-        effective
+        effective: effectiveExisting?.effective ?? effective
     }, now);
     store.saveRoleSessionSet(updated);
     return updated.sessions[input.agentId];
@@ -2174,17 +2528,20 @@ function mapRole(store, role) {
         ?? undefined;
     const reopened = role.name === "leader"
         && store.getPendingWakeup(role.taskId)?.reasons.includes("task-reopened") === true;
+    const liveSession = activeLiveRoleAgentSession(store.getTaskRoleSessionSet(role.taskId, role.name));
     const effective = reopened
         ? resolveEffectiveLaunch({
             role,
             purpose: "execution",
             ...(workspace === undefined ? {} : { workspace })
         })
-        : activeLiveRoleAgentSession(store.getTaskRoleSessionSet(role.taskId, role.name))?.effective ?? resolveEffectiveLaunch({
-            role,
-            purpose: "execution",
-            ...(workspace === undefined ? {} : { workspace })
-        });
+        : liveSession !== null && workspace?.owner.type === "task"
+            ? effectiveLaunchWithTaskMainWorkspace(liveSession.effective, workspace)
+            : liveSession?.effective ?? resolveEffectiveLaunch({
+                role,
+                purpose: "execution",
+                ...(workspace === undefined ? {} : { workspace })
+            });
     return {
         taskId: role.taskId,
         name: role.name,
@@ -2204,6 +2561,13 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
         if (active.effective.agentId !== agentId) {
             throw new Error(`Native Session registration does not match the effective Run Agent: ${taskId}/${roleName}.`);
         }
+        if (existing !== undefined) {
+            const workspace = active.workspace ?? store.getTaskWorkspace(taskId);
+            if (!effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, active.effective, workspace)) {
+                throw new Error(`Native Session effective launch does not match the active Run: ${taskId}/${roleName}.`);
+            }
+            return existing.effective;
+        }
         return active.effective;
     }
     if (existing !== undefined)
@@ -2370,3 +2734,31 @@ function runLaunchEventPayload(run) {
         writeProjectIds: run.effective.writeProjectIds.join(",") || "none"
     };
 }
+/**
+ * Maps a provider progress observation to the telemetry sidecar entry. The
+ * payload mirrors the semantic event payload so sidecar rows and legacy
+ * events carry identical evidence.
+ */
+function toTelemetryEntry(input) {
+    return {
+        taskId: input.taskId,
+        roleName: input.roleName,
+        runId: input.runId,
+        generation: input.launchId !== "" ? input.launchId : input.nativeSessionId,
+        progressId: input.progressId,
+        ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
+        payload: {
+            eventId: input.eventId,
+            roleName: input.roleName,
+            agentId: input.agentId,
+            adapterId: input.adapterId,
+            launchId: input.launchId,
+            nativeSessionId: input.nativeSessionId,
+            runId: input.runId,
+            progressId: input.progressId,
+            progressAt: input.receivedAt,
+            ...(input.sequence === undefined ? {} : { sequence: String(input.sequence) })
+        },
+        receivedAt: input.receivedAt
+    };
+}