@zq-silk/yui 2.6.0 → 2.7.1

package/dist/doctor/doctor.js

@@ -1,6 +1,6 @@
 import { accessSync, constants, existsSync, lstatSync, realpathSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
-import Database from "better-sqlite3";
+import Database, { selectSqliteDriver } from "../sqlite/driver.js";
 import { inspectPty } from "./ptyProbe.js";
 import { gitVersionSupport } from "../repository/gitCompatibility.js";
 import { resolveExecutable } from "../external/pinnedCommandRunner.js";
@@ -31,6 +31,7 @@ import { CommandExecutionError } from "../tmux/commandExecutor.js";
  * and never block an update.
  */
 export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
+    "sqlite driver",
     "storage schema",
     "storage compatibility",
     "storage state"
@@ -38,7 +39,7 @@ export const STORAGE_DOCTOR_CHECK_NAMES = Object.freeze([
 /**
  * Classify the storage checks into a machine-readable health verdict. This is the
  * canonical, parseable signal the update post-verify consumes (P1-3): storage is
- * healthy only when schema, compatibility, and state are all `ok`. Any
+ * healthy only when driver, schema, compatibility, and state are all `ok`. Any
  * `unsupported` (version mismatch / needs-new-version), `invalid` (corrupted /
  * unreadable), or `missing` (uninitialized) storage check is blocking — even
  * and the machine-readable command exits non-zero.
@@ -119,6 +120,7 @@ export async function getDoctorChecks(env, executor) {
 async function inspectDoctor(env, executor) {
     const home = resolveYuiHome(env);
     const homeCheck = checkHome(home);
+    const driverCheck = checkSqliteDriver();
     const schema = readSchema(home);
     const compatibility = inspectCompatibility(home, homeCheck, schema);
     const schemaCheck = checkSchema(schema);
@@ -135,6 +137,7 @@ async function inspectDoctor(env, executor) {
     return {
         checks: [
             homeCheck,
+            driverCheck,
             schemaCheck,
             compatibility.check,
             storage.check,
@@ -148,6 +151,26 @@ async function inspectDoctor(env, executor) {
         review: review.report
     };
 }
+export function checkSqliteDriver() {
+    try {
+        const selected = selectSqliteDriver();
+        return {
+            name: "sqlite driver",
+            status: "ok",
+            detail: `${selected.name}@${selected.version}; SQLite ${selected.sqliteVersion}; `
+                + (selected.fallbackReason === undefined
+                    ? "no fallback"
+                    : `fallback: ${selected.fallbackReason}`)
+                + ". Isolated native connection probe; does not validate Home data."
+        };
+    }
+    catch (error) {
+        return {
+            name: "sqlite driver", status: "invalid",
+            detail: `Native driver probe failed (not a Home diagnosis): ${error instanceof Error ? error.message : String(error)}`
+        };
+    }
+}
 /** Query the authenticated Controller endpoint without starting it. */
 export async function checkController(home, probe = callController) {
     try {

package/dist/executor/effectiveLaunch.js

@@ -2,7 +2,7 @@ import { isDeepStrictEqual } from "node:util";
 import { validateExecutionEnvironmentSnapshot } from "../resources/projectResource.js";
 import { validateManagedWorkspace } from "../worktree/managedWorkspace.js";
 import { resolveAgentAdapter } from "./agentAdapter.js";
-import { compileRoleSessionContext, roleSessionKind } from "../context/roleSessionContext.js";
+import { loadYuiSkillContexts, roleSessionKind, roleSkillIds } from "../context/roleSessionContext.js";
 import { validateSkillPackageRef } from "../context/skillPackage.js";
 import { isAgentAdapterId } from "../agent/adapterCatalog.js";
 import { adapterIdForExecutionComponent, isAgentExecutionComponentId, resolveAgentExecutionComponent } from "../agent/executionComponents.js";
@@ -24,7 +24,7 @@ export function resolveEffectiveLaunch(input) {
     const continuing = existing?.status === "active";
     const skillPackages = continuing ? existing.effective.skillPackages
         : home === undefined ? undefined
-            : compileRoleSessionContext(home, input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, { purpose: input.purpose }).skills.map(skill => skill.package);
+            : loadYuiSkillContexts(home, roleSkillIds(input.role, roleSessionKind(input.role, "taskId" in input.role ? { scope: "task", taskId: input.role.taskId } : { scope: "global" }, input.purpose))).map(skill => skill.package);
     return snapshotFromConfig({
         executionAuthority: input.executionAuthority ?? (input.purpose === "planning" ? "planning" : "delivery"),
         sourceDesiredRevision: input.role.launchRevision,

package/dist/executor/fileRoleLaunchPlanner.js

@@ -337,12 +337,10 @@ export class FileRoleLaunchPlanner {
         Object.assign(launchEnvironment, runtimeIsolation === undefined
             ? {}
             : taskRuntimeIsolationEnvironment(runtimeIsolation));
-        const skillPackages = input.mode === "resume"
-            ? existingSession?.effective.skillPackages : effective.skillPackages;
-        if (skillPackages === undefined) {
-            throw new Error("This launch has no frozen Skill package evidence (pre-1.5 or externally recorded Session). Create a new Session from current Role configuration; historical Skill versions cannot be reconstructed.");
-        }
-        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, { ...sessionPolicy, skillPackages });
+        // Frozen packages describe historical materialization, not Session identity
+        // or current instruction availability. Never require or reconstruct them
+        // when reconnecting a valid old Session.
+        const baseSessionContext = compileRoleSessionContext(this.home, launchRole, owner, sessionPolicy);
         const bootstrap = materializeSessionBootstrap({
             yuiHome: this.home,
             role: launchRole,

package/dist/interaction/notificationPresentation.js

@@ -69,7 +69,7 @@ export function taskNotificationPresentation(wake, store) {
         ...(messages.length > 4 ? [`${messages.length - 4} more messages in the fixed wake.`] : []),
         `Refresh: yui task context ${wake.taskId} --json`,
         `Read inputs/results: yui task wake show ${wake.taskId} ${wake.id} --json`,
-        "Apply yui-leader (from the current Manifest); read relevant originals in full and advance authorized work."
+        "Check current Skills each turn: yui session skills --json. Apply current yui-leader; read relevant originals in full and advance authorized work."
     ].join("\n");
 }
 export function globalMessagePresentation(roleName, messageId, message) {
@@ -80,6 +80,6 @@ export function globalMessagePresentation(roleName, messageId, message) {
         ...(summary === undefined ? [] : [`Author summary (message-body): ${JSON.stringify(summary)}`]),
         "Refresh Session Context using the current Manifest's loadCommand.",
         `Read original: yui role message show ${roleName} ${messageId} --json`,
-        `Apply ${roleName === "operator" ? "yui-operator" : "yui-runtime"} from the current Manifest within existing authority.`
+        `The Global loadCommand checks current Skill versions each turn. Apply current ${roleName === "operator" ? "yui-operator" : "yui-runtime"} within existing authority.`
     ].join("\n");
 }

package/dist/interaction/operatorPresentation.js

@@ -10,7 +10,7 @@ export function createOperatorBatchPresentation(batchId, items) {
         receiptId: `operator-batch:${batchId}`,
         text: [
             "[Yui updates]",
-            "Apply yui-operator from the current Manifest: inspect these originals and present material changes or decisions.",
+            "Check current Skills each turn via the Global Manifest's loadCommand. Apply current yui-operator; inspect these originals and present material changes or decisions.",
             ...items.flatMap(renderItem)
         ].join("\n")
     };

package/dist/message/globalInputBacklog.js

@@ -0,0 +1,69 @@
+import { providerRetryPending } from "../runtime/providerRetry.js";
+import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
+/** Bounded, derived diagnostics only; never an acknowledgement or recovery authority. */
+export function globalInputBacklog(pending, sessions, now = new Date(), mailboxes = {}) {
+    const first = pending[0];
+    const run = sessions?.providerBinding?.run;
+    const session = sessions?.sessions[sessions.activeAgentId];
+    const authority = sessions?.providerBinding?.authority;
+    const batches = [mailboxes.attention?.pending, mailboxes.attention?.processing?.batch]
+        .filter(batch => batch != null);
+    const coalescedFactCount = batches.reduce((count, batch) => count + batch.requestCount, 0);
+    let reason = "ready";
+    let recovery = "The Controller delivers at the next legal opportunity; do not duplicate the input.";
+    if (first === undefined && coalescedFactCount === 0)
+        reason = "empty";
+    else if (hasRuntimeCleanupObligation(mailboxes.lifecycle ?? null)) {
+        reason = "lifecycle-cleanup";
+        recovery = "Complete the existing exact-owner stop/replacement; queued input cannot revive the Session.";
+    }
+    else if (session?.status !== "active") {
+        reason = session === undefined ? "session-unavailable" : "session-stopped";
+        recovery = "Inspect Session lifecycle. Explicit stop/replacement is not undone by background delivery.";
+    }
+    else if (authority?.owner !== "controller") {
+        reason = "external-or-unknown-writer";
+        recovery = "Resolve the current writer/authority explicitly; no background takeover is allowed.";
+    }
+    else if (providerRetryPending(sessions?.providerBinding)) {
+        reason = "provider-retry";
+        recovery = "The existing bounded Provider retry owns this input; inspect session retry before intervening.";
+    }
+    else if (run && ["submitting", "accepted", "delivery-unknown"].includes(run.status)) {
+        reason = run.status === "accepted" ? "in-flight-or-unobserved-terminal" : run.status;
+        recovery = "Age does not prove a stalled Turn. Periodic reconciliation asks only the original Host for exact retained terminal evidence. Inspect recent runtime-attention Messages if the Host is unobservable; never resend unknown input.";
+    }
+    else if (first?.inbox) {
+        reason = "agent-inbox-handling";
+        recovery = "Read the exact inbox original and prior handling claim; explicitly acknowledge after processing. No automatic replay or timeout release.";
+    }
+    else if (first?.control && first.control.outcome !== "rejected") {
+        reason = "message-acceptance-unresolved";
+        recovery = "Inspect this original Message's exact control receipt; do not replay or bypass uncertain input.";
+    }
+    else if (first?.interruptThen) {
+        reason = "reserved-interrupt-then";
+        recovery = "Only the original Session, authority and exact terminal release the reserved continuation.";
+    }
+    else if (first?.deliveryTarget && (first.deliveryTarget.agentId !== sessions?.activeAgentId
+        || first.deliveryTarget.nativeSessionId !== session.nativeSessionId)) {
+        reason = "stale-target";
+        recovery = "Unsubmitted stale messages are retained with a nondelivery reason; no cross-Session input copy.";
+    }
+    const oldestCreatedAt = [...pending.map(message => message.createdAt), ...batches.map(batch => batch.firstQueuedAt)]
+        .reduce((oldest, at) => oldest === null || at < oldest ? at : oldest, null);
+    return {
+        pendingCount: pending.length, coalescedFactCount, oldestCreatedAt,
+        oldestAgeMs: oldestCreatedAt === null ? null : Math.max(0, now.getTime() - Date.parse(oldestCreatedAt)),
+        reason, recovery,
+        target: session === undefined ? null : {
+            agentId: session.agentId, nativeSessionId: session.nativeSessionId,
+            authority: authority ?? null, attemptId: run?.attemptId ?? null, nativeTurnId: run?.nativeTurnId ?? null
+        },
+        messages: pending.slice(0, 8).map(message => ({
+            id: message.id, createdAt: message.createdAt, deliveryTarget: message.deliveryTarget ?? null,
+            control: message.control ?? null, interruptThen: message.interruptThen ?? null
+        })),
+        omittedMessages: Math.max(0, pending.length - 8)
+    };
+}

package/dist/message/globalMessageQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/message/inboxReceipt.js

@@ -0,0 +1,32 @@
+import { requireKnownFields, requireText, requireTimestamp } from "../domain/validation.js";
+import { isDeepStrictEqual } from "node:util";
+export function validateInboxReceipt(receipt) {
+    if (receipt === undefined)
+        return;
+    requireKnownFields(receipt, ["claim", "ack"], "Inbox receipt");
+    for (const [kind, entry] of Object.entries(receipt)) {
+        requireKnownFields(entry, kind === "claim" ? ["requestId", "actor", "at"]
+            : ["requestId", "actor", "at", "reason"], "Inbox action");
+        requireText(entry.requestId, "Inbox request id");
+        requireTimestamp(entry.at, "Inbox timestamp");
+        const actor = entry.actor;
+        requireKnownFields(actor, ["scope", "taskId", "roleName", "agentId", "nativeSessionId", "runId"], "Inbox actor");
+        if (!["task", "global"].includes(actor.scope)
+            || (actor.scope === "task") !== (actor.taskId !== undefined))
+            throw new Error("Inbox actor scope is invalid.");
+        for (const value of Object.values(actor))
+            requireText(value, "Inbox actor identity");
+        if (kind === "ack")
+            requireText(entry.reason, "Inbox disposition");
+    }
+    if (!receipt.claim)
+        throw new Error("Inbox receipt requires its original claim.");
+}
+/** A stale automatic writer cannot erase an active claim between its read and
+ * Host admission. The original claim and any ack are immutable audit facts. */
+export function assertInboxReceiptPreserved(previous, next) {
+    if (previous !== undefined && (!isDeepStrictEqual(previous.claim, next?.claim)
+        || previous.ack !== undefined && !isDeepStrictEqual(previous.ack, next?.ack))) {
+        throw new Error("Inbox handling ownership changed; reread the original instead of overwriting its receipt.");
+    }
+}

package/dist/message/message.js

@@ -1,5 +1,6 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { requireKnownFields } from "../domain/validation.js";
+import { validateInboxReceipt } from "./inboxReceipt.js";
 export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
 /**
  * How a user/operator submission asks its Task to react (task-32 Requirement A).
@@ -207,8 +208,9 @@ export function validateTaskMessage(message) {
         throw new Error("Task Message must use schemaVersion 1.");
     requireKnownFields(message, [
         "schemaVersion", "id", "taskId", "kind", "author", "body", "intent", "submissionKey", "submissionReceipt",
-        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt"
+        "inputControl", "interruptThen", "control", "runId", "resultRef", "workItemId", "recipient", "continuation", "handovers", "createdAt", "inbox"
     ], "Task Message");
+    validateInboxReceipt(message.inbox);
     validateTaskRecordReference({ taskId: message.taskId, localId: message.id }, "message");
     requireText(message.body, "Message body");
     validateKindAndAuthor(message.kind, message.author);
@@ -394,6 +396,7 @@ export function createGlobalRoleMessage(id, roleName, body, kind, author, now, c
     return message;
 }
 export function validateGlobalRoleMessage(message) {
+    validateInboxReceipt(message.inbox);
     if (message.schemaVersion !== 1)
         throw new Error("Global Role Message must use schemaVersion 1.");
     validateGlobalRoleMessageId(message.id);
@@ -517,6 +520,8 @@ export function markGlobalRoleMessageDelivered(message, now, via = "provider") {
  * keeps resolving to this same Message and never creates a second input.
  */
 export function claimGlobalRoleMessageInterruptThen(message, claim) {
+    if (message.inbox !== undefined)
+        throw new Error("Agent inbox handling already owns this Message; it cannot be replayed through interrupt-then.");
     const { inputControl, notDelivered: _priorNondelivery, ...rest } = message;
     const claimed = {
         ...rest,

package/dist/message/messageContinuation.js

@@ -10,6 +10,7 @@ import { validateExactRunReviewRound } from "../lifecycle/exactRunTerminalizatio
 import { sourceRunContextValue } from "../context/sourceRunContext.js";
 import { requireManagedTaskCaller } from "../runtime/managedCaller.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { isTaskRecordRetired, operationalTaskRecords } from "../task/taskRecordRetirement.js";
 export function resolveMessageRecipient(store, taskId, roleName, scope) {
     if (scope.reviewRoundId !== undefined) {
         const round = store.getReviewRound(taskId, scope.reviewRoundId);
@@ -28,8 +29,11 @@ export function resolveMessageRecipient(store, taskId, roleName, scope) {
         throw new Error("No existing Dispatch owns this Role and work scope.");
     return { roleName, ownerRunId: previous.id, ...scope };
 }
-/** Bounded diagnosis, not automatic ownership repair. */
-export function messageContinuationBlocker(store, message) {
+/** Current Assignment authority, independent of eligibility to start a new Run.
+ * A Reviewer still owns its frozen clarification when Task main advances. */
+export function messageAssignmentBlocker(store, message) {
+    if (isTaskRecordRetired(store.listEvents(message.taskId), "message", message.id))
+        return "message-retired";
     const target = message.recipient;
     if (target?.ownerRunId === undefined)
         return "recipient-assignment-missing";
@@ -78,22 +82,29 @@ export function messageContinuationBlocker(store, message) {
         && latest.inputs[0]?.input.source.channel !== "message-continuation")
         return "assignment-changed";
     if (target.reviewRoundId !== undefined) {
-        const round = store.getReviewRound(message.taskId, target.reviewRoundId);
-        if (round === null)
-            return "review-round-missing";
+        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
+        if (validation.disposition !== "applied")
+            return validation.reason ?? "review-candidate-stale";
+    }
+    return undefined;
+}
+/** Starting another Run additionally requires the reviewed candidate to remain current. */
+export function messageContinuationBlocker(store, message) {
+    const invalid = messageAssignmentBlocker(store, message);
+    if (invalid !== undefined)
+        return invalid;
+    const reviewRoundId = message.recipient?.reviewRoundId;
+    if (reviewRoundId !== undefined) {
+        const round = store.getReviewRound(message.taskId, reviewRoundId);
         if (round.scope === "task") {
+            const task = store.getTask(message.taskId);
             if (round.taskCandidate?.projects.some((project) => task.projectBindings.find((binding) => binding.projectId === project.projectId)?.currentCommit !== project.commit)) {
                 return "review-candidate-stale";
             }
         }
-        else {
-            const item = store.getWorkItem(message.taskId, round.workItemId);
-            if (item?.candidates.at(-1)?.id !== round.candidateId)
-                return "review-candidate-stale";
+        else if (store.getWorkItem(message.taskId, round.workItemId)?.candidates.at(-1)?.id !== round.candidateId) {
+            return "review-candidate-stale";
         }
-        const validation = validateExactRunReviewRound(store, latest ?? owner, { allowTerminal: true });
-        if (validation.disposition !== "applied")
-            return validation.reason ?? "review-candidate-stale";
     }
     return undefined;
 }
@@ -189,7 +200,11 @@ export function interruptThenTerminalState(store, message) {
  * remain the pending authority; Mailbox is only the existing scheduling hint.
  * Reserving inputs and creating the next Run is one atomic effect. */
 export function prepareMessageContinuations(store, taskId, now, roleName) {
-    const pending = store.listMessages(taskId).filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+    const messages = operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message");
+    const claims = messages.filter(message => message.recipient?.roleName === roleName
+        && message.inbox !== undefined && message.inbox.ack === undefined);
+    const pending = messages.filter((message) => message.recipient?.roleName === roleName && message.recipient.ownerRunId !== undefined
+        && message.inbox === undefined
         && message.continuation?.runId === undefined
         // A steer targets the exact current native turn, never a queued next Run.
         // If its live attempt did not submit, the message stays saved for the
@@ -197,6 +212,12 @@ export function prepareMessageContinuations(store, taskId, now, roleName) {
         && message.inputControl?.action !== "steer");
     for (const message of pending) {
         const recipient = message.recipient;
+        // Retain ordering within the claimed Assignment, not across unrelated
+        // work owned by the same Role. Only ack or explicit retirement settles a
+        // claim's scheduling obligation; neither time nor a failed Run does.
+        if (claims.some(claim => claim.recipient?.workItemId === recipient.workItemId
+            && claim.recipient?.reviewRoundId === recipient.reviewRoundId))
+            continue;
         const blocker = messageContinuationBlocker(store, message);
         if (blocker !== undefined) {
             markNotDelivered(store, message, blocker);

package/dist/message/taskInboxOwnership.js

@@ -0,0 +1,21 @@
+import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
+export function latestMessageUpdate(store, message) {
+    return store.listEvents(message.taskId).filter(event => event.type === "message.updated" && event.payload.messageId === message.id).at(-1);
+}
+/** Leader steer has no Assignment recipient; ordinary Task records are not
+ * private inbox messages. Queued Leader inputs remain fixed wake windows. */
+export function isLeaderSteer(message) {
+    return message.recipient === undefined && message.inputControl?.action === "steer";
+}
+/** Derive ownership from original receipts, never from disposable mailboxes. */
+export function taskMessageInboxReceipt(store, message) {
+    const revision = latestMessageUpdate(store, message);
+    return message.inbox ?? store.listTaskWakes(message.taskId).find(wake => wake.inbox !== undefined
+        && (revision === undefined || wake.refs?.some(ref => ref.type === "event" && ref.taskId === message.taskId && ref.id === revision.id))
+        && wake.refs?.some(ref => ref.type === "message" && ref.taskId === message.taskId && ref.id === message.id))?.inbox;
+}
+export function unfinishedLeaderInbox(store, taskId) {
+    return store.listTaskWakes(taskId).some(wake => wake.inbox !== undefined && wake.inbox.ack === undefined)
+        || operationalTaskRecords(store.listMessages(taskId), store.listEvents(taskId), "message").some(message => isLeaderSteer(message)
+            && message.inbox !== undefined && message.inbox.ack === undefined);
+}

package/dist/nativeAgent/session/backends.js

@@ -1,4 +1,4 @@
-import Database from 'better-sqlite3';
+import Database from "../../sqlite/driver.js";
 import { randomUUID } from 'node:crypto';
 import { isAbsolute, resolve } from 'node:path';
 import { existsSync, lstatSync } from 'node:fs';

package/dist/observability/runtimeIdentity.js

@@ -12,7 +12,7 @@ import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { join } from "node:path";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storage/storageVersions.js";
 import { inspectStorageSchema } from "../storage/storageSchema.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";

package/dist/resources/sqliteResourceRegistry.js

@@ -13,7 +13,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import Database from "better-sqlite3";
+import Database from "../sqlite/driver.js";
 import { validateSqliteSchema } from "../storage/sqliteSchema.js";
 import { emptyResourceRegistry, parseResourceRegistryState } from "./resourceRegistry.js";
 import { RESOURCE_REGISTRY_SCHEMA_VERSION } from "./resourceTypes.js";

package/dist/runtime/agentHost.js

@@ -93,6 +93,9 @@ export async function runAgentHost(input) {
     let activeRunPayload;
     let lastTerminalPayload;
     let lastTerminal;
+    // One exact direct Turn witnessed by this Endpoint under its original fence.
+    // This is recovery evidence, never ownership of the Desktop client's input.
+    let directObservation;
     let activeRunAttemptId;
     let activeNativeTurnId;
     let codexClientAttachedAt;
@@ -166,6 +169,7 @@ export async function runAgentHost(input) {
     const handleStarted = (started, observedPayload = sessionPayload) => {
         if (started.clientOwned || observedPayload === undefined)
             return;
+        const observedAuthority = authority === undefined ? undefined : { ...authority };
         updateSnapshot(hostSnapshot("busy", {
             adapterId: observedPayload.providerControl?.adapterId,
             processInstanceId: session?.processInstanceId,
@@ -175,6 +179,22 @@ export async function runAgentHost(input) {
             ...authorityFields()
         }));
         void enqueueSerialized(async () => {
+            // Desktop can start another Turn before the Controller's periodic pass.
+            // Persist the previous exact terminal before replacing its bounded cache
+            // or publishing the new start. Never clear the newer native writer.
+            const previous = directObservation;
+            if (previous?.terminal !== undefined && authority !== undefined
+                && sameProviderAuthorityFence(previous.authority, authority)
+                && previous.started.nativeSessionId === session?.nativeSessionId) {
+                await publishStructuredProviderTerminal({
+                    home: input.home, environment: previous.payload.environment, terminal: previous.terminal
+                });
+            }
+            if (session !== undefined && started.nativeSessionId === session.nativeSessionId
+                && started.conversationId === session.conversationId && observedAuthority !== undefined
+                && authority !== undefined && sameProviderAuthorityFence(observedAuthority, authority)) {
+                directObservation = { started, payload: observedPayload, authority: observedAuthority };
+            }
             await publishStructuredProviderStarted({
                 home: input.home,
                 environment: observedPayload.environment,
@@ -194,6 +214,14 @@ export async function runAgentHost(input) {
             // AgentRun audit record. It has no WorkItem ownership and no managed input
             // fence; the runtime observer records only visible input/output.
             void enqueueSerialized(async () => {
+                const direct = directObservation;
+                if (direct !== undefined && authority !== undefined
+                    && sameProviderAuthorityFence(direct.authority, authority)
+                    && direct.started.nativeSessionId === terminal.nativeSessionId
+                    && direct.started.conversationId === terminal.conversationId
+                    && direct.started.nativeTurnId === terminal.nativeTurnId) {
+                    direct.terminal = terminal;
+                }
                 await publishStructuredProviderTerminal({
                     home: input.home,
                     environment: busyPayload.environment,
@@ -274,6 +302,7 @@ export async function runAgentHost(input) {
                     conversationId: terminal.conversationId,
                     ...authorityFields()
                 }));
+                signalRoleMailbox(input.home, currentPayload);
                 promptHuman();
             }
             catch (error) {
@@ -621,6 +650,7 @@ export async function runAgentHost(input) {
                 await recordProviderConnection(input.home, next, started.session);
                 lastTerminalPayload = undefined;
                 lastTerminal = undefined;
+                directObservation = undefined;
                 // Recoverable means a later process can rebind this Conversation by
                 // its native id. The Endpoint answers that from the Driver capability
                 // or, where the protocol settles it per connection, from what this
@@ -1157,6 +1187,51 @@ export async function runAgentHost(input) {
             }
             return controlResult("accepted", { ...snapshot, nativeTui: !!nativeTui });
         }
+        if (request.type === "reconcile-turn") {
+            if (session === undefined || session.nativeSessionId !== request.nativeSessionId
+                || authority === undefined || !sameProviderAuthorityFence(authority, request.authority)) {
+                throw new Error("Terminal reconciliation targets a different Session or authority.");
+            }
+            const direct = directObservation;
+            const directMatch = direct?.terminal !== undefined
+                && request.nativeTurnId !== undefined
+                && request.attemptId === `direct:${request.nativeTurnId}`
+                && direct.started.nativeTurnId === request.nativeTurnId
+                && direct.started.nativeSessionId === request.nativeSessionId
+                && sameProviderAuthorityFence(direct.authority, request.authority);
+            const terminal = directMatch ? direct.terminal : lastTerminal;
+            const terminalPayload = directMatch ? direct.payload : lastTerminalPayload;
+            if (terminal === undefined || terminalPayload === undefined
+                || terminal.nativeSessionId !== request.nativeSessionId
+                || !directMatch && (terminal.clientOwned !== true || terminal.attemptId !== request.attemptId)
+                || request.nativeTurnId !== undefined && terminal.nativeTurnId !== request.nativeTurnId) {
+                return { ...controlResult("status", snapshot), reconciliation: "unobserved" };
+            }
+            // Serialize with submission/terminal persistence. The original Host and
+            // original launch envelope remain the observer, including the full result.
+            await enqueueSerialized(async () => {
+                if (session?.nativeSessionId !== request.nativeSessionId || authority === undefined
+                    || !sameProviderAuthorityFence(authority, request.authority)
+                    || directMatch && directObservation !== direct) {
+                    throw new Error("Session changed before terminal reconciliation.");
+                }
+                await publishStructuredProviderTerminal({
+                    home: input.home, environment: terminalPayload.environment, terminal
+                });
+                if (!directMatch && activeRunAttemptId === terminal.attemptId) {
+                    activeRunPayload = undefined;
+                    activeRunAttemptId = undefined;
+                    activeNativeTurnId = undefined;
+                    updateSnapshot(hostSnapshot(session.inspect().activeNativeTurnId === undefined ? "idle" : "busy", {
+                        adapterId: session.adapterId, processInstanceId: session.processInstanceId,
+                        nativeSessionId: session.nativeSessionId, conversationId: session.conversationId,
+                        ...authorityFields()
+                    }));
+                }
+                signalRoleMailbox(input.home, terminalPayload);
+            });
+            return { ...controlResult("status", snapshot), reconciliation: "terminal-republished" };
+        }
         if (request.type === "status") {
             // Read the Agent's configuration at answer time, not from the stored
             // snapshot. The Agent may have changed it since the last state
@@ -1461,6 +1536,11 @@ export async function inspectAgentHost(input) {
     });
     return result.snapshot;
 }
+export async function reconcileAgentHostTurn(input) {
+    // Periodic observation must not hold the scheduler behind an unavailable Host.
+    // A timeout is only an observation failure, never permission to submit again.
+    return exchangeAgentHostControl(agentHostControlSocketPath(input), input.control, 1_000);
+}
 export async function waitForAgentHostLaunchAck(input) {
     const deadline = Date.now() + (input.timeoutMs ?? AGENT_HOST_READY_TIMEOUT_MS);
     let lastError;
@@ -1616,7 +1696,7 @@ export async function openAgentHostControl(home, payload, snapshot, dispatch) {
                         ...result,
                         snapshot: {
                             ...result.snapshot,
-                            ...(payload.environment.YUI_SESSION_SCOPE !== "task" ? {} : {
+                            ...(!["task", "global"].includes(payload.environment.YUI_SESSION_SCOPE ?? "") ? {} : {
                                 eventDelivery: structuredProviderEventDelivery(home, payload.environment, result.snapshot.nativeSessionId)
                             })
                         }
@@ -1691,7 +1771,8 @@ function boundControlResponse(result) {
     // visible through an otherwise successful status request.
     result = {
         ...controlResult(result.outcome, validateSnapshot(result.snapshot), result.failure === undefined ? undefined : providerDeliveryFailure(result.failure)),
-        ...(result.cancellation === undefined ? {} : { cancellation: result.cancellation })
+        ...(result.cancellation === undefined ? {} : { cancellation: result.cancellation }),
+        ...(result.reconciliation === undefined ? {} : { reconciliation: result.reconciliation })
     };
     if (withinControlBound(result))
         return result;
@@ -1709,29 +1790,29 @@ function boundControlResponse(result) {
     };
     // Never make an omitted option list look like a complete empty enumeration.
     if (result.snapshot.runConfiguration?.status === "observed") {
-        result = controlResult(result.outcome, validateSnapshot({
-            ...result.snapshot,
-            runConfiguration: unknownAgentRunConfiguration("The Agent's reported configuration is too large for the Agent Host "
-                + "control response, so it could not be carried in full and none of it "
-                + "is shown rather than part of it.")
-        }), result.failure);
+        result = { ...result, ...controlResult(result.outcome, validateSnapshot({
+                ...result.snapshot,
+                runConfiguration: unknownAgentRunConfiguration("The Agent's reported configuration is too large for the Agent Host "
+                    + "control response, so it could not be carried in full and none of it "
+                    + "is shown rather than part of it.")
+            }), result.failure) };
         if (withinControlBound(result))
             return result;
     }
-    let bounded = controlResult(result.outcome, {
-        ...result.snapshot,
-        ...(result.snapshot.detail === undefined ? {} : { detail: clip(result.snapshot.detail, 1200) })
-    }, result.failure === undefined ? undefined : { ...result.failure, detail: clip(result.failure.detail, 1200) });
+    let bounded = { ...result, ...controlResult(result.outcome, {
+            ...result.snapshot,
+            ...(result.snapshot.detail === undefined ? {} : { detail: clip(result.snapshot.detail, 1200) })
+        }, result.failure === undefined ? undefined : { ...result.failure, detail: clip(result.failure.detail, 1200) }) };
     const raw = bounded.failure?.raw;
     if (withinControlBound(bounded) || raw === undefined)
         return bounded;
     let chars = raw.length;
     while (!withinControlBound(bounded) && chars > 0) {
         chars = Math.floor(chars / 2);
-        bounded = controlResult(bounded.outcome, bounded.snapshot, {
-            ...bounded.failure,
-            raw: clip(raw, chars)
-        });
+        bounded = { ...bounded, ...controlResult(bounded.outcome, bounded.snapshot, {
+                ...bounded.failure,
+                raw: clip(raw, chars)
+            }) };
     }
     return bounded;
 }
@@ -1764,6 +1845,14 @@ function validateControl(control) {
     }
     if (control.type === "status")
         return Object.freeze({ ...control });
+    if (control.type === "reconcile-turn") {
+        validateIdentity(control.nativeSessionId, "native Session id");
+        validateIdentity(control.attemptId, "Provider input attempt id");
+        if (control.nativeTurnId !== undefined)
+            validateIdentity(control.nativeTurnId, "native Turn id");
+        validateProviderAuthorityFence(control.authority);
+        return Object.freeze({ ...control });
+    }
     if (control.type === "native-open" || control.type === "native-respond" || control.type === "native-model") {
         validateIdentity(control.nativeSessionId, "native Session id");
         if (control.type === "native-model" && (typeof control.model !== "string"