@ziggs-ai/agent-sdk 0.42.0 → 0.43.0

package/dist/platform/inboxLoop.js

@@ -1,9 +1,8 @@
+import { prepareWorkExecution } from '@ziggs-ai/api-client';
 import { deliveryHandlingId, withWorkExecution } from '@ziggs-ai/api-client';
-import { ContextReadClient, InboxClient, planInboxAck, planPartialInboxAck, } from '@ziggs-ai/api-client';
+import { MessageRecordsClient, InboxClient, planInboxAck, planPartialInboxAck, } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { isRateLimited } from '@ziggs-ai/api-client';
-import { isPublishProbeChat } from '../probeChat.js';
-const READ_PAGE = 100;
 function log(label, msg) {
     runtimeLog.info(label, msg);
 }
@@ -26,21 +25,6 @@ async function releaseInboxHostBestEffort(deps) {
 function warn(label, msg) {
     runtimeLog.warn(label, msg);
 }
-/**
- * A capability probe waits on a `probe_*` chat reply, not inbox ack. Act
- * those rooms before leftover mail so a standing host answers the gate
- * even when the envelope also carries older chats. The prefix only orders
- * the wake — it does not buy a canned answer.
- */
-export function chatsInWakeOrder(chats) {
-    return [...chats].sort((a, b) => {
-        const ap = isPublishProbeChat(a.chatId) ? 0 : 1;
-        const bp = isPublishProbeChat(b.chatId) ? 0 : 1;
-        if (ap !== bp)
-            return ap - bp;
-        return a.latestAt < b.latestAt ? 1 : -1;
-    });
-}
 /**
  * Standing proposals share the merged inbox visibility model with deliveries,
  * but older envelopes predate an explicit assignee stamp. Prefer the server's
@@ -55,84 +39,41 @@ function proposalIsMine(proposal, ownAgentId) {
     return (proposal.pendingApprovalPartyIds?.includes(ownAgentId) === true ||
         proposal.proposedTo === ownAgentId);
 }
-/**
- * Read the messages behind one chat's deliveries and hand them to the host.
- *
- * The envelope names exact assigned message ids, not their bodies — so this still
- * reads through `/context/read`, where the agent's own grants fence what it is
- * allowed to see. A delivery reference is an address, never an authorisation.
- */
-async function deliverMessagesForChat(deps, news, refs, reader, attempt, handledIds) {
-    const pending = new Map(refs.map(ref => [ref.resourceId, ref]));
-    for (const id of pending.keys()) {
-        if (deps.seen.has(deliveryHandlingId(pending.get(id)))) {
-            handledIds.add(deliveryHandlingId(pending.get(id)));
-            pending.delete(id);
-        }
+/** Read exact assigned records. Historical lookup is optional context, never handoff. */
+async function deliverAssignedMessage(deps, ref, reader, attempt, handledIds) {
+    // A pending answer comes from its message owner, not from a delivery, so it
+    // has no receipt to settle. Its eventId still names that exact slot, which
+    // is enough to avoid a second wake for it.
+    const receiptId = ref.receiptId ? deliveryHandlingId(ref) : undefined;
+    const key = receiptId ?? ref.eventId;
+    if (deps.seen.has(key)) {
+        if (receiptId)
+            handledIds.add(receiptId);
+        return false;
     }
-    if (!pending.size)
-        return 0;
-    let delivered = 0;
-    const earliest = refs.map(ref => ref.ts).sort()[0];
-    let after = new Date(Date.parse(earliest) - 1).toISOString();
-    let cursor;
-    for (let pages = 0; pending.size && pages < 100; pages++) {
-        let page;
-        try {
-            page = await reader.read('messages', {
-                via: `chat:${news.chatId}`, after, direction: 'forward', limit: READ_PAGE,
-                ...(cursor ? { cursor } : {}),
-            });
-        }
-        catch (err) {
-            const status = err.status;
-            if (status !== 403 && status !== 404)
-                throw err;
-            // This read explicitly establishes that these deliveries are inaccessible.
-            // The server also excludes out-of-reach rows from its acknowledgment guard.
-            // A context refusal (including changed audience) must be retried, never acknowledged as read.
-            if (refs.some(ref => ref.executionContext))
-                throw err;
-            for (const id of pending.keys())
-                handledIds.add(id);
-            return delivered;
-        }
-        for (const row of page.items) {
-            const id = String(row.messageId ?? '');
-            const ref = pending.get(id);
-            if (!ref)
-                continue;
-            const handled = await attempt(`chat ${news.chatId} message ${id}`, () => deps.onMessage(typeof row.text === 'string' ? row.text : '', {
-                ...row,
-                chatId: news.chatId,
-                // Preserve the message's addressee. Assignment separately authorizes
-                // this carrier to handle it, including a person's stand-in.
-                assigneeId: deps.ownAgentId,
-                ...(ref.responsibilityId ? { responsibilityId: ref.responsibilityId, executionContext: ref.executionContext } : {}),
+    const handled = await attempt(`message ${ref.resourceId}`, () => (async () => {
+        if (!ref.action)
+            throw new Error('Assigned message has no domain action');
+        const execution = await prepareWorkExecution(ref.action, deps.creds.operatorKey, deps.ownAgentId, deps.baseUrl);
+        return withWorkExecution(execution, async () => {
+            const row = await reader.get(ref.resourceId);
+            const metadata = { messageId: row.messageId, ...(row.mandate ?? {}),
+                sender: { id: row.sender.ref, type: row.sender.kind }, receiver: { id: deps.ownAgentId, type: 'agent' },
+                entryType: 'message', timestamp: row.timestamp, roomless: true };
+            await deps.onMessage(row.content.text, {
+                ...metadata, assigneeId: deps.ownAgentId, ...(receiptId ? { receiptId } : {}),
+                executionContext: execution,
                 ...(ref.agreementId ? { agreementId: ref.agreementId } : {}),
-            }));
-            if (handled) {
-                delivered++;
-                handledIds.add(deliveryHandlingId(ref));
-            }
-            pending.delete(id);
-        }
-        if (!page.hasMore)
-            break;
-        if (page.nextCursor && page.nextCursor !== cursor)
-            cursor = page.nextCursor;
-        else if (page.latestSequence && page.latestSequence > after) {
-            after = page.latestSequence;
-            cursor = undefined;
-        }
-        else
-            break;
-    }
-    if (pending.size)
-        await attempt(`chat ${news.chatId} missing assigned messages`, async () => {
-            throw new Error(`Assigned message(s) not read: ${[...pending.keys()].join(', ')}`);
+                ...(ref.taskId ? { taskId: ref.taskId } : {}),
+            });
         });
-    return delivered;
+    })());
+    if (handled) {
+        deps.seen.mark(key);
+        if (receiptId)
+            handledIds.add(receiptId);
+    }
+    return handled;
 }
 /**
  * One long-poll pass: hold up to `waitSeconds` for new inbox content, then read
@@ -181,7 +122,15 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // Everything else in the merged view (a sibling carrier's mail, the owner's
     // needs-human rows, granted ambient lanes) is context the host may read on
     // demand — never a wake, never mine to ack as handled.
-    const mine = (d) => d.assigneeId === deps.ownAgentId;
+    //
+    // A responsibility is its receipt: without one the server cannot settle the
+    // row, so it is not mine to act on. One such row (written by an older
+    // server) must not fail the whole pass and stop every other delivery.
+    const unreceipted = envelope.deliveries.filter(d => d.assigneeId === deps.ownAgentId && !d.receiptId);
+    if (unreceipted.length) {
+        warn(label, `${unreceipted.length} assigned deliver${unreceipted.length === 1 ? 'y has' : 'ies have'} no receiptId; skipped (${unreceipted.map(d => `${d.kind} ${d.resourceId}`).join(', ')})`);
+    }
+    const mine = (d) => d.assigneeId === deps.ownAgentId && Boolean(d.receiptId);
     // Give the mark back in steps instead of once at the end of the pass.
     //
     // A pass that acks only when it finishes freezes the watermark for its whole
@@ -205,7 +154,23 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     if (blocked) {
         log(label, `${blocked} assignment(s) cannot run yet (no access or execution refused); left pending for the server to offer again`);
     }
-    const handledSoFar = new Set();
+    if (deps.onTaskControlCheck) {
+        const blockedTasks = new Set([
+            ...envelope.deliveries.filter(d => mine(d) && d.kind === 'task-state' && d.executionBlocked && !d.outOfReach).map(d => d.resourceId),
+            ...(envelope.tasksAwaitingMe ?? []).filter(t => t.executionBlocked).map(t => t.taskId),
+        ]);
+        for (const taskId of blockedTasks) {
+            try {
+                await deps.onTaskControlCheck(taskId);
+            }
+            catch (error) {
+                warn(label, `task control observation failed for ${taskId}: ${error.message}`);
+            }
+        }
+    }
+    // A receipt with no owner action is transport-only: acknowledge observation
+    // without creating model work from an FYI.
+    const handledSoFar = new Set(envelope.deliveries.filter(d => mine(d) && d.kind !== 'request' && (!d.action || d.actionState === 'settled') && !d.outOfReach && !d.executionBlocked).map(deliveryHandlingId));
     const acknowledged = new Set();
     // A handled id the server would not settle (it lost access mid-wake) stays
     // pending there and comes back once it can run; this pass is not redone.
@@ -237,43 +202,36 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             warn(label, `mid-pass ack did not land: ${err?.message ?? err}`);
         }
     };
-    const assignedByChat = new Map();
-    for (const d of envelope.deliveries) {
-        if (d.kind !== 'message' || !d.chatId || !mine(d) || d.outOfReach || d.executionBlocked)
-            continue;
-        const groupId = d.executionContext?.contextId ?? d.chatId;
-        const rows = assignedByChat.get(groupId) ?? [];
-        rows.push(d);
-        assignedByChat.set(groupId, rows);
-    }
-    const chats = [...assignedByChat].map(([chatId, refs]) => ({
-        chatId, count: refs.length, latestAt: refs.map(ref => ref.ts).sort().at(-1),
-    }));
-    for (const group of chatsInWakeOrder(chats)) {
-        const refs = assignedByChat.get(group.chatId);
-        const news = { ...group, chatId: refs[0].chatId };
-        // Read a room's mail as that room's wake would: with the room as the lane.
-        // Without it the read is judged in the workspace the key signed in to, and
-        // a room another company opened with a listed agent is filed in theirs, so
-        // every stranger's message came back 403 and was acked unread.
-        const roomReader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
-        const n = await withWorkExecution(refs[0]?.executionContext, () => deliverMessagesForChat(deps, news, refs, roomReader, attempt, handledSoFar));
-        messagesDelivered += n;
+    // Every assigned message is fetched by resource identity. Navigation is optional.
+    const assigned = envelope.deliveries
+        .filter(d => d.kind === 'message' && !!d.action && d.action.kind !== 'task' && d.actionState !== 'settled' && d.actionState !== 'waiting' && mine(d) && !d.outOfReach && !d.executionBlocked)
+        .sort((a, b) => b.ts.localeCompare(a.ts));
+    const records = new MessageRecordsClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
+    for (const delivery of assigned) {
+        if (await deliverAssignedMessage(deps, delivery, records, attempt, handledSoFar))
+            messagesDelivered++;
         await ackWhatIsFinished();
     }
+    // Recover owner actions even after their transport receipt was acknowledged.
+    const deliveredAnswerKeys = new Set(assigned.map(delivery => JSON.stringify(delivery.action)));
+    for (const answer of envelope.answersAwaitingMe ?? []) {
+        if (!answer.action || answer.executionBlocked || answer.outOfReach || deliveredAnswerKeys.has(JSON.stringify(answer.action)))
+            continue;
+        if (await deliverAssignedMessage(deps, answer, records, attempt, new Set()))
+            messagesDelivered++;
+    }
     // Everything that is not chat text is handed over as a resource event, from
     // the delivery itself — the reference already carries the ids the host needs,
     // so nothing has to be re-derived to name what changed.
-    // Requests must never take this path — even if a pre-cut server
-    // left them in `deliveries`, skip so they cannot wake the LLM before triage.
+    // Requests have a dedicated triage path and tasks use their canonical executor.
     // Unassigned rows never take it either: waking the brain on a sibling's
     // mail is the N-wakes-per-event cost the party-owned inbox exists to kill.
     for (const d of envelope.deliveries) {
-        if (d.kind === 'message' || d.kind === 'request')
+        if (d.kind === 'message' || d.kind === 'request' || d.action?.kind === 'task')
             continue;
-        if (!mine(d) || d.executionBlocked || d.outOfReach)
+        if (!mine(d) || d.executionBlocked || d.outOfReach || !d.action || d.actionState === 'settled' || d.actionState === 'waiting')
             continue;
-        const key = d.responsibilityId ?? `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
+        const key = deliveryHandlingId(d);
         // Handled on an earlier pass — it still settles this instant, exactly as
         // it does in the end-of-pass list.
         if (deps.seen.has(key)) {
@@ -281,20 +239,24 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             continue;
         }
         deps.seen.mark(key);
-        const handled = await attempt(`${d.kind} ${d.resourceId}`, () => deps.onResourceEvent({
-            kind: d.kind,
-            ts: d.ts,
-            resourceId: d.resourceId,
-            ...(d.responsibilityId ? { responsibilityId: d.responsibilityId, executionContext: d.executionContext } : {}),
-            ...(d.chatId ? { chatId: d.chatId } : {}),
-            ...(d.agreementId ? { agreementId: d.agreementId } : {}),
-            ...(d.taskId ? { taskId: d.taskId } : {}),
-            // claim/listing wakes carry reason + claimer; host needs
-            // both for agrn lane routing, claim kickoff, and chat_open buyer id.
-            ...(d.reason != null && d.reason !== '' ? { reason: d.reason } : {}),
-            ...(d.actorId ? { actorId: d.actorId } : {}),
-            change: 'created',
-        }), () => deps.seen.unmark(key));
+        const handled = await attempt(`${d.kind} ${d.resourceId}`, async () => {
+            const executionContext = await prepareWorkExecution(d.action, deps.creds.operatorKey, deps.ownAgentId, deps.baseUrl);
+            return deps.onResourceEvent({
+                kind: d.kind,
+                ts: d.ts,
+                resourceId: d.resourceId,
+                ...(d.receiptId ? { receiptId: d.receiptId, executionContext } : {}),
+                ...(d.addressId ? { addressId: d.addressId } : {}),
+                ...(d.agreementId ? { agreementId: d.agreementId } : {}),
+                ...(d.taskId ? { taskId: d.taskId } : {}),
+                // claim/listing wakes carry reason + claimer; host needs
+                // both for agrn lane routing, claim kickoff, and chat_open buyer id.
+                ...(d.reason != null && d.reason !== '' ? { reason: d.reason } : {}),
+                ...(d.actorId ? { actorId: d.actorId } : {}),
+                change: 'created',
+                executionContext,
+            });
+        }, () => deps.seen.unmark(key));
         if (handled) {
             resourceEvents++;
             handledSoFar.add(deliveryHandlingId(d));
@@ -302,23 +264,65 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     }
     // An older row here may have been holding the mark back behind the chats.
     await ackWhatIsFinished();
-    // the work channel. An open assigned task is redelivered on every
-    // pass until it closes (that IS the durable-wait contract), so dedup on
-    // taskId+updatedAt — a genuinely touched task wakes again, an untouched one
-    // doesn't storm the lane every long-poll.
+    // One canonical task action, however many receipts announced changes to it.
+    // A receipt is acknowledged only after this action was handed to the task executor.
+    const taskActions = new Map();
     for (const task of envelope.tasksAwaitingMe ?? []) {
+        taskActions.set(task.taskId, { task, receipts: [] });
+    }
+    for (const receipt of envelope.deliveries) {
+        if (!mine(receipt) || receipt.action?.kind !== 'task' || receipt.outOfReach)
+            continue;
+        if (receipt.actionState === 'settled') {
+            // Domain state ended or reassigned this work. No model execution is needed.
+            handledSoFar.add(deliveryHandlingId(receipt));
+            continue;
+        }
+        if (receipt.executionBlocked || receipt.actionState !== 'ready')
+            continue;
+        const id = receipt.action.id;
+        const existing = taskActions.get(id);
+        const task = {
+            taskId: id, agreementId: receipt.agreementId,
+            title: existing?.task.title ?? id, state: 'active',
+            updatedAt: receipt.actionVersion ?? null,
+            executionContext: receipt.executionContext,
+        };
+        if (!existing)
+            taskActions.set(id, { task, receipts: [receipt] });
+        else {
+            existing.receipts.push(receipt);
+            // Prefer the freshest owner snapshot, not the event's source timestamp.
+            if ((task.updatedAt ?? '') >= (existing.task.updatedAt ?? ''))
+                existing.task = task;
+        }
+    }
+    for (const { task, receipts } of taskActions.values()) {
         if (task.executionBlocked)
             continue;
         const key = `task:${task.taskId}:${task.updatedAt ?? ''}:${task.executionContext?.contextId ?? ''}`;
-        if (deps.seen.has(key))
+        const receiptKeys = receipts.map(receipt => `task-receipt:${deliveryHandlingId(receipt)}`);
+        // A timestamp is not a causal sequence: a new input can share its owner's
+        // version with an earlier handoff. Only suppress receipts actually handled.
+        if (deps.seen.has(key) && receiptKeys.every(id => deps.seen.has(id))) {
+            receipts.forEach(receipt => handledSoFar.add(deliveryHandlingId(receipt)));
             continue;
-        deps.seen.mark(key);
-        if (deps.onTask) {
-            const handled = await attempt(`task ${task.taskId}`, () => withWorkExecution(task.executionContext, () => deps.onTask(task)), () => deps.seen.unmark(key));
-            if (handled)
-                tasksDelivered++;
         }
+        if (!deps.onTask)
+            continue; // Unsupported work stays pending; delivery is not completion.
+        const handled = await attempt(`task ${task.taskId}`, async () => {
+            const executionContext = await prepareWorkExecution({ kind: 'task', id: task.taskId }, deps.creds.operatorKey, deps.ownAgentId, deps.baseUrl);
+            return withWorkExecution(executionContext, () => deps.onTask({ ...task, executionContext }, receipts.map(receipt => ({ kind: receipt.kind, id: receipt.resourceId, eventId: receipt.eventId ?? receipt.receiptId }))));
+        });
+        if (handled) {
+            deps.seen.mark(key);
+            receiptKeys.forEach(id => deps.seen.mark(id));
+            tasksDelivered++;
+            receipts.forEach(receipt => handledSoFar.add(deliveryHandlingId(receipt)));
+        }
+        await ackWhatIsFinished();
     }
+    await ackWhatIsFinished();
     if (envelope.truncatedTasks) {
         warn(label, `inbox truncatedTasks=${envelope.truncatedTasks} (more assigned tasks than one pass surfaces — they appear as earlier ones close)`);
     }
@@ -327,7 +331,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     for (const request of envelope.openRequestsAwaitingMe ?? []) {
         const key = `request:${request.agreementId}:${request.ts}`;
         if (deps.seen.has(key)) {
-            handledSoFar.add(request.responsibilityId);
+            handledSoFar.add(request.receiptId);
             continue;
         }
         deps.seen.mark(key);
@@ -335,14 +339,14 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             const handled = await attempt(`request ${request.agreementId}`, () => deps.onRequest(request), () => deps.seen.unmark(key));
             if (handled) {
                 requestsTriaged++;
-                handledSoFar.add(request.responsibilityId);
+                handledSoFar.add(request.receiptId);
             }
         }
         else {
             // No handler → still count as handled (ack) so an old host cannot wedge
             // forever on request mail it does not understand.
             requestsTriaged++;
-            handledSoFar.add(request.responsibilityId);
+            handledSoFar.add(request.receiptId);
         }
     }
     // Pending decisions are standing state, not deliveries: they keep appearing
@@ -359,15 +363,18 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         if (deps.seen.has(key))
             continue;
         deps.seen.mark(key);
-        const handled = await attempt(`pending proposal ${proposal.agreementId}`, () => deps.onResourceEvent({
-            kind: 'agreement',
-            ts: proposal.proposedAt ?? new Date().toISOString(),
-            resourceId: proposal.agreementId,
-            agreementId: proposal.agreementId,
-            change: 'created',
-            reason: 'proposal_pending',
-            ...(proposal.executionContext ? { executionContext: proposal.executionContext } : {}),
-        }), () => deps.seen.unmark(key));
+        const handled = await attempt(`pending proposal ${proposal.agreementId}`, async () => {
+            const executionContext = await prepareWorkExecution({ kind: 'agreement', id: proposal.agreementId }, deps.creds.operatorKey, deps.ownAgentId, deps.baseUrl);
+            return deps.onResourceEvent({
+                kind: 'agreement',
+                ts: proposal.proposedAt ?? new Date().toISOString(),
+                resourceId: proposal.agreementId,
+                agreementId: proposal.agreementId,
+                change: 'created',
+                reason: 'proposal_pending',
+                executionContext,
+            });
+        }, () => deps.seen.unmark(key));
         if (handled)
             resourceEvents++;
     }

package/dist/platform/polls/PollKind.d.ts

@@ -9,39 +9,36 @@
  * both inbox delivery and external polls; disconnect stops both. The process
  * runner does not own a second copy of the polling lifecycle.
  *
- * A poll answers ONE question: is there work for this agent right now. It never
- * returns the work itself. The agent reads that for itself once woken, through
- * its own tools, so it cannot end up with a second, differently-shaped copy of
- * its input and no way to tell which is current.
+ * A source may report an existing task action for authorized host processing.
+ * A mechanical source may dispatch through its existing domain owner and return
+ * actionable:false; the resulting owner delivery supplies work to its assignee.
+ * It never creates a room or borrows the execution that started the timer.
  *
  * WHERE THE CURSOR LIVES: in the source, whenever the source has one. Sente
  * has `archived` on a message, so "already handled" is a fact about the
  * mailbox, not something we mirror. A kind whose source has no such notion has
  * to keep a cursor, and then it is the kind's business — never the agent's.
  */
-/**
- * Kind-specific config, verbatim from the agent's manifest.
- *
- * `chatId` is not kind-specific and is not optional in practice: a wake has to
- * resolve to a lane or Agent's session resolver returns null and drops it
- * silently. A poll has no engagement behind it to derive one from, so the
- * binding names the chat the agent thinks in — which also puts its triage
- * somewhere a human can watch. PollRunner refuses to register a binding without
- * one rather than let the wake evaporate at runtime.
- */
+/** Kind-specific source configuration. It carries no room or execution authority. */
 export interface PollBinding {
     kind: string;
-    /** Chat the poll wake is delivered into. Required; see above. */
-    chatId?: string;
     [key: string]: unknown;
 }
 export interface PollContext {
     agentId: string;
     operatorKey?: string;
+    /** False after disconnect, including an older connection after reconnect. */
+    isActive(): boolean;
 }
 export interface PollResult {
     /** Whether the agent should be woken now. */
     actionable: boolean;
+    /** A model wake must name existing task work; owner preparation can refuse it.
+     * Mechanical sources dispatch through their owner and return actionable:false. */
+    action?: {
+        kind: 'task';
+        id: string;
+    };
     /**
      * One line telling the agent why it woke. Carries no payload — see above.
      * Omit and the runner sends the kind's default.

package/dist/platform/polls/PollKind.js

@@ -9,10 +9,10 @@
  * both inbox delivery and external polls; disconnect stops both. The process
  * runner does not own a second copy of the polling lifecycle.
  *
- * A poll answers ONE question: is there work for this agent right now. It never
- * returns the work itself. The agent reads that for itself once woken, through
- * its own tools, so it cannot end up with a second, differently-shaped copy of
- * its input and no way to tell which is current.
+ * A source may report an existing task action for authorized host processing.
+ * A mechanical source may dispatch through its existing domain owner and return
+ * actionable:false; the resulting owner delivery supplies work to its assignee.
+ * It never creates a room or borrows the execution that started the timer.
  *
  * WHERE THE CURSOR LIVES: in the source, whenever the source has one. Sente
  * has `archived` on a message, so "already handled" is a fact about the

package/dist/platform/polls/PollRunner.d.ts

@@ -1,25 +1,8 @@
-/**
- * PollRunner — executes declared external wake sources for agents.
- *
- * Each Agent owns its runner and starts it with its inbox loop. A poll is per
- * (agent, binding), with its own interval, backoff and backpressure. This same
- * lifecycle applies to fleet, MCP-tool, lab and evaluation agents.
- *
- * One loop per (agent, binding), and each loop AWAITS its own wake before
- * scheduling the next tick. That is the whole backpressure story: while an
- * agent is still dealing with what it was woken for, its next poll has not
- * happened yet, so it cannot be woken twice for the same thing. No in-flight
- * bookkeeping, no dedup table — the source is authoritative and a poll that
- * has not run yet cannot report anything stale.
- *
- * A failing source backs off exponentially and recovers on the first success.
- * Without it a source that is down is hit at full rate indefinitely, which is
- * how you get rate-limited by the thing you were trying to read.
- */
+import { type WorkExecutionContext } from '@ziggs-ai/api-client';
 import { type PollRegistry } from './PollKind.js';
-/** The slice of ConnectionPool this needs. Kept narrow to avoid a cycle. */
+/** Existing task-owner wake entry; called only after exact execution preparation. */
 export interface WakeTarget {
-    sendTo(agentId: string, text: string, metadata?: Record<string, unknown>, opts?: {
+    wakeTask(agentId: string, taskId: string, execution: WorkExecutionContext, opts?: {
         timeoutMs?: number;
     }): Promise<unknown>;
 }

package/dist/platform/polls/PollRunner.js

@@ -1,3 +1,4 @@
+import { prepareWorkExecution, withAutonomousRequest, withWorkExecution } from '@ziggs-ai/api-client';
 /**
  * PollRunner — executes declared external wake sources for agents.
  *
@@ -49,19 +50,11 @@ export class PollRunner {
                     runtimeLog.warn(label, `${agentId} declares unknown poll kind "${binding.kind}" — it will never be woken by it (registered: ${registry.ids.join(', ') || 'none'})`);
                     continue;
                 }
-                if (!binding.chatId) {
-                    // Refused at startup rather than dropped per-wake: without a lane the
-                    // host's session resolver returns null and the wake disappears with
-                    // only a debug line, which looks exactly like "the source is quiet".
-                    runtimeLog.warn(label, `${agentId} declares poll "${binding.kind}" without a chatId — refusing to register it, because every wake would be silently dropped`);
-                    continue;
-                }
                 this.loops.push({
                     agentId,
                     binding,
                     kind,
                     intervalMs: kind.intervalMs ?? defaultIntervalMs,
-                    chatId: binding.chatId,
                     timer: null,
                     failures: 0,
                     inFlight: false,
@@ -104,7 +97,8 @@ export class PollRunner {
         loop.timer = setTimeout(() => {
             loop.timer = null;
             loop.inFlight = true;
-            void this.tick(loop, this.generation).finally(() => {
+            const generation = this.generation;
+            void withAutonomousRequest(() => this.tick(loop, generation)).finally(() => {
                 loop.inFlight = false;
                 this.schedule(loop);
             });
@@ -123,6 +117,7 @@ export class PollRunner {
         try {
             result = await loop.kind.poll(loop.binding, {
                 agentId: loop.agentId,
+                isActive: () => this.running && generation === this.generation,
                 ...(this.operatorKey ? { operatorKey: this.operatorKey } : {}),
             });
             loop.failures = 0;
@@ -136,13 +131,16 @@ export class PollRunner {
         if (!this.running || generation !== this.generation)
             return;
         if (result?.actionable && this.claimWake(loop)) {
-            const hint = result.hint ?? `New work from ${loop.kind.id}. Check it.`;
             try {
-                // Awaited on purpose — see the header. The next tick waits for the
-                // agent to finish, which is what stops a double wake. chatId is what
-                // makes the wake resolve to a lane at all, and wakeTimeoutMs has to
-                // outlast a real multi-turn wake or the await stops meaning anything.
-                await this.pool.sendTo(loop.agentId, hint, { chatId: loop.chatId, pollKind: loop.kind.id }, { timeoutMs: this.wakeTimeoutMs });
+                if (!this.operatorKey || result.action?.kind !== 'task' || !result.action.id?.trim()) {
+                    throw new Error('Poll model wake requires an authenticated exact task action; unbound wake refused');
+                }
+                const execution = await prepareWorkExecution(result.action, this.operatorKey, loop.agentId);
+                if (!this.running || generation !== this.generation)
+                    return;
+                if (execution.taskId !== result.action.id)
+                    throw new Error('Poll preparation returned different task work');
+                await withWorkExecution(execution, () => this.pool.wakeTask(loop.agentId, result.action.id, execution, { timeoutMs: this.wakeTimeoutMs }));
                 runtimeLog.info(this.label, `woke ${loop.agentId} for ${loop.kind.id}`);
             }
             catch (err) {

package/dist/platform/polls/declaredPollRunner.d.ts

@@ -4,7 +4,7 @@ import { PollRunner, type WakeTarget } from './PollRunner.js';
  * Build the runner that executes this agent's declared wakes.
  *
  * A malformed `polls` value is a programming error and still throws. A
- * binding that names an unknown kind or has no chatId is not: PollRunner
+ * binding that names an unknown kind is not: PollRunner
  * warns and skips it, so one agent's invalid poll cannot refuse the host.
  */
 export declare function createDeclaredPollRunner(options: AgentOptions, target: WakeTarget): PollRunner | null;

package/dist/platform/polls/declaredPollRunner.js

@@ -4,7 +4,7 @@ import { PollRunner } from './PollRunner.js';
  * Build the runner that executes this agent's declared wakes.
  *
  * A malformed `polls` value is a programming error and still throws. A
- * binding that names an unknown kind or has no chatId is not: PollRunner
+ * binding that names an unknown kind is not: PollRunner
  * warns and skips it, so one agent's invalid poll cannot refuse the host.
  */
 export function createDeclaredPollRunner(options, target) {