@open-everywhere/core 0.1.0

package/agent/channels/task-wake.ts

@@ -0,0 +1,528 @@
+// task-wake — one background task, one host-minted wake id: minted when the delegation PARKS, installed on the turn the settlement WAKES. Without it a task-woken turn inherits the previous wake's stamp, so it holds a live reply address into a conversation that asked it nothing. eve gives authored code no signal on the wake itself, so the identity rides the two edges OE does see — the parked receipt and the settlement notification — and both calls sit in ONE hook file, because eve gives no ordering guarantee between hook files.
+// A settlement wake deliberately does NOT re-run OE's ingress gates: it enters no surface to admit, a framework notification has no author to classify, and its content taint is already adopted at the edge the child's prose enters the parent's history. The ingress gates are about UNTRUSTED INPUT and an UNKNOWN AUTHOR, and a settlement wake has neither — it was the IDENTITY that was missing.
+
+import { appendAudit } from "../audit/audit.js";
+import { getOperationalStore } from "../operational/provider.js";
+// A LEAF import: access/task-wake-signal.ts reaches only `eve/context`, so nothing in this file's
+// own import cone can be reached back through it.
+import { adoptTaskWakeThisTurn, uningressedTurn } from "../access/task-wake-signal.js";
+import type { DispatchedTaskWake } from "../access/dispatch-origin-signal.js";
+import {
+  mintWakeId,
+  isWakeSurfaceBinding,
+  registerUnifiedWakeTarget,
+  resolveUnifiedWakeAuthority,
+  resolveUnifiedWakeBinding,
+  resolveUnifiedWakeSurfaceKey,
+  resolveUnifiedWakeTarget,
+  sameUnifiedConversation,
+  sameUnifiedPlacement,
+  withCarriedPlacement,
+  WAKE_TARGET_TTL_MS,
+  type ResolvedUnifiedWakeAuthority,
+} from "./unified-window.js";
+import { adoptDelegatedAuthority, delegatedBindingAdopted, pinDelegatedBindingToTurn, type DelegatedDispatchAuthority } from "../identity/delegated-binding.js";
+import { currentTurnId, deploymentOrg, isSubagentChildContext, subagentParentSessionId, type BindableContext, type SurfaceBinding } from "../identity/binding.js";
+import { isRequesterVerdict, type RequesterVerdict } from "../access/requester-identity.js";
+import type { SettlementDispatchAuthority } from "../access/settlement-dispatch-signal.js";
+
+/** The audit action naming the turn a background task woke. This is the "wake row of its own" the
+ *  defect was the absence of: it names the task, the wake id the turn now answers under, and the
+ *  stale id it would otherwise have inherited. */
+export const TASK_WAKE_ACTION = "unified.task_wake";
+
+/** The audit action naming a task wake MOVED to the conversation its dispatching turn addressed. Its own action rather than a second `unified.task_wake` shape, so "did the coalesced-turn correction fire, and where did it move the answer" is countable. */
+export const TASK_WAKE_RETARGET_ACTION = "unified.task_wake_retarget";
+
+/** The `reply.refused` reason for a settlement turn that holds no address yet (OPE-597) — its own
+ *  reason string, so the size of this hole is countable in production apart from every other
+ *  refusal. Joins to the `unified.task_wake` rows by session and turn. */
+export const TASK_WAKE_UNREAD_REFUSAL_REASON = "task-wake-unread";
+
+/**
+ * The copy a settlement turn reads when it holds NO reply address at all. It names no recovery tool, because there is no recovery: the identity installs from the settlement notification before the model's first word, so a turn that STILL has no address is one whose wake row could not be found, and no tool call can produce it. Naming one would send the model round a loop it cannot win.
+ * It states the fact and names the one honest action left. It deliberately DISCLOSES NO WAKE ID — there is no id this turn may answer under, and the ids it can see belong to other conversations.
+ */
+export function taskWakeUnreadRefusalMessage(): string {
+  return (
+    "reply: this turn was woken by delegated work finishing, and it has NO reply address — nothing was posted. " +
+    "The wake-id from the previous message belongs to a different conversation, so replying under it would answer a room that asked nothing. " +
+    "No tool call can recover the address: the task's own wake record is missing or expired. " +
+    "Call `no_reply` to end this turn, and say what the worker found the next time that conversation asks."
+  );
+}
+
+/** Key prefix for the taskId→wakeId row. Its own namespace, so it can never be confused with the
+ *  taint plane's `oe-task-call:` / `oe-task-agent:` rows in the same task-result slice. */
+const TASK_WAKE_PREFIX = "oe-task-wake:";
+/** Parent session + call id → task wake. The child holds exactly these two host-set ids. */
+const DELEGATED_TASK_WAKE_PREFIX = "oe-delegated-task-wake:";
+
+/** Same 6h bound as the wake-target map itself — the two rows are read together and a wake id that
+ *  outlived its origin row would resolve to nothing anyway. */
+const TASK_WAKE_TTL_MS = WAKE_TARGET_TTL_MS;
+
+/** The store key for one task's wake row. `taskId` alone is unique within the org: eve derives it
+ *  from `sha256(parentSessionId, parentTurnId, callId)`. */
+export function taskWakeKey(taskId: string): string {
+  return `${TASK_WAKE_PREFIX}${taskId}`;
+}
+
+function delegatedTaskWakeKey(parentSessionId: string, callId: string): string {
+  return `${DELEGATED_TASK_WAKE_PREFIX}${parentSessionId}:${callId}`;
+}
+
+/** Persist the one join a delayed child needs to recover its dispatch wake. Written first from
+ * actions.requested (before launch can race), then advanced to the task's own retargetable wake. */
+export async function rememberDelegatedTaskWake(
+  org: string,
+  parentSessionId: string,
+  callId: string,
+  wakeId: string,
+  // Compatibility-only call-site parameters. The durable wake row, never these turn-global values,
+  // is authoritative; callers are migrated separately without weakening this edge meanwhile.
+  _requester?: RequesterVerdict,
+  _nonMemberWake?: boolean,
+): Promise<void> {
+  if (parentSessionId.length === 0 || callId.length === 0 || wakeId.length === 0) {
+    throw new Error("delegated task wake pointer requires parent session, call, and wake ids");
+  }
+  const authority = await resolveUnifiedWakeAuthority(getOperationalStore(), org, wakeId);
+  if (authority === undefined) throw new Error("delegated task wake pointer requires exact per-wake authority");
+  await getOperationalStore().putTaskResult(
+    org,
+    delegatedTaskWakeKey(parentSessionId, callId),
+    JSON.stringify({ wakeId, requester: authority.requester, nonMemberWake: authority.nonMemberWake }),
+    new Date().toISOString(),
+    TASK_WAKE_TTL_MS,
+  );
+}
+
+/** A delegation admitted from a blank/unreadable token has no unified wake id. Persist its dispatch
+ * binding directly under the same parent/call authority row, so that fail-open degradation does not
+ * turn into either a misbound child or a blanket no-row abort. Ordinary native seats cannot delegate. */
+export async function rememberDelegatedTaskBinding(
+  org: string,
+  parentSessionId: string,
+  callId: string,
+  binding: SurfaceBinding,
+  requester: RequesterVerdict,
+  nonMemberWake: boolean,
+): Promise<void> {
+  if (parentSessionId.length === 0 || callId.length === 0 || !isWakeSurfaceBinding(binding) || binding.org !== org || !isRequesterVerdict(requester)) {
+    throw new Error("delegated task binding pointer requires a valid parent, call, and binding");
+  }
+  await getOperationalStore().putTaskResult(
+    org,
+    delegatedTaskWakeKey(parentSessionId, callId),
+    JSON.stringify({ binding, requester, nonMemberWake }),
+    new Date().toISOString(),
+    TASK_WAKE_TTL_MS,
+  );
+}
+
+type DelegatedTaskAuthority = ({ readonly wakeId: string } | { readonly binding: SurfaceBinding }) & { readonly requester: RequesterVerdict; readonly nonMemberWake: boolean };
+
+async function readDelegatedTaskAuthority(org: string, parentSessionId: string, callId: string): Promise<DelegatedTaskAuthority | undefined> {
+  try {
+    if (parentSessionId.length === 0 || callId.length === 0) return undefined;
+    const raw = await getOperationalStore().getTaskResult(org, delegatedTaskWakeKey(parentSessionId, callId));
+    if (raw === null) return undefined;
+    const parsed = JSON.parse(raw) as { wakeId?: unknown; binding?: unknown; requester?: unknown; nonMemberWake?: unknown } | null;
+    if (!isRequesterVerdict(parsed?.requester) || typeof parsed?.nonMemberWake !== "boolean") return undefined;
+    if (typeof parsed?.wakeId === "string" && parsed.wakeId.length > 0) return { wakeId: parsed.wakeId, requester: parsed.requester, nonMemberWake: parsed.nonMemberWake };
+    if (isWakeSurfaceBinding(parsed?.binding) && parsed.binding.org === org) return { binding: parsed.binding, requester: parsed.requester, nonMemberWake: parsed.nonMemberWake };
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export interface ResolvedDelegatedTaskAuthority extends ResolvedUnifiedWakeAuthority {
+  readonly wakeId: string;
+}
+
+/** Resolve a child back to the exact host-frozen wake that launched it. Parent session + call id
+ * come from Eve's child linkage; current child auth is deliberately ignored. Binding-only native
+ * degradation and legacy/malformed rows return undefined because they cannot identify a unified
+ * conversational destination for a host continuation such as an approval notice. */
+export async function resolveDelegatedTaskAuthority(ctx: BindableContext): Promise<ResolvedDelegatedTaskAuthority | undefined> {
+  if (!isSubagentChildContext(ctx)) return undefined;
+  const parentSessionId = subagentParentSessionId(ctx);
+  const callId = ctx.session?.parent?.callId;
+  if (parentSessionId === undefined || typeof callId !== "string" || callId.length === 0) return undefined;
+  const org = deploymentOrg();
+  const pointer = await readDelegatedTaskAuthority(org, parentSessionId, callId);
+  if (pointer === undefined || !("wakeId" in pointer)) return undefined;
+  const authority = await resolveUnifiedWakeAuthority(getOperationalStore(), org, pointer.wakeId);
+  if (
+    authority === undefined ||
+    JSON.stringify(authority.requester) !== JSON.stringify(pointer.requester) ||
+    authority.nonMemberWake !== pointer.nonMemberWake
+  ) return undefined;
+  return { wakeId: pointer.wakeId, ...authority };
+}
+
+/** The exact pre-launch wake authority written by actions.requested for this parent call. */
+export async function delegatedTaskDispatchAuthority(
+  org: string,
+  parentSessionId: string,
+  callId: string,
+): Promise<SettlementDispatchAuthority | undefined> {
+  const pointer = await readDelegatedTaskAuthority(org, parentSessionId, callId);
+  if (pointer === undefined || !("wakeId" in pointer)) return undefined;
+  const authority = await resolveUnifiedWakeAuthority(getOperationalStore(), org, pointer.wakeId);
+  if (
+    authority === undefined ||
+    JSON.stringify(authority.requester) !== JSON.stringify(pointer.requester) ||
+    authority.nonMemberWake !== pointer.nonMemberWake
+  ) return undefined;
+  return { wakeId: pointer.wakeId, requester: authority.requester, nonMemberWake: authority.nonMemberWake };
+}
+
+/** Advance the pre-launch pointer to the task wake without re-reading mutable parent auth. */
+export async function advanceDelegatedTaskWake(
+  org: string,
+  parentSessionId: string,
+  callId: string,
+  taskId: string,
+  wakeId: string,
+  expected: SettlementDispatchAuthority,
+): Promise<void> {
+  const authority = await readDelegatedTaskAuthority(org, parentSessionId, callId);
+  if (
+    authority === undefined ||
+    !("wakeId" in authority) ||
+    JSON.stringify({ wakeId: authority.wakeId, requester: authority.requester, nonMemberWake: authority.nonMemberWake }) !== JSON.stringify(expected)
+  ) {
+    throw new Error("delegated task authority changed before receipt");
+  }
+  await rememberDelegatedTaskWake(org, parentSessionId, callId, wakeId, authority.requester, authority.nonMemberWake);
+  await getOperationalStore().putTaskResult(
+    org,
+    taskWakeKey(taskId),
+    JSON.stringify({ wakeId, parentSessionId, callId, requester: authority.requester, nonMemberWake: authority.nonMemberWake }),
+    new Date().toISOString(),
+    TASK_WAKE_TTL_MS,
+  );
+}
+
+/** Restore a delayed child's dispatch binding at session start and pin it to its opening turn. */
+async function restoreDelegatedTaskBinding(input: {
+  readonly org: string;
+  readonly parentSessionId: string;
+  readonly callId: string;
+  readonly turnId: string | undefined;
+}): Promise<"adopted" | "already" | "no-row" | "no-binding"> {
+  if (delegatedBindingAdopted()) {
+    // session.started installs without a turn id; turn.started attaches that same snapshot to turn 0.
+    pinDelegatedBindingToTurn(input.turnId);
+    return "already";
+  }
+  const authority = await readDelegatedTaskAuthority(input.org, input.parentSessionId, input.callId);
+  if (authority === undefined) return "no-row";
+  const resolved = "wakeId" in authority ? await resolveUnifiedWakeAuthority(getOperationalStore(), input.org, authority.wakeId) : undefined;
+  if (
+    resolved !== undefined &&
+    (JSON.stringify(resolved.requester) !== JSON.stringify(authority.requester) || resolved.nonMemberWake !== authority.nonMemberWake)
+  ) return "no-binding";
+  const binding = "binding" in authority ? authority.binding : resolved?.binding;
+  if (binding === undefined) return "no-binding";
+  // OPE-2133 — the wake rides into the child's slot beside the binding, because this edge is the
+  // only one that holds the parent/call linkage the row is keyed on. See {@link delegatedWakeThisTurn}.
+  const snapshot: DelegatedDispatchAuthority = {
+    binding,
+    requester: authority.requester,
+    nonMemberWake: authority.nonMemberWake,
+    ...("wakeId" in authority ? { wakeId: authority.wakeId } : {}),
+  };
+  return adoptDelegatedAuthority(snapshot, input.turnId) ? "adopted" : "no-binding";
+}
+
+export class DelegatedTaskBindingUnavailableError extends Error {
+  readonly outcome: "no-row" | "no-binding";
+
+  constructor(outcome: "no-row" | "no-binding") {
+    super(`delegated task binding unavailable: ${outcome}`);
+    this.name = "DelegatedTaskBindingUnavailableError";
+    this.outcome = outcome;
+  }
+}
+
+/** Context-shaped wrapper used at every lifecycle edge that must resolve access before the generic
+ * binding hook has necessarily run. Eve gives no ordering guarantee between hook files. */
+export async function ensureDelegatedTaskBinding(ctx: BindableContext): Promise<void> {
+  if (!isSubagentChildContext(ctx)) return;
+  const parentSessionId = subagentParentSessionId(ctx);
+  const callId = ctx.session?.parent?.callId;
+  if (parentSessionId === undefined || typeof callId !== "string" || callId.length === 0) return;
+  const outcome = await restoreDelegatedTaskBinding({ org: deploymentOrg(), parentSessionId, callId, turnId: currentTurnId(ctx) });
+  // A child with host parent/call linkage is a native delegation. Missing durable authority is not
+  // a license to use whichever surface currently occupies the standing seat. Pre-upgrade queued
+  // children therefore fail closed and can be retried from the originating conversation.
+  if (outcome === "no-row" || outcome === "no-binding") throw new DelegatedTaskBindingUnavailableError(outcome);
+}
+
+/**
+ * DISPATCH EDGE — mint and register the wake identity one background task will settle under. It returns the minted wake id, or `null` when there is nothing to mint against, which is not an error: a session with no wake origin has no conversation for the settlement to answer into either.
+ * THE ORIGIN IS COPIED FROM THE DISPATCHING WAKE, never invented, because the task's answer belongs in the conversation that ASKED for it — which is what makes it right on a multi-thread seat, where the wake that runs last is a different conversation. The window token is copied for the cross-domain fence. Never throws: a hook edge may not fail because a store blipped.
+ */
+export async function openTaskWake(input: {
+  readonly org: string;
+  readonly taskId: string;
+  /**
+   * The wake whose conversation the answer owes: either the wake the dispatching turn already
+   * addressed or its one positively identified delivered wake. Ambiguous/missing authority never
+   * reaches this function from the delegation hook.
+   */
+  readonly parentWakeId: string | undefined;
+  /** `resolveOwnWindowToken` — the dispatching seat's own bare window token. */
+  readonly windowToken: string | undefined;
+}): Promise<string | null> {
+  try {
+    if (input.taskId.length === 0) return null;
+    if (input.parentWakeId === undefined || input.parentWakeId.length === 0) return null;
+    const store = getOperationalStore();
+    const origin = await resolveUnifiedWakeTarget(store, input.org, input.parentWakeId);
+    if (origin === null) return null;
+    const authority = await resolveUnifiedWakeAuthority(store, input.org, input.parentWakeId);
+    const frozenAuthority = authority === undefined
+      ? undefined
+      : { binding: authority.binding, requester: authority.requester, nonMemberWake: authority.nonMemberWake };
+    const binding = authority?.binding ?? await resolveUnifiedWakeBinding(store, input.org, input.parentWakeId);
+    const surfaceKey = authority?.surfaceKey ?? await resolveUnifiedWakeSurfaceKey(store, input.org, input.parentWakeId);
+    const wakeId = mintWakeId();
+    const at = new Date().toISOString();
+    // ORDER IS LOAD-BEARING, the same order and the same reason as the unified receive hook: the wakeId-to-origin row must exist before anything can answer under the id.
+    // The taskId-to-wakeId row is the pointer TO that row, so it goes second — a crash between the two leaves an unreferenced and harmless origin row, never a pointer to an address that resolves to nothing.
+    await registerUnifiedWakeTarget(store, input.org, wakeId, origin, at, input.windowToken, undefined, undefined, surfaceKey, binding, frozenAuthority);
+    await store.putTaskResult(input.org, taskWakeKey(input.taskId), JSON.stringify({ wakeId }), at, TASK_WAKE_TTL_MS);
+    return wakeId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * RE-POINT the tasks a turn dispatched at the conversation that turn ADDRESSED. The dispatch edge alone is not enough: a turn that merged queued deliveries carries only the LAST delivery's auth, so a task dispatched for a SIBLING conversation is registered against the wrong one.
+ * 🔴 THAT MERGE IS UNREACHABLE ON eve 0.54.3, AND THE RE-POINT STAYS ANYWAY (OPE-2042). eve batches adjacent queued deliveries only when their full auth contexts match, and OE stamps a fresh per-delivery `oe_delivery_id` into `auth.attributes`, so two auth-carrying deliveries on one unified window never compare equal. Only the caller-less task COMPLETION COHORT still folds, and it carries no `auth` at all. But the turn's ctx names the wrong conversation WITHOUT any merge too: a turn woken by an INTERNAL wake — an approval decision, a completion — answers a conversation whose envelope is in the seat's shared context, through the reply fence's same-conversation and pending arms. Measured in production on 2026-08-15 (`docs/glossary.md`). So this is LOAD-BEARING, not defensive. `scripts/coalesced-delivery-merge-assumption-test.ts` pins the MERGE road alone.
+ * `addressedWakeId` has already passed the reply fence, and the origin is COPIED from it, never invented. Idempotent and cheap on the common path — a task already registered against that conversation is skipped, so a turn woken by one conversation writes nothing at all. Never throws: a reply that has already posted may not fail because a store blipped.
+ */
+export async function retargetTaskWakes(input: {
+  readonly org: string;
+  readonly tasks: readonly DispatchedTaskWake[];
+  /** The wake the turn addressed — the reply fence's own admitted `wake` argument. */
+  readonly addressedWakeId: string;
+  /** `resolveOwnWindowToken` — re-stamped onto the moved row, so the cross-domain fence still holds. */
+  readonly windowToken: string | undefined;
+  /** The turn that addressed it, for the audit join. */
+  readonly turnId: string | undefined;
+}): Promise<number> {
+  try {
+    if (input.tasks.length === 0) return 0;
+    if (input.addressedWakeId.length === 0) return 0;
+    const store = getOperationalStore();
+    const origin = await resolveUnifiedWakeTarget(store, input.org, input.addressedWakeId);
+    if (origin === null) return 0; // an unresolvable address is never a reason to move an answer
+    const addressedAuthority = await resolveUnifiedWakeAuthority(store, input.org, input.addressedWakeId);
+    const frozenAddressedAuthority = addressedAuthority === undefined
+      ? undefined
+      : { binding: addressedAuthority.binding, requester: addressedAuthority.requester, nonMemberWake: addressedAuthority.nonMemberWake };
+    const addressedBinding = addressedAuthority?.binding ?? await resolveUnifiedWakeBinding(store, input.org, input.addressedWakeId);
+    const addressedSurfaceKey = addressedAuthority?.surfaceKey ?? await resolveUnifiedWakeSurfaceKey(store, input.org, input.addressedWakeId);
+    let moved = 0;
+    for (const task of input.tasks) {
+      const current = await resolveUnifiedWakeTarget(store, input.org, task.wakeId);
+      const currentBinding = await resolveUnifiedWakeBinding(store, input.org, task.wakeId);
+      // 🔴 THE CONVERSATION TEST IS NOT A PLACEMENT TEST (OPE-1827). Skipping on
+      // `sameUnifiedConversation` alone was wrong on exactly the surfaces whose placement sits
+      // OUTSIDE the identity: on Slack a top-level wake's thread key IS its channel id, so two
+      // top-level wakes in one channel compare EQUAL while naming two different messages to hang
+      // under — and the skip then kept the stale anchor the dispatching turn happened to be carrying.
+      // What the turn ADDRESSED is the authority here (the whole reason this function exists), so a
+      // row that agrees on the conversation but not on the placement is re-pointed like any other.
+      // The write is still skipped when both axes already agree, which is every single-wake turn —
+      // the common path costs one read and nothing else.
+      if (
+        current !== null &&
+        sameUnifiedConversation(current, origin) &&
+        sameUnifiedPlacement(current, origin) &&
+        JSON.stringify(currentBinding) === JSON.stringify(addressedBinding)
+      )
+        continue;
+      const at = new Date().toISOString();
+      // 🔴 AND A CARRY, NEVER A MOVE (OPE-1826). Where the addressed wake names NO placement of its
+      // own — a routine fire, a webhook post-back, a surface that keeps placement inside its thread
+      // key — the row keeps the one it already had rather than losing it to a blank. `origin` is the
+      // target because the addressed wake decides the conversation; `withCarriedPlacement` is what
+      // stops the re-point from flattening a placed answer onto the bare container. Core re-validates
+      // the arm's result and re-tests the conversation, so a provider arm can fill a gap and can
+      // never move the post.
+      // 🔴 ONLY WITHIN ONE CONVERSATION. The conversation test is what makes the carry safe, and it
+      // is checked HERE rather than left to `withCarriedPlacement`: that function re-tests the
+      // carried origin against its own TARGET, and a placement is deliberately outside the identity,
+      // so a Slack anchor lifted out of a DIFFERENT channel would pass its test and hang this answer
+      // under a message id that room never saw. A re-point across conversations therefore takes the
+      // addressed origin exactly as the turn named it, placement and all.
+      const next = current !== null && sameUnifiedConversation(current, origin) ? withCarriedPlacement(origin, current) : origin;
+      await registerUnifiedWakeTarget(
+        store,
+        input.org,
+        task.wakeId,
+        next,
+        at,
+        input.windowToken,
+        undefined,
+        undefined,
+        addressedSurfaceKey,
+        addressedBinding,
+        frozenAddressedAuthority,
+      );
+      moved++;
+      void appendAudit({
+        org: input.org,
+        platform: "unified",
+        workspace: "delegation",
+        action: TASK_WAKE_RETARGET_ACTION,
+        detail: {
+          task: task.taskId,
+          wakeId: task.wakeId,
+          addressedWakeId: input.addressedWakeId,
+          originPlatform: origin.platform,
+          ...(input.turnId !== undefined && input.turnId.length > 0 ? { turnId: input.turnId } : {}),
+        },
+      }).catch(() => undefined);
+    }
+    return moved;
+  } catch (err) {
+    // A failed re-point leaves the task on the coalesced sibling wake — the OPE-601 defect
+    // itself — so it must be as countable as a successful move (the header's audit-row bound).
+    console.error(`retargetTaskWakes failed (org=${input.org}, addressedWake=${input.addressedWakeId}): ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
+
+/** One task wake row. Older deployments wrote only `wakeId`; that remains enough for reply routing. */
+type TaskWakeRecord = {
+  readonly wakeId: string;
+  readonly parentSessionId?: string;
+  readonly callId?: string;
+  readonly authority?: SettlementDispatchAuthority;
+};
+
+async function taskWakeRecord(org: string, taskId: string): Promise<TaskWakeRecord | undefined> {
+  try {
+    if (taskId.length === 0) return undefined;
+    const raw = await getOperationalStore().getTaskResult(org, taskWakeKey(taskId));
+    if (raw === null) return undefined;
+    const parsed = JSON.parse(raw) as { wakeId?: unknown; parentSessionId?: unknown; callId?: unknown; requester?: unknown; nonMemberWake?: unknown } | null;
+    const wakeId = parsed?.wakeId;
+    if (typeof wakeId !== "string" || wakeId.length === 0) return undefined;
+    const parentSessionId = typeof parsed?.parentSessionId === "string" && parsed.parentSessionId.length > 0 ? parsed.parentSessionId : undefined;
+    const callId = typeof parsed?.callId === "string" && parsed.callId.length > 0 ? parsed.callId : undefined;
+    const pointerAuthority =
+      parentSessionId !== undefined && callId !== undefined
+        ? await delegatedTaskDispatchAuthority(org, parentSessionId, callId)
+        : undefined;
+    const authority =
+      pointerAuthority !== undefined &&
+      pointerAuthority.wakeId === wakeId &&
+      isRequesterVerdict(parsed?.requester) &&
+      typeof parsed?.nonMemberWake === "boolean" &&
+      JSON.stringify(pointerAuthority.requester) === JSON.stringify(parsed.requester) &&
+      pointerAuthority.nonMemberWake === parsed.nonMemberWake
+        ? pointerAuthority
+        : undefined;
+    return {
+      wakeId,
+      ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+      ...(callId !== undefined ? { callId } : {}),
+      ...(authority !== undefined && parentSessionId !== undefined && callId !== undefined ? { authority } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+/** Read one task's minted wake id back, or `undefined` for an absent, malformed or unreadable row. */
+export async function taskWakeId(org: string, taskId: string): Promise<string | undefined> {
+  return (await taskWakeRecord(org, taskId))?.wakeId;
+}
+
+/** What {@link installTaskWake} did, so the caller (and the test) can assert on it rather than on a
+ *  log line. `outcome` is also the audit row's own verdict field. */
+export type TaskWakeInstall = {
+  /** `installed` — the turn now answers under `wakeId`. `no-row` — nothing was minted for this task
+   *  (a dispatch that predates this leg, an expired row, a seat with no wake origin). `no-turn` —
+   *  the eve turn id was unreadable, so no identity could be scoped to a turn. `already` — an
+   *  earlier settlement in the SAME turn already named it. `ingressed` — this turn brought a
+   *  delivery of its own, so its own wake stamp stands (see below). */
+  readonly outcome: "installed" | "already" | "no-row" | "no-turn" | "ingressed" | "wrong-session";
+  readonly wakeId: string | null;
+  /** Present only when the task row also holds the frozen pre-launch requester/member authority. */
+  readonly dispatchAuthority?: SettlementDispatchAuthority;
+};
+
+/**
+ * SETTLEMENT EDGE — name this turn with the task's own wake identity, and write the wake row. ONLY ON AN UNINGRESSED TURN: a terminal task view is not proof a task WOKE this turn, and installing on a turn that brought its own delivery would send a human's answer to the task's thread, which is the defect in reverse. The fence answers `false` for everything it cannot prove.
+ * The audit row is written on EVERY outcome, misses included: a settlement that could not find its wake row is exactly the case where the turn is still running under a stale address, so it must be the loudest thing in the log rather than a silent fall-through. Never throws.
+ */
+export async function installTaskWake(input: {
+  readonly org: string;
+  readonly taskId: string;
+  readonly status: string;
+  readonly sessionId: string;
+  /** `currentTurnId` — the turn the identity is scoped to. Unreadable ⇒ `no-turn`. */
+  readonly turnId: string | undefined;
+  /** {@link currentWakeId}'s answer BEFORE the install — the stale id the turn would otherwise
+   *  reply under. Recorded so the defect is countable after the fix, not only before it. */
+  readonly inheritedWakeId: string | undefined;
+  /** Injected so the whole function is drivable from a unit test with no eve context. Defaults to
+   *  the real per-turn slot. */
+  readonly adopt?: (turnId: string | undefined, taskId: string, wakeId: string) => boolean;
+  /** Injected for the same reason. Defaults to the real turn-boundary record. */
+  readonly uningressed?: (turnId: string | undefined) => boolean;
+}): Promise<TaskWakeInstall> {
+  let result: TaskWakeInstall = { outcome: "no-row", wakeId: null };
+  try {
+    const record = await taskWakeRecord(input.org, input.taskId);
+    const wakeId = record?.wakeId;
+    if (record === undefined || wakeId === undefined) {
+      result = { outcome: "no-row", wakeId: null };
+    } else if (input.turnId === undefined || input.turnId.length === 0) {
+      result = { outcome: "no-turn", wakeId };
+    } else if (!(input.uningressed ?? uningressedTurn)(input.turnId)) {
+      result = { outcome: "ingressed", wakeId };
+    } else if (record.parentSessionId !== undefined && record.parentSessionId !== input.sessionId) {
+      result = { outcome: "wrong-session", wakeId };
+    } else {
+      const adopt = input.adopt ?? adoptTaskWakeThisTurn;
+      result = {
+        outcome: adopt(input.turnId, input.taskId, wakeId) ? "installed" : "already",
+        wakeId,
+        ...(record.authority !== undefined ? { dispatchAuthority: record.authority } : {}),
+      };
+    }
+  } catch {
+    result = { outcome: "no-row", wakeId: null };
+  }
+  void appendAudit({
+    org: input.org,
+    // `unified` because this IS a wake row on the single-window plane — it joins to the ingress
+    // lines the other wake classes write. Ids and the verdict only; the notification text is
+    // framework-authored and carries nothing worth recording.
+    platform: "unified",
+    workspace: "delegation",
+    action: TASK_WAKE_ACTION,
+    detail: {
+      task: input.taskId,
+      status: input.status,
+      outcome: result.outcome,
+      wakeId: result.wakeId,
+      inheritedWakeId: input.inheritedWakeId ?? null,
+      ...(input.sessionId.length > 0 ? { sessionId: input.sessionId } : {}),
+      ...(input.turnId !== undefined && input.turnId.length > 0 ? { turnId: input.turnId } : {}),
+    },
+  }).catch(() => undefined);
+  return result;
+}

package/agent/channels/teams-bridge.ts

@@ -0,0 +1,85 @@
+// teams-bridge — the registration seam for the two Teams probes core's routine fire-eligibility leg needs. Core owns the seam and the default; registerTeamsProvider() supplies the live Microsoft Graph arms at boot.
+// The default is "CANNOT CHECK", never "confirmed no": fire-eligibility reads `undefined` and `false` as different answers and only `false` skips a fire, so an unregistered bridge must read unresolvable rather than fabricate a "removed" or "inactive".
+
+import { processRegistrySlot } from "../lib/process-registry.js";
+
+/**
+ * Why a room-membership probe could not answer. A CLOSED set, and every member of it is a
+ * FAIL-OPEN arm — the fire proceeds — so the set is what makes one fail-open distinguishable from
+ * another in the audit trail (OPE-1810). Before it, a Graph 403 and a roster the page bound could
+ * not finish reached the dispatcher as the same `undefined`, and neither was legible at all.
+ */
+export type TeamsMembershipUnresolved =
+  /** No Teams provider is booted, so the bridge holds no Graph arm to ask with. */
+  | "no_provider"
+  /** A team, channel or creator id was empty — nothing to ask about. */
+  | "missing_ids"
+  /** The Bot Connector could not give this team's Microsoft 365 group id, which every Graph
+   *  `/teams/{team-id}/…` URL takes (channels/teams-graph-team-id.ts). */
+  | "team_id_unresolved"
+  /** The Graph read itself failed — a network error, a 5xx, or a 401/403 for a permission the
+   *  install does not hold. THE ONE ARM Tommy's 2026-09-13 ruling keeps fail-open by intent. */
+  | "read_error"
+  /** Graph answered, and the body was not a member page — an unrecognised shape is never read as
+   *  "confirmed nobody is in this channel". */
+  | "malformed_response"
+  /** The pagination bound was reached with roster left unseen, so "not found yet" is not the same
+   *  fact as "scanned the whole roster and they are not in it". */
+  | "roster_incomplete";
+
+/**
+ * One room-membership answer. `member: true`/`false` are CONFIRMED facts and both BIND: a confirmed
+ * `false` skips the fire, exactly as the Slack leg's own confirmed `false` does. `member: undefined`
+ * is the fail-open arm and it always names WHY.
+ */
+export type TeamsRoomMembership =
+  | { readonly member: boolean }
+  | { readonly member: undefined; readonly unresolved: TeamsMembershipUnresolved };
+
+/** Is `aadObjectId` CURRENTLY a member of the Teams channel `channelId` (inside team `teamId`)?
+ *  `teamId` is the activity's own BOT CONNECTOR team id (`19:…@thread.tacv2`); the provider arm
+ *  resolves it into the Graph group id, and `serviceUrl` is the Connector endpoint that resolution
+ *  is addressed to. An unresolved answer names its cause — it is never a "no". */
+export type TeamsRoomMembershipCheck = (
+  teamId: string,
+  channelId: string,
+  aadObjectId: string,
+  serviceUrl: string | undefined,
+) => Promise<TeamsRoomMembership>;
+
+/** Is `aadObjectId`'s Entra account CURRENTLY enabled? `undefined` = the probe could not answer. */
+export type TeamsAccountActiveCheck = (aadObjectId: string) => Promise<boolean | undefined>;
+
+/** Everything the fire-eligibility leg consumes from the Teams provider's Graph client. */
+export interface TeamsBridge {
+  readonly roomMembership: TeamsRoomMembershipCheck;
+  readonly accountActive: TeamsAccountActiveCheck;
+}
+
+// PROCESS-GLOBAL slot (mirrors slack-bridge.ts's OPE-406 note): registerTeamsProvider() writes from
+// one module identity while core reads from another (dist-vs-src in-repo) is a real failure mode for
+// this repo's dual module resolution, so the slot is keyed the same way slack's is.
+const bridgeSlot = processRegistrySlot<TeamsBridge>("teams-bridge.v1");
+
+/** Register (or replace) the Teams bridge. Called once from registerTeamsProvider() at boot. */
+export function registerTeamsBridge(b: TeamsBridge): void {
+  bridgeSlot.set(b);
+}
+
+export function _resetTeamsBridgeForTest(): void {
+  bridgeSlot.set(null);
+}
+
+export function teamsBridge(): TeamsBridge | null {
+  return bridgeSlot.get();
+}
+
+/** Unregistered ⇒ unresolvable (never a fabricated "removed") — see the header. */
+export const bridgeTeamsRoomMembership: TeamsRoomMembershipCheck = async (teamId, channelId, aadObjectId, serviceUrl) => {
+  const b = bridgeSlot.get();
+  return b ? b.roomMembership(teamId, channelId, aadObjectId, serviceUrl) : { member: undefined, unresolved: "no_provider" };
+};
+
+/** Unregistered ⇒ unresolvable (never a fabricated "inactive") — see the header. */
+export const bridgeTeamsAccountActive: TeamsAccountActiveCheck = async (aadObjectId) =>
+  bridgeSlot.get() ? bridgeSlot.get()!.accountActive(aadObjectId) : undefined;

package/agent/channels/test-wake.ts

@@ -0,0 +1,12 @@
+// Deployment mount for `POST /control/v1/test/wake`; the behaviour lives in control/test-route.ts.
+// Triple-gated and fail-closed; test-route.ts is the authority. Gate 1 404s unless OE_TEST_WAKE is truthy AND the OE_CONTROL_INJECT_TOKENS family is configured. Gate 2 refuses 401 on a missing or non-matching bearer — a read token included, with no fallback between the two families.
+// Gate 3 refuses 400 unless a standing window is enabled for the claimed surface and the origin is well-formed. So an unauthenticated probe reads 404 only while gate 1 is shut; once an operator arms both halves, the 401 discloses that the seam exists.
+
+import { defineChannel, POST } from "eve/channels";
+import { CONTROL_TEST_WAKE_PATH, handleTestWakeInjection } from "../control/test-route.js";
+
+export default defineChannel({
+  routes: [
+    POST(CONTROL_TEST_WAKE_PATH, async (req, { to }) => handleTestWakeInjection(req, to)),
+  ],
+});