@zq-silk/yui 0.12.3 → 0.12.4

package/dist/commands/taskIntegrationCommands.js

@@ -6,7 +6,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { createIntegrationAttempt, recordResolutionDecision, supersedeIntegration, updateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { GitIntegrationService } from "../integration/gitIntegrationService.js";
 import { runTaskIntegrationQueueCommand } from "./taskIntegrationQueueCommands.js";
-import { taskActor } from "./taskActor.js";
+import { taskLocalActor } from "./taskActor.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 import { runDeliveryGuardPreflight, withGuardWarnings } from "./deliveryGuardPreflight.js";
 export async function runTaskIntegrationCommand(args, store, home, options = {}) {
@@ -18,12 +18,13 @@ export async function runTaskIntegrationCommand(args, store, home, options = {})
         return continueIntegration(rest, store, home, now, options);
     }
     if (command === "resolve") {
-        return resolveDecision(rest, store, now, options.environment);
+        return resolveDecision(rest, store, now, options.environment, home);
     }
     if (command === "abort")
-        return abortIntegration(rest, store, now(), options);
-    if (command === "supersede")
-        return supersedeIntegrationCommand(rest, store, now(), options.environment);
+        return abortIntegration(rest, store, now(), options, home);
+    if (command === "supersede") {
+        return supersedeIntegrationCommand(rest, store, now(), options.environment, home);
+    }
     if (command === "cleanup") {
         return cleanupIntegration(rest, store, home, options.environment);
     }
@@ -43,6 +44,7 @@ async function cleanupIntegration(args, store, home, environment) {
         throw usageError("Task Integration cleanup usage: yui task integration cleanup <task>/<integration>.");
     }
     const integration = requireIntegration(store, args[0], environment);
+    taskLocalActor(store, environment, integration.taskId, home);
     if (integration.status !== "committed"
         && integration.status !== "superseded"
         && integration.status !== "failed") {
@@ -83,6 +85,7 @@ async function start(args, store, home, now, options) {
     if (task.status !== "active") {
         throw usageError(`Task is not active: ${task.id}/${task.status}.`);
     }
+    taskLocalActor(store, options.environment, task.id, home);
     const changeSetIds = parsed.many.get("--change-set") ?? [];
     if (changeSetIds.length === 0)
         throw usageError("--change-set is required.", usage);
@@ -135,6 +138,7 @@ async function start(args, store, home, now, options) {
     // record creation are atomic, so a concurrent Leader cannot sneak a
     // duplicate Integration between the guard and the write.
     const integration = store.transaction((tx) => {
+        taskLocalActor(tx, options.environment, task.id, home);
         const guard = runDeliveryGuardPreflight(tx, task.id, {
             kind: "integration-start",
             projectId: project.id,
@@ -165,6 +169,7 @@ async function continueIntegration(args, store, home, now, options) {
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
+    taskLocalActor(store, options.environment, integration.taskId, home);
     if (integration.status !== "validating"
         && integration.status !== "running"
         && (integration.status !== "blocked"
@@ -184,25 +189,28 @@ async function runIntegration(store, home, integration, now, options) {
                 : `Integration ${result.attempt.id} failed; target ref was not advanced\n`;
     return { output, data: result };
 }
-function resolveDecision(args, store, now, environment) {
+function resolveDecision(args, store, now, environment, home) {
     const usage = "Task Integration resolve usage: yui task integration resolve <task>/<integration> --option <manual-resolution|reject> --rationale <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--option", "--rationale"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
-    const integration = requireIntegration(store, parsed.positionals[0], environment);
-    const task = requireActiveIntegrationTask(store, integration);
-    if (taskActor(environment, task.id) !== "leader") {
-        throw usageError("Only the Task Leader can resolve an Integration conflict.");
-    }
     const selectedOption = parsed.one.get("--option");
     const rationale = parsed.one.get("--rationale");
     if (selectedOption === undefined || rationale === undefined)
         throw usageError(usage);
-    const resolved = recordResolutionDecision(integration, {
-        action: selectedOption,
-        rationale
-    }, now());
-    store.saveIntegrationAttempt(resolved.taskId, resolved);
+    const resolved = store.transaction((tx) => {
+        const integration = requireIntegration(tx, parsed.positionals[0], environment);
+        const task = requireActiveIntegrationTask(tx, integration);
+        if (taskLocalActor(tx, environment, task.id, home) !== "leader") {
+            throw usageError("Only the Task Leader can resolve an Integration conflict.");
+        }
+        const updated = recordResolutionDecision(integration, {
+            action: selectedOption,
+            rationale
+        }, now());
+        tx.saveIntegrationAttempt(updated.taskId, updated);
+        return updated;
+    });
     return {
         output: selectedOption === "manual-resolution"
             ? `Leader selected manual resolution for ${resolved.id}; resolve its candidate worktree, then run integration continue\n`
@@ -210,13 +218,14 @@ function resolveDecision(args, store, now, environment) {
         data: { integration: resolved }
     };
 }
-async function abortIntegration(args, store, now, options) {
+async function abortIntegration(args, store, now, options, home) {
     const usage = "Task Integration abort usage: yui task integration abort <task>/<integration> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const integration = requireIntegration(store, parsed.positionals[0], options.environment);
     requireActiveIntegrationTask(store, integration);
+    taskLocalActor(store, options.environment, integration.taskId, home);
     if (integration.status !== "running" && integration.status !== "blocked") {
         throw usageError(`Integration cannot be aborted from ${integration.status}: ${integration.id}.`);
     }
@@ -238,6 +247,7 @@ async function abortIntegration(args, store, now, options) {
         if (current.status !== "running" && current.status !== "blocked") {
             throw usageError(`Integration cannot be aborted from ${current.status}: ${current.id}.`);
         }
+        taskLocalActor(tx, options.environment, current.taskId, home);
         const aborted = updateIntegrationAttempt(current, {
             status: "failed",
             checks: [
@@ -252,7 +262,7 @@ async function abortIntegration(args, store, now, options) {
         };
     });
 }
-function supersedeIntegrationCommand(args, store, now, environment) {
+function supersedeIntegrationCommand(args, store, now, environment, home) {
     const usage = "Task Integration supersede usage: yui task integration supersede <task>/<integration> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
@@ -267,7 +277,7 @@ function supersedeIntegrationCommand(args, store, now, environment) {
         throw usageError(usage);
     // Only the Task Leader (or Operator/user) may supersede a committed
     // Integration: it rewrites delivery-baseline evidence and audit history.
-    taskActor(environment, integration.taskId);
+    taskLocalActor(store, environment, integration.taskId, home);
     // A queue-backed committed Attempt cannot be superseded: the queue entry
     // would remain in its current status while its Attempt becomes "superseded",
     // leaving contradictory terminal records that never converge. This covers
@@ -287,6 +297,7 @@ function supersedeIntegrationCommand(args, store, now, environment) {
         if (current.status !== "committed") {
             throw usageError(`Integration cannot be superseded from ${current.status}: ${current.id}.`);
         }
+        taskLocalActor(tx, environment, current.taskId, home);
         const superseded = supersedeIntegration(current, reason, now);
         tx.saveIntegrationAttempt(superseded.taskId, superseded);
         return {

package/dist/commands/taskIntegrationQueueCommands.js

@@ -3,7 +3,7 @@ import { defaultTableWidth, renderTable } from "../output/table.js";
 import { resolveProject } from "../repository/project.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { enqueueIntegrationQueueEntry, processIntegrationQueue, reconcileIntegrationQueueEntry, requeueIntegrationQueueEntry, supersedeIntegrationQueueEntry } from "../integration/integrationQueueService.js";
-import { taskActor } from "./taskActor.js";
+import { taskLocalActor } from "./taskActor.js";
 import { parseRepeatable } from "./taskIntegrationCommands.js";
 import { resolveTaskRecordReference } from "../task/taskRecordReference.js";
 /**
@@ -22,11 +22,11 @@ export async function runTaskIntegrationQueueCommand(args, store, home, options
     if (command === "process")
         return process(rest, store, home, options);
     if (command === "supersede")
-        return supersede(rest, store, options);
+        return supersede(rest, store, options, home);
     if (command === "requeue")
-        return requeue(rest, store, options);
+        return requeue(rest, store, options, home);
     if (command === "reconcile")
-        return reconcile(rest, store, options);
+        return reconcile(rest, store, options, home);
     throw usageError(command === undefined
         ? "Task Integration queue command is required."
         : `Unknown command: task integration queue ${command}`);
@@ -37,7 +37,7 @@ async function enqueue(args, store, options, home) {
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const task = requireActiveTask(store, parsed.positionals[0]);
-    requireLeader(options.environment, task.id);
+    requireLeader(store, options.environment, task.id, home);
     const projectRef = parsed.one.get("--project");
     const changeSetId = parsed.one.get("--change-set");
     if (projectRef === undefined || changeSetId === undefined)
@@ -120,7 +120,7 @@ async function process(args, store, home, options) {
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const task = requireActiveTask(store, parsed.positionals[0]);
-    requireLeader(options.environment, task.id);
+    requireLeader(store, options.environment, task.id, home);
     const limitValue = parsed.one.get("--limit");
     const limit = limitValue === undefined ? undefined : Number.parseInt(limitValue, 10);
     if (limitValue !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
@@ -148,13 +148,13 @@ async function process(args, store, home, options) {
         : `${lines.join("\n")}\n`;
     return { output, data: { processed } };
 }
-function supersede(args, store, options) {
+function supersede(args, store, options, home) {
     const usage = "Task Integration queue supersede usage: yui task integration queue supersede <task>/<entry> --reason <text>.";
     const parsed = parseRepeatable(args, new Set(), new Set(["--reason"]), usage);
     if (parsed.positionals.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, parsed.positionals[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
+    requireLeader(store, options.environment, entry.taskId, home);
     const reason = parsed.one.get("--reason");
     if (reason === undefined)
         throw usageError(usage);
@@ -164,24 +164,24 @@ function supersede(args, store, options) {
         data: { entry: superseded }
     };
 }
-function requeue(args, store, options) {
+function requeue(args, store, options, home) {
     const usage = "Task Integration queue requeue usage: yui task integration queue requeue <task>/<entry>.";
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
+    requireLeader(store, options.environment, entry.taskId, home);
     const waiting = requeueIntegrationQueueEntry(store, entry.taskId, entry.id, options.now ?? (() => new Date()));
     return {
         output: `Requeued ${waiting.id}; it will be processed again on the next queue run\n`,
         data: { entry: waiting }
     };
 }
-async function reconcile(args, store, options) {
+async function reconcile(args, store, options, home) {
     const usage = "Task Integration queue reconcile usage: yui task integration queue reconcile <task>/<entry>.";
     if (args.length !== 1)
         throw usageError(usage);
     const entry = requireQueueEntry(store, args[0], options.environment);
-    requireLeader(options.environment, entry.taskId);
+    requireLeader(store, options.environment, entry.taskId, home);
     const committed = await reconcileIntegrationQueueEntry(store, entry.taskId, entry.id, new NodeGitWorkspace(), options.now ?? (() => new Date()));
     return {
         output: `Reconciled ${committed.id} as committed -> ${committed.targetAfter ?? "-"}\n`,
@@ -221,8 +221,8 @@ function requireQueueEntry(store, value, environment) {
     }
     return entry;
 }
-function requireLeader(environment, taskId) {
-    if (taskActor(environment, taskId) !== "leader") {
+function requireLeader(store, environment, taskId, home) {
+    if (taskLocalActor(store, environment, taskId, home) !== "leader") {
         throw usageError("Only the Task Leader can change the integration queue.");
     }
 }

package/dist/context/runContextPack.js

@@ -1,3 +1,4 @@
+import { rejectedYieldAttemptFromTaskEvent, RUN_YIELD_REJECTED_EVENT } from "../run/rejectedYieldAttempt.js";
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { RUN_BOOTSTRAP_MAX_DELTAS } from "./runContextContract.js";
@@ -426,6 +427,20 @@ function collectAuthorizedContext(store, run) {
         for (const event of publishedTreeAuthorizations.reverse().slice(-16)) {
             result.push(materialize("L4", "task-event", event.id, event));
         }
+        for (const event of events.filter(({ type }) => (type === RUN_YIELD_REJECTED_EVENT)).slice(-16)) {
+            result.push(materialize("L4", "task-event", event.id, event));
+            const attempt = rejectedYieldAttemptFromTaskEvent(event);
+            if (attempt === null)
+                continue;
+            const rejectedRun = store.getAgentRun(task.id, attempt.runId);
+            if (rejectedRun !== null) {
+                result.push(materialize("L4", "agent-run", rejectedRun.id, rejectedRun));
+            }
+            const rejectedRound = store.getReviewRound(task.id, attempt.reviewRoundId);
+            if (rejectedRound !== null) {
+                result.push(materialize("L3", "review-round", rejectedRound.id, rejectedRound));
+            }
+        }
         for (const request of store.listOpenInputRequests([task.id])) {
             result.push(materialize("L4", "input-request", request.id, request));
         }

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -1714,8 +1714,24 @@ export class FileSchedulerStoreAdapter {
                     }
                 }
             }
-            store.saveRole(task.id, updateRoleStatus(role, "exited", input.now));
+            const blocksAutomaticLeaderRecovery = role.name === "leader"
+                && input.leaderRecovery === "blocked";
+            store.saveRole(task.id, updateRoleStatus(role, blocksAutomaticLeaderRecovery ? "failed" : "exited", input.now));
             stopTaskSessionIfPresent(store, task.id, role.name, currentRun.effective.agentId, input.now);
+            if (blocksAutomaticLeaderRecovery) {
+                const failure = recordLeaderFailure(task.id, input.session?.nativeSessionId ?? "(unregistered)", input.summary, input.now, store.getLeaderFailure(task.id));
+                store.saveLeaderFailure(failure);
+                recordLeaderAttentionRequired(store, {
+                    taskId: task.id,
+                    reason: "leader-recovery-failed",
+                    payload: {
+                        message: failure.message,
+                        runId: currentRun.id
+                    },
+                    now: input.now
+                });
+                return "failed";
+            }
             queueLeaderWakeup(store, task.id, wakeReason(role.name === "leader" ? "leader-run-failed" : "role-run-failed"), input.now);
             return "failed";
         });

package/dist/executor/workspacePreflightClassification.js

@@ -1,5 +1,4 @@
-import { isDeepStrictEqual } from "node:util";
-import { isTaskOwnedWorkspace } from "../worktree/managedWorkspace.js";
+import { isTaskOwnedWorkspace, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 function ownerLabel(owner) {
     switch (owner.type) {
         case "task":
@@ -43,11 +42,13 @@ export function classifyWorkspacePreflight(store, task, roleName, activeRun, ins
         };
     }
     // 2. Run snapshot validation: when the active Run carries a workspace
-    //    snapshot it must match the durable ManagedWorkspace exactly.  A
-    //    mismatch means the Run was created against a stale baseline.
+    //    snapshot its launch-stable identity must match the durable
+    //    ManagedWorkspace. Audit timestamps may change without changing the
+    //    owner, root, or Project entries authorized for the Run.
     if (activeRun?.workspace !== undefined) {
         const durableRunWorkspace = store.getManagedWorkspace(activeRun.workspace.owner);
-        if (durableRunWorkspace === null || !isDeepStrictEqual(durableRunWorkspace, activeRun.workspace)) {
+        if (durableRunWorkspace === null
+            || !sameManagedWorkspaceIdentity(durableRunWorkspace, activeRun.workspace)) {
             const diff = [];
             if (durableRunWorkspace === null) {
                 diff.push(`durable ManagedWorkspace for owner ${JSON.stringify(activeRun.workspace.owner)} is missing`);

package/dist/lifecycle/exactRunTerminalization.js

@@ -9,7 +9,7 @@ import { finishReviewRound, updateReviewExecutionGroup } from "../review/reviewR
 import { reconcileReviewFindingsAfterReview } from "../review/reviewFindingLedger.js";
 import { agentRunDeliveryReceiptId, failAgentRun, withYieldReceipt, yieldAgentRun } from "../run/agentRun.js";
 import { createYieldReceipt } from "../run/yieldReceipt.js";
-import { recordExecutionLaneResult } from "../execution/executionGroup.js";
+import { recordExecutionLaneResult, resolveExecutionGroup } from "../execution/executionGroup.js";
 import { isRuntimeLaunchReservation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
 import { runOwnsBlockingProviderContinuation } from "../runtime/runtimeContinuationProjection.js";
 import { runHasActiveRuntimeOperations } from "../runtime/runtimeObservation.js";
@@ -145,7 +145,7 @@ export function terminalizeExactRunReviewRound(store, input, now) {
         return validation;
     }
     const reviewRound = validation.round;
-    const groupedRound = input.run.executionGroupId !== undefined
+    let groupedRound = input.run.executionGroupId !== undefined
         && input.run.executionLaneId !== undefined
         && reviewRound.executionGroup !== undefined
         ? updateReviewExecutionGroup(reviewRound, recordExecutionLaneResult(reviewRound.executionGroup, input.run.executionLaneId, {
@@ -174,10 +174,25 @@ export function terminalizeExactRunReviewRound(store, input, now) {
                 : { gitSnapshot: input.reviewResult.gitSnapshot })
         }, input.outcome.status === "yielded" ? "completed" : "failed", now))
         : reviewRound;
+    if (input.settleFailedExecutionGroup === true
+        && input.outcome.status === "failed"
+        && groupedRound.executionGroup !== undefined
+        && groupedRound.executionGroup.resolution === undefined
+        && groupedRound.executionGroup.lanes.every((lane) => (lane.status === "yielded"
+            || lane.status === "completed"
+            || lane.status === "failed"
+            || lane.status === "skipped"))) {
+        groupedRound = updateReviewExecutionGroup(groupedRound, resolveExecutionGroup(groupedRound.executionGroup, {
+            decision: "blocked",
+            summary: input.outcome.summary
+        }, now));
+    }
     const groupedMultiLane = groupedRound.executionGroup !== undefined
         && (groupedRound.executionGroup.lanes.length > 1
             || groupedRound.executionGroup.strategy.mode === "adaptive");
-    if (groupedMultiLane && groupedRound.executionGroup !== undefined) {
+    if (groupedMultiLane
+        && groupedRound.executionGroup !== undefined
+        && groupedRound.executionGroup.resolution === undefined) {
         // A panel Lane only contributes evidence.  The Leader must see every
         // terminal Lane and explicitly resolve the Group before this ReviewRound
         // can become terminal.
@@ -193,6 +208,108 @@ export function terminalizeExactRunReviewRound(store, input, now) {
     }
     return { disposition: "applied", round: terminal };
 }
+/**
+ * Retire one stranded active Run only after its exact Provider Turn is
+ * terminal and every durable execution fence is quiet. The caller owns the
+ * surrounding aggregate transaction so the Run, ReviewRound/Lane, mailbox,
+ * Session, and append-only retirement record commit together.
+ */
+export function retireExactActiveAgentRun(store, input, now) {
+    const current = store.getAgentRun(input.taskId, input.runId);
+    const stateChanged = (reason) => ({
+        disposition: "state-changed",
+        run: current,
+        ...(current === null ? {} : { progressAt: latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId)?.progressAt }),
+        reason
+    });
+    const task = store.getTask(input.taskId);
+    if (task === null)
+        return stateChanged("task-missing");
+    if (task.status !== "active")
+        return stateChanged("task-terminal");
+    if (current === null)
+        return stateChanged("run-missing");
+    if (current.status !== "active")
+        return stateChanged("run-terminal");
+    if (current.taskId !== input.taskId || current.roleName !== input.roleName) {
+        return stateChanged("run-owner-mismatch");
+    }
+    if (current.effective.agentId !== input.agentId
+        || current.effective.adapterId !== input.adapterId) {
+        return stateChanged("run-launch-identity-mismatch");
+    }
+    const active = current.executionGroupId !== undefined && current.executionLaneId !== undefined
+        ? store.getActiveExecutionLaneRun(input.taskId, current.executionGroupId, current.executionLaneId)
+        : store.getActiveAgentRun(input.taskId, input.roleName);
+    if (active?.id !== current.id)
+        return stateChanged("active-run-mismatch");
+    const progress = latestRunDurableProgressAt(store, input.taskId, input.roleName, input.runId);
+    if (progress === null)
+        return stateChanged("progress-unavailable");
+    if (progress.progressAt !== input.expectedProgressAt) {
+        return { ...stateChanged("progress-fence-mismatch"), progressAt: progress.progressAt };
+    }
+    if (!matchesRecoverySessionFence(store, {
+        ...input,
+        action: "terminate",
+        providerAcceptance: current.deliveredAt === undefined ? "rejected" : "accepted",
+        now
+    }))
+        return stateChanged("session-or-launch-fence-mismatch");
+    const blocker = exactRecoveryExecutionBlocker(store, current);
+    if (blocker !== null) {
+        return {
+            disposition: "blocked",
+            run: current,
+            progressAt: progress.progressAt,
+            reason: blocker
+        };
+    }
+    const sessions = store.getTaskRoleSessionSet(input.taskId, input.roleName);
+    const session = sessions?.sessions[input.agentId];
+    const providerBinding = sessions?.providerBinding;
+    const providerTurn = providerBinding?.turn;
+    const providerSettled = providerBinding?.runId === current.id
+        && (providerTurn?.status === "completed"
+            || providerTurn?.status === "failed"
+            || providerTurn?.status === "cancelled"
+            || providerTurn?.status === "rejected");
+    if (session?.status !== "stopped" && session?.status !== "broken" && !providerSettled) {
+        return {
+            disposition: "blocked",
+            run: current,
+            progressAt: progress.progressAt,
+            reason: "runtime-not-terminal"
+        };
+    }
+    const terminal = terminalizeExactTaskRun(store, {
+        taskId: input.taskId,
+        roleName: input.roleName,
+        agentId: input.agentId,
+        runId: input.runId,
+        receiptId: agentRunDeliveryReceiptId(current),
+        ...(input.nativeSessionId === undefined ? {} : { nativeSessionId: input.nativeSessionId }),
+        ...(input.launchId === undefined ? {} : { launchId: input.launchId }),
+        settleFailedExecutionGroup: true,
+        outcome: { status: "failed", summary: input.reason }
+    }, now);
+    if (terminal.disposition !== "applied" || terminal.run === null) {
+        return stateChanged(terminal.reason ?? "terminalization-fence-mismatch");
+    }
+    if (terminal.run.purpose === "execution" && terminal.run.workItemId !== undefined) {
+        const item = store.getWorkItem(input.taskId, terminal.run.workItemId);
+        if (item !== null
+            && !["completed", "failed", "retired"].includes(item.status)
+            && !workItemOwnsUnresolvedExecutionLane(item, terminal.run.executionGroupId, terminal.run.executionLaneId)) {
+            store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", now, input.reason));
+        }
+    }
+    return {
+        disposition: "applied",
+        run: terminal.run,
+        progressAt: progress.progressAt
+    };
+}
 /**
  * Applies one exact application-level terminal fact inside the caller's
  * FileTaskStore transaction. All caller-owned outcome records can therefore
@@ -279,7 +396,10 @@ export function terminalizeExactTaskRun(store, input, now) {
         taskId: input.taskId,
         run,
         outcome: input.outcome,
-        reviewResult: input.reviewResult
+        reviewResult: input.reviewResult,
+        ...(input.settleFailedExecutionGroup === undefined
+            ? {}
+            : { settleFailedExecutionGroup: input.settleFailedExecutionGroup })
     }, now);
     if (reviewRoundTerminalization.disposition !== "applied") {
         return obsolete(run, reviewRoundTerminalization.reason ?? "review-round-mismatch");
@@ -313,7 +433,7 @@ export function terminalizeExactTaskRun(store, input, now) {
             ? undefined
             : workItemExecutionGroupById(item, run.executionGroupId);
         if (item !== null && group !== undefined) {
-            const grouped = recordExecutionLaneResult(group, run.executionLaneId, {
+            let grouped = recordExecutionLaneResult(group, run.executionLaneId, {
                 summary: input.outcome.summary,
                 ...(input.reviewResult?.report === undefined ? {} : { report: input.reviewResult.report }),
                 ...(input.reviewResult?.checks === undefined ? {} : { checks: input.reviewResult.checks }),
@@ -322,6 +442,18 @@ export function terminalizeExactTaskRun(store, input, now) {
                 ...(input.reviewResult?.evidenceCommit === undefined ? {} : { evidenceCommit: input.reviewResult.evidenceCommit }),
                 ...(input.reviewResult?.gitSnapshot === undefined ? {} : { gitSnapshot: input.reviewResult.gitSnapshot })
             }, input.outcome.status === "yielded" ? "completed" : "failed", now);
+            if (input.settleFailedExecutionGroup === true
+                && input.outcome.status === "failed"
+                && grouped.resolution === undefined
+                && grouped.lanes.every((lane) => (lane.status === "yielded"
+                    || lane.status === "completed"
+                    || lane.status === "failed"
+                    || lane.status === "skipped"))) {
+                grouped = resolveExecutionGroup(grouped, {
+                    decision: "blocked",
+                    summary: input.outcome.summary
+                }, now);
+            }
             store.saveWorkItem(input.taskId, updateWorkItemExecutionGroup(item, grouped, now));
         }
     }
@@ -643,6 +775,12 @@ function matchesSessionFence(sessions, input) {
         && inFlight.receiptId === input.receiptId);
 }
 function matchesLaunchFence(store, sessions, input) {
+    // A resumed Run shares the native Provider Session whose process environment
+    // was created for an earlier Run. Once that exact native Session has passed
+    // matchesSessionFence, its immutable per-launch environment is not a second
+    // Run identity. Opaque hosts still require the launch fence below.
+    if (input.nativeSessionId !== undefined)
+        return true;
     if (input.launchId === undefined)
         return true;
     const session = sessions?.sessions[input.agentId];
@@ -664,7 +802,9 @@ function settleLaunchReservation(store, sessions, input) {
     const mailbox = store.getWorkMailbox(target);
     const reservation = mailbox?.processing;
     const session = sessions?.sessions[input.agentId];
-    const launchId = input.launchId ?? session?.launchId;
+    const launchId = input.nativeSessionId === undefined
+        ? input.launchId ?? session?.launchId
+        : session?.launchId;
     if (launchId === undefined || !isRuntimeLaunchReservation(reservation, launchId))
         return;
     const settled = completeProcessing(mailbox, reservation.batchId);