@zq-silk/yui 0.15.9 → 0.15.11

package/dist/controller/globalInputDelivery.js

@@ -0,0 +1,119 @@
+import { sendAgentHostRunControl, AGENT_HOST_CONTROL_PROTOCOL } from "../runtime/agentHost.js";
+import { currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
+import { hasRuntimeCleanupObligation, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
+import { markGlobalRoleMessageNotDelivered } from "../message/message.js";
+/** Messages are the only queue. Host's atomic begin arbitrates native writers. */
+export async function deliverGlobalInputs(home, store, ensure, onError) {
+    for (const role of store.listGlobalRoles()) {
+        try {
+            let pending = store.listGlobalRoleMessages(role.name).filter(message => message.delivery === undefined && message.notDelivered === undefined
+                && (message.inputControl?.action === "queue" || message.interruptThen !== undefined));
+            if (pending.length === 0 || hasRuntimeCleanupObligation(store.getWorkMailbox(runtimeLifecycleTarget({ scope: "global", roleName: role.name }))))
+                continue;
+            let sessions = store.getGlobalRoleSessionSet(role.name);
+            const current = sessions?.providerBinding?.run;
+            const obsolete = pending.filter(message => {
+                const claim = message.interruptThen;
+                return claim !== undefined && (sessions?.activeAgentId !== claim.targetAgentId
+                    || sessions.sessions[claim.targetAgentId]?.nativeSessionId !== claim.targetNativeSessionId
+                    || sessions.providerBinding?.authority.epoch !== claim.targetAuthorityEpoch
+                    || sessions.providerBinding.authority.holderId !== claim.targetAuthorityHolderId);
+            });
+            for (const message of obsolete)
+                store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(message, "native-session-or-authority-changed", new Date()));
+            pending = pending.filter(message => !obsolete.includes(message));
+            if (pending.length === 0)
+                continue;
+            if (current != null && ["submitting", "accepted", "delivery-unknown"].includes(current.status))
+                continue;
+            const claims = pending.filter(message => message.interruptThen !== undefined);
+            let next;
+            if (claims.length > 0) {
+                next = claims.find(message => {
+                    const claim = message.interruptThen;
+                    const binding = sessions?.providerBinding;
+                    return current?.attemptId === claim.targetAttemptId
+                        && ["completed", "failed", "cancelled"].includes(current.status)
+                        && sessions?.activeAgentId === claim.targetAgentId
+                        && sessions.sessions[claim.targetAgentId]?.nativeSessionId === claim.targetNativeSessionId
+                        && binding?.authority.owner === "controller"
+                        && binding.authority.epoch === claim.targetAuthorityEpoch
+                        && binding.authority.holderId === claim.targetAuthorityHolderId;
+                });
+                if (next === undefined)
+                    continue;
+            }
+            else
+                next = pending[0];
+            const attemptId = `global-input:${role.name}/${next.id}`;
+            if (current?.attemptId === attemptId)
+                continue;
+            if (next.control !== undefined && next.control.outcome !== "rejected")
+                continue;
+            const matchesTarget = () => next.deliveryTarget === undefined
+                || sessions?.activeAgentId === next.deliveryTarget.agentId
+                    && sessions.sessions[next.deliveryTarget.agentId]?.nativeSessionId === next.deliveryTarget.nativeSessionId;
+            if (!matchesTarget()) {
+                store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(next, "native-session-changed", new Date()));
+                continue;
+            }
+            await ensure(role.name);
+            sessions = store.getGlobalRoleSessionSet(role.name);
+            const binding = sessions?.providerBinding;
+            if (binding == null || binding.authority.owner !== "controller")
+                continue;
+            const nativeSessionId = currentProviderConversation(binding).conversationId;
+            const persisted = store.listGlobalRoleMessages(role.name).find(message => message.id === next.id);
+            if (persisted === undefined || JSON.stringify(persisted) !== JSON.stringify(next))
+                continue;
+            const claim = next.interruptThen;
+            if (!matchesTarget() || claim !== undefined
+                && (sessions?.activeAgentId !== claim.targetAgentId
+                    || nativeSessionId !== claim.targetNativeSessionId
+                    || binding.authority.epoch !== claim.targetAuthorityEpoch
+                    || binding.authority.holderId !== claim.targetAuthorityHolderId
+                    || binding.run?.attemptId !== claim.targetAttemptId
+                    || !["completed", "failed", "cancelled"].includes(binding.run.status))) {
+                store.updateGlobalRoleMessage(markGlobalRoleMessageNotDelivered(next, "native-session-changed", new Date()));
+                continue;
+            }
+            if (next.deliveryTarget === undefined) {
+                next = { ...next, deliveryTarget: { agentId: sessions.activeAgentId, nativeSessionId } };
+                store.updateGlobalRoleMessage(next);
+            }
+            const result = await sendAgentHostRunControl({
+                home, scope: "global", roleName: role.name,
+                control: {
+                    protocol: AGENT_HOST_CONTROL_PROTOCOL, type: "submit-turn", nativeSessionId,
+                    authority: { epoch: binding.authority.epoch, owner: "controller",
+                        holderId: binding.authority.holderId },
+                    run: { attemptId, boundedText: [
+                            `Yui Global Message: role=${role.name} message=${next.id}.`,
+                            "Read your Session Context and the referenced Message in full, then act on its durable input."
+                        ].join("\n") }
+                }
+            });
+            if (result.outcome === "rejected") {
+                store.transaction(tx => {
+                    const latest = tx.listGlobalRoleMessages(role.name).find(message => message.id === next.id);
+                    if (latest === undefined || latest.delivery !== undefined || latest.notDelivered !== undefined)
+                        return;
+                    const turn = tx.getGlobalRoleSessionSet(role.name)?.providerBinding?.run;
+                    // A later canonical acceptance wins over transport diagnostics.
+                    if (turn?.attemptId === attemptId && ["accepted", "completed", "failed", "cancelled"].includes(turn.status))
+                        return;
+                    const unknown = result.failure?.inputDisposition === "unknown" || result.snapshot.state === "delivery-unknown";
+                    const updated = { ...latest, control: {
+                            requestId: latest.inputControl?.requestId ?? latest.interruptThen.requestId,
+                            receiptId: attemptId, outcome: unknown ? "delivery-unknown" : "rejected",
+                            observedAt: new Date().toISOString()
+                        } };
+                    tx.updateGlobalRoleMessage(unknown ? updated : markGlobalRoleMessageNotDelivered(updated, result.failure?.detail ?? result.snapshot.detail ?? "provider-input-rejected", new Date()));
+                });
+            }
+        }
+        catch (error) {
+            onError(error);
+        }
+    }
+}

package/dist/controller/jobControl.js

@@ -253,10 +253,14 @@ function validateJobTarget(store, params) {
         if (attempt === null) {
             throw jobDomainError(`Integration Attempt not found: ${params.taskId}/${params.owner.integrationAttemptId}.`);
         }
-        if (attempt.status === "committed" || attempt.status === "failed") {
-            throw jobDomainError(`DurableJob owner Integration Attempt is terminal: `
+        if (attempt.status !== "running") {
+            throw jobDomainError(`DurableJob owner Integration Attempt must be running: `
                 + `${params.taskId}/${params.owner.integrationAttemptId} is ${attempt.status}.`);
         }
+        if (attempt.candidateCommit !== params.head || attempt.checkInputDigest === undefined
+            || attempt.checkInputDigest !== durableJobIdempotencyKey(params)) {
+            throw jobDomainError("Integration Job has no matching admitted candidate/check specification.");
+        }
     }
     const project = store.getProject(params.projectId);
     if (project === null) {

package/dist/controller/resourceInventory.js

@@ -1,4 +1,11 @@
 import { resolve } from "node:path";
+/** Archiving may retain execution; a Task lifecycle label is not exit proof. */
+export function runtimeRoleProtectsDomain(role) {
+    return (role.ownerKind === "task-role"
+        && (role.taskStatus === "active" || role.taskStatus === "archived"))
+        // Global Roles have no Task lifecycle; require a current native Session.
+        || (role.ownerKind === "global-role" && role.nativeSessionId !== undefined);
+}
 export function createRuntimeResourceActivityTracker() {
     const previous = new Map();
     return (identity, resource) => {
@@ -112,8 +119,7 @@ export function buildControllerResourceInventory(facts) {
             for (const process of paneProcesses)
                 claimed.add(process.pid);
             const role = findRole(homeFact.roles, pane);
-            const terminalIsolation = (role?.taskStatus === "cancelled" && role.taskRetirementIsolated === true)
-                || role?.taskStatus === "archived";
+            const terminalIsolation = role?.taskStatus === "cancelled" && role.taskRetirementIsolated === true;
             resources.push(processResource({
                 kind: "agent-session",
                 state: pane.dead ? "dead" : role === undefined ? "orphaned" : "running",
@@ -122,7 +128,8 @@ export function buildControllerResourceInventory(facts) {
                     : terminalIsolation ? "safe" : "protected",
                 reasonCode: role === undefined
                     ? pane.dead ? "dead-orphan-pane" : "orphan-pane"
-                    : terminalIsolation ? (role.taskStatus === "cancelled" ? "retired-task-pane" : "archived-task-pane") : "owned-role-pane",
+                    : terminalIsolation ? "retired-task-pane"
+                        : role.taskStatus === "archived" ? "archived-task-pane" : "owned-role-pane",
                 yuiHome,
                 owner: role === undefined ? { kind: "none" } : roleOwner(role),
                 processes: paneProcesses,
@@ -358,7 +365,10 @@ function artifactResource(artifact, yuiHome, domain, homeId) {
     };
 }
 function domainDisposition(base, reason, domain, target) {
-    if (reason === "retired-task-pane" || reason === "archived-task-pane") {
+    // Even an expired test domain cannot authorize deleting retained execution.
+    if (reason === "archived-task-pane")
+        return "protected";
+    if (reason === "retired-task-pane") {
         return "safe";
     }
     if (domain === undefined)

package/dist/controller/resourceInventoryLinux.js

@@ -11,7 +11,7 @@ import { readControllerDiscovery } from "../core/controllerClient.js";
 import { CONTROLLER_DISCOVERY_PATH } from "../core/protocol.js";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
-import { buildControllerResourceInventory } from "./resourceInventory.js";
+import { buildControllerResourceInventory, runtimeRoleProtectsDomain } from "./resourceInventory.js";
 import { CONTROLLER_DOMAIN_PATH, EPHEMERAL_DOMAIN_GRACE_MS, ephemeralDomainFingerprint, readEphemeralDomainIdentity, readLinuxProcessStartIdentity } from "./domainIdentity.js";
 const LINUX_PROCESS_SCAN_BATCH_SIZE = 64;
 export const INVENTORY_EVENT_LOOP_RUN_BUDGET_MS = 25;
@@ -518,11 +518,7 @@ function inspectRuntimeDomain(home, processes, roles, storageStatus, now) {
             graceMs: EPHEMERAL_DOMAIN_GRACE_MS
         };
     }
-    const activeRole = roles.some((role) => ((role.ownerKind === "task-role" && role.taskStatus === "active")
-        // Global Roles have no Task status. Only a live native Session is a
-        // durable liveness fact for that scope; stopped/broken history must not
-        // protect an expired disposable domain merely because it has an ID.
-        || (role.ownerKind === "global-role" && role.nativeSessionId !== undefined)));
+    const activeRole = roles.some(runtimeRoleProtectsDomain);
     if (!storageSafe) {
         return {
             kind: "ephemeral-test",

package/dist/controller/runtime.js

@@ -1,5 +1,4 @@
 import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveRuntimeHealth, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
-import { resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { controllerSocketPath } from "../core/controllerEndpoint.js";
 import { AGENT_OPERATIONAL_ENVIRONMENT_NAMES, NATIVE_AGENT_ENVIRONMENT_NAMES, nativeAgentEnvironmentNames, YUI_MANAGED_RUNTIME_ENVIRONMENT_NAMES } from "../agent/launchEnvironment.js";
@@ -11,6 +10,7 @@ import { AgentConfigurationCatalogService, validateAgentLaunchConfiguration } fr
 import { isTaskOwnedWorkspace, sameManagedWorkspaceIdentity } from "../worktree/managedWorkspace.js";
 import { FileRoleLaunchPlanner } from "../executor/fileRoleLaunchPlanner.js";
 import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
+import { managedRuntimeRoot } from "../storage/homeLayout.js";
 import { SqliteTaskStore } from "../storage/sqliteStore.js";
 import { AsyncTaskStoreClient, resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
@@ -41,9 +41,12 @@ import { createResourceAutoGc } from "../resources/autoResourceGc.js";
 import { createRuntimeResourceActivityTracker } from "./resourceInventory.js";
 import { SessionOwnerReconciliation } from "./sessionOwnerReconciliation.js";
 import { launchBrokerForHome } from "../runtime/launchBroker.js";
+import { assertExecutionEnvironmentCurrent } from "../runtime/executionEnvironment.js";
 import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } from "../runtime/processExitObservation.js";
 import { replayRuntimeProcessExitOutbox } from "../runtime/processExitOutbox.js";
 import { appendGlobalProcessExitObservation } from "../runtime/globalProcessExitStore.js";
+import { deliverGlobalInputs } from "./globalInputDelivery.js";
+import { createGlobalRoleMessage } from "../message/message.js";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { createTaskEvent } from "../event/taskEvent.js";
@@ -174,11 +177,14 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             ?? new AgentHostPromptPushAdapter(home);
         const runtimeIsolation = options.runtimeIsolation
             ?? new FileTaskRuntimeIsolation({
-                // A sibling of the exact control Home keeps provider data/cache/tmp out
-                // of both the shared control plane and every managed Git workspace.
-                runtimeRoot: `${resolve(home)}.task-runtimes`,
+                // Provider data/cache/tmp live in a dedicated Home partition. The
+                // control boundary permits runtime roots to overlap only this exact
+                // subtree, keeping them out of the database, managed Git workspaces and
+                // every other part of the control plane.
+                runtimeRoot: managedRuntimeRoot(home),
                 controlPlane: {
                     yuiHome: home,
+                    managedRuntimeRoot: managedRuntimeRoot(home),
                     controllerSocketPath: controllerSocketPath(homeId),
                     tmuxNamespace: yuiTmuxServerName(home),
                     globalInstallPaths: [process.execPath]
@@ -239,6 +245,31 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             sessionHost,
             promptPush,
             launchCoordinator,
+            notifyOperatorInputOnce: async (input) => {
+                // The original attention mailbox remains pending until this one
+                // Global Message has an actual Provider receipt. Never inject keys
+                // into a busy Host console and mistake that for accepted attention.
+                const message = store.transaction(tx => {
+                    const requestId = `operator-notice:${encodeURIComponent(input.receiptId)}`;
+                    const previous = tx.listGlobalRoleMessages("operator").find(entry => (entry.inputControl ?? entry.interruptThen?.reusedInput)?.requestId === requestId);
+                    if (previous !== undefined)
+                        return previous;
+                    const sessions = tx.getGlobalRoleSessionSet("operator");
+                    const session = sessions?.sessions[sessions.activeAgentId];
+                    if (session?.status !== "active" || sessions?.providerBinding == null)
+                        return null;
+                    const created = { ...createGlobalRoleMessage(tx.nextGlobalRoleMessageId(), "operator", input.text, "system", { type: "system" }, new Date(), { inputControl: { action: "queue", requestId } }),
+                        deliveryTarget: { agentId: session.agentId, nativeSessionId: session.nativeSessionId } };
+                    tx.saveGlobalRoleMessage(created);
+                    return created;
+                });
+                if (message === null)
+                    return "unavailable";
+                if (message.delivery?.via === "provider")
+                    return "already-sent";
+                runningRuntime?.signal("global-role:operator");
+                return "not-ready";
+            },
             roleResourceInventory: async (panes, inputs) => {
                 const inventory = await scanInventory(panes);
                 return inventory.resources.flatMap((resource) => {
@@ -440,6 +471,9 @@ export async function startFileTaskControllerRuntime(home, options = {}) {
             onError: options.onError,
             lifecycleHost,
             jobSupervisor,
+            globalInputDelivery: () => deliverGlobalInputs(home, store, async (roleName) => {
+                await lifecycleDispatcher("runtime.ensure-role-session", { scope: "global", roleName });
+            }, options.onError ?? (() => undefined)),
             jobControl,
             capabilityDispatcher: createCapabilityDispatcher(kernel.capabilities),
             ...(continuationReconciler === undefined ? {} : { continuationReconciler }),
@@ -546,6 +580,20 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
         });
     const lifecycleTails = new Map();
     return async (method, params) => {
+        if (method === "runtime.host-observation-apply") {
+            const id = params.eventId;
+            if (typeof id !== "string")
+                throw applicationError("INVALID_PARAMS", "Host event id is required.");
+            // Eager delivery is only a hint about the exact immutable Inbox file.
+            // Missing means the normal drainer has already committed and ACKed it.
+            const event = new FileRuntimeEventInbox(store.rootDirectory()).read(id);
+            if (event === null)
+                return { outcome: "applied" };
+            if (event.type !== "runtime-observation" || event.host === undefined) {
+                throw applicationError("INVALID_PARAMS", "Expected an Agent Host observation.");
+            }
+            return { outcome: schedulerStore.observeAgentHostObservation(event, new Date()) };
+        }
         if (method === "runtime.observation-apply") {
             try {
                 return {
@@ -676,7 +724,34 @@ export function createRuntimeLifecycleDispatcher(store, schedulerStore, sessionH
             }
             // The launch payload is validated at reservation time and every member
             // of its discriminated Provider-control union is JSON serializable.
-            return launchBrokerForHome(store.rootDirectory()).redeem(ticket);
+            const payload = launchBrokerForHome(store.rootDirectory()).redeem(ticket);
+            if (payload.executionEnvironment !== undefined) {
+                if (payload.environment.YUI_SESSION_SCOPE !== "task"
+                    || payload.environment.YUI_TASK_ID !== payload.executionEnvironment.taskId
+                    || payload.cwd !== payload.executionEnvironment.directory.path) {
+                    throw applicationError("INVALID_PARAMS", "Launch does not match its adopted execution environment.");
+                }
+                assertExecutionEnvironmentCurrent(store, payload.executionEnvironment.taskId, payload.executionEnvironment);
+            }
+            return payload;
+        }
+        if (method === "runtime.execution-environment-check") {
+            const value = params;
+            const { taskId, roleName, agentId, nativeSessionId, workspace } = value;
+            if ([taskId, roleName, agentId, nativeSessionId, workspace].some(v => typeof v !== "string")) {
+                throw applicationError("INVALID_PARAMS", "Exact Host execution identity is required.");
+            }
+            const sessions = store.getTaskRoleSessionSet(taskId, roleName);
+            const session = sessions?.sessions[agentId];
+            if (sessions?.activeAgentId !== agentId || session?.status !== "active"
+                || session.nativeSessionId !== nativeSessionId
+                || (session.effective.executionEnvironment?.directory.path ?? session.effective.workspace.root) !== workspace) {
+                throw applicationError("INVALID_PARAMS", "Host no longer owns the current execution environment.");
+            }
+            if (session.effective.executionEnvironment !== undefined) {
+                assertExecutionEnvironmentCurrent(store, taskId, session.effective.executionEnvironment);
+            }
+            return { current: true };
         }
         if (method === "runtime.replace-agent-environment") {
             if (environmentRefresher === undefined) {
@@ -1123,7 +1198,7 @@ function providerTurnControlParams(params) {
         throw applicationError("INVALID_PARAMS", "Provider Turn control fence is invalid.");
     }
     return {
-        taskId: requiredParam(value.taskId),
+        ...(value.taskId === undefined ? {} : { taskId: requiredParam(value.taskId) }),
         roleName: requiredParam(value.roleName),
         ...(value.runId === undefined ? {} : { runId: requiredParam(value.runId) }),
         agentId: requiredParam(value.agentId),

package/dist/controller/runtimeEventInbox.js

@@ -4,6 +4,7 @@ import { closeSync, constants, existsSync, fchmodSync, fsyncSync, linkSync, lsta
 import { join } from "node:path";
 import { createRuntimeObservation, isRuntimeTokenEvidence } from "../runtime/runtimeObservation.js";
 import { boundedRunFailureDiagnostic, transportAgentResult } from "../domain/agentResultTransport.js";
+import { readAgentHostObservationSource } from "../runtime/agentHostProtocol.js";
 export const MAX_RUNTIME_EVENT_FILE_BYTES = 16 * 1024 * 1024;
 const RUNTIME_EVENT_DIRECTORY = join("runtime", "inbox");
 const INVALID_RUNTIME_EVENT_DIRECTORY = join("runtime", "inbox-invalid");
@@ -24,7 +25,7 @@ export class FileRuntimeEventInbox {
         this.hooks = hooks;
         this.directory = join(home, RUNTIME_EVENT_DIRECTORY);
     }
-    enqueueObservation(input) {
+    enqueueObservation(input, host) {
         const observation = createRuntimeObservation(input);
         const scope = observation.fence.taskId === undefined ? "global" : "task";
         const event = Object.freeze({
@@ -36,7 +37,8 @@ export class FileRuntimeEventInbox {
             ...(observation.fence.taskId === undefined
                 ? {}
                 : { taskId: observation.fence.taskId }),
-            observation
+            observation,
+            ...(host === undefined ? {} : { host: readAgentHostObservationSource(host) })
         });
         return this.publish(event);
     }
@@ -117,6 +119,20 @@ export class FileRuntimeEventInbox {
         }
         return event;
     }
+    /** Producer-local delivery diagnostics need only existence, never a read of
+     * another version's payload or permission to quarantine another producer. */
+    has(id) {
+        assertEventId(id);
+        try {
+            lstatSync(this.eventPath(id));
+            return true;
+        }
+        catch (error) {
+            if (isNodeError(error, "ENOENT"))
+                return false;
+            throw error;
+        }
+    }
     acknowledge(id) {
         assertEventId(id);
         try {
@@ -408,6 +424,7 @@ function parseRuntimeEvent(value) {
 function parseRuntimeObservationEvent(value) {
     const expected = [
         "schemaVersion", "id", "type", "receivedAt", "scope", "observation",
+        ...(value.host === undefined ? [] : ["host"]),
         ...(value.taskId === undefined ? [] : ["taskId"])
     ];
     if (value.schemaVersion !== 1 || !hasExactKeys(value, expected))
@@ -426,9 +443,18 @@ function parseRuntimeObservationEvent(value) {
         receivedAt: observation.receivedAt,
         scope,
         ...(scope === "task" ? { taskId: observation.fence.taskId } : {}),
-        observation
+        observation,
+        ...(value.host === undefined ? {} : { host: parseHostSource(value.host) })
     });
 }
+function parseHostSource(value) {
+    try {
+        return readAgentHostObservationSource(value);
+    }
+    catch (error) {
+        throw invalidEvent(error instanceof Error ? error.message : String(error));
+    }
+}
 function parseDurableJobTerminalEvent(value) {
     const expected = [
         "schemaVersion", "id", "type", "receivedAt", "scope", "taskId",
@@ -520,6 +546,9 @@ function assertEventId(id) {
         throw invalidEvent("Runtime event id is invalid.");
 }
 function hasSameIdentity(left, right) {
+    if (left.type === "runtime-observation" && right.type === "runtime-observation"
+        && !isDeepStrictEqual(left.host, right.host))
+        return false;
     if (left.type === "runtime-observation" && right.type === "runtime-observation"
         && ["turn.completed", "turn.failed", "turn.cancelled"].includes(left.observation.kind)) {
         return left.id === right.id

package/dist/controller/runtimeEventProcessor.js

@@ -143,11 +143,17 @@ export class FileRuntimeEventProcessor {
         return { candidate, outcome };
     }
     applyRuntimeObservation(event, now) {
+        if (event.host !== undefined) {
+            return this.observer.observeAgentHostObservation?.(event, now) ?? "deferred";
+        }
         const taskId = event.observation.fence.taskId;
         if (taskId !== undefined) {
             const task = this.observer.getTask(taskId);
+            if (task?.status === "archived") {
+                this.recordObsolete(event, "task-archived", now);
+                return "obsolete";
+            }
             if (task === null
-                || task.status === "archived"
                 || (!["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind)
                     && (task.status !== "active" || task.executionGate.state !== "enabled")))
                 return "obsolete";
@@ -247,7 +253,8 @@ export class FileRuntimeEventProcessor {
                 agentId: fence.agentId,
                 ...(fence.runId === undefined ? {} : { runId: fence.runId }),
                 nativeSessionId: fence.nativeSessionId,
-                reason
+                reason,
+                ...(reason === "task-archived" ? { originalEvent: event } : {})
             }, now);
             return;
         }
@@ -263,7 +270,8 @@ export class FileRuntimeEventProcessor {
             agentId: event.agentId,
             ...(event.runId === undefined ? {} : { runId: event.runId }),
             nativeSessionId: event.nativeSessionId,
-            reason
+            reason,
+            ...(reason === "task-archived" ? { originalEvent: event } : {})
         }, now);
     }
     acknowledge(ids, acknowledged) {
@@ -394,6 +402,9 @@ function progressStreamKey(event) {
         fence.driverId,
         fence.nativeSessionId ?? null,
         fence.runId ?? null,
+        fence.receiptId ?? null,
+        fence.nativeTurnId ?? null,
+        event.host ?? null,
         payload.activity,
         isRuntimeTokenEvidence(event.observation) ? "usage" : "signal"
     ]);
@@ -510,6 +521,7 @@ export function createAsyncRuntimeObserver(invoke) {
     const withNow = (method, input, now) => now === undefined ? call(method, [input]) : call(method, [input, now]);
     return {
         getTask: (taskId) => call("getTask", [taskId]),
+        observeAgentHostObservation: (input, now) => withNow("observeAgentHostObservation", input, now),
         observeRuntimeObservation: (input, now) => withNow("observeRuntimeObservation", input, now),
         observeRuntimeRunTerminal: (input, now) => withNow("observeRuntimeRunTerminal", input, now),
         observeGlobalRuntimeRunTerminal: (input, now) => withNow("observeGlobalRuntimeRunTerminal", input, now),
@@ -605,11 +617,17 @@ export class AsyncRuntimeEventProcessor {
         };
     }
     async applyRuntimeObservation(event, now) {
+        if (event.host !== undefined) {
+            return this.observer.observeAgentHostObservation?.(event, now) ?? "deferred";
+        }
         const taskId = event.observation.fence.taskId;
         if (taskId !== undefined) {
             const task = await this.observer.getTask(taskId);
+            if (task?.status === "archived") {
+                await this.recordObsolete(event, "task-archived", now);
+                return "obsolete";
+            }
             if (task === null
-                || task.status === "archived"
                 || (!["turn.completed", "turn.failed", "turn.cancelled"].includes(event.observation.kind)
                     && (task.status !== "active" || task.executionGate.state !== "enabled")))
                 return "obsolete";
@@ -685,7 +703,8 @@ export class AsyncRuntimeEventProcessor {
                 agentId: fence.agentId,
                 ...(fence.runId === undefined ? {} : { runId: fence.runId }),
                 nativeSessionId: fence.nativeSessionId,
-                reason
+                reason,
+                ...(reason === "task-archived" ? { originalEvent: event } : {})
             }, now);
             return;
         }
@@ -697,7 +716,8 @@ export class AsyncRuntimeEventProcessor {
             agentId: event.agentId,
             ...(event.runId === undefined ? {} : { runId: event.runId }),
             nativeSessionId: event.nativeSessionId,
-            reason
+            reason,
+            ...(reason === "task-archived" ? { originalEvent: event } : {})
         }, now);
     }
     acknowledge(ids, acknowledged) {