zyndo 0.3.0 → 0.3.1

package/dist/connection.d.ts

@@ -84,3 +84,13 @@ export declare function deliverTask(session: AgentSession, taskId: string, conte
 export declare function sendTaskMessage(session: AgentSession, taskId: string, type: 'question' | 'answer' | 'info', content: string): Promise<void>;
 export declare function getTaskMessages(session: AgentSession, taskId: string): Promise<ReadonlyArray<TaskMessage>>;
 export declare function getTaskDetail(session: AgentSession, taskId: string): Promise<TaskDetail | undefined>;
+/**
+ * List every task the broker has on record for this agent (both as buyer and
+ * seller). Used by the seller daemon to reconcile against its event cursor:
+ * when an event is missed (broker restart, network partition, lost SSE), the
+ * reconciliation pass picks up any `submitted` task assigned to us that the
+ * event stream failed to deliver and drives it to `accepted`. Without this the
+ * seller can appear "online" (heartbeat OK, polling OK) while silently leaving
+ * a buyer's task stuck forever.
+ */
+export declare function listAgentTasks(session: AgentSession): Promise<ReadonlyArray<TaskDetail>>;

package/dist/connection.js

@@ -154,3 +154,19 @@ export async function getTaskDetail(session, taskId) {
         return undefined;
     return (await res.json());
 }
+/**
+ * List every task the broker has on record for this agent (both as buyer and
+ * seller). Used by the seller daemon to reconcile against its event cursor:
+ * when an event is missed (broker restart, network partition, lost SSE), the
+ * reconciliation pass picks up any `submitted` task assigned to us that the
+ * event stream failed to deliver and drives it to `accepted`. Without this the
+ * seller can appear "online" (heartbeat OK, polling OK) while silently leaving
+ * a buyer's task stuck forever.
+ */
+export async function listAgentTasks(session) {
+    const res = await jsonGet(`${session.bridgeUrl}/agent/tasks`, session.token);
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.tasks ?? [];
+}

package/dist/sellerDaemon.js

@@ -2,7 +2,7 @@
 // Seller daemon — poll for tasks, run agent loop, deliver results
 // ---------------------------------------------------------------------------
 import { resolve } from 'node:path';
-import { connect, reconnect, heartbeat, pollEvents, acceptTask, deliverTask, sendTaskMessage, getTaskMessages, getTaskDetail, registerIdentity } from './connection.js';
+import { connect, reconnect, heartbeat, pollEvents, acceptTask, deliverTask, sendTaskMessage, getTaskMessages, getTaskDetail, listAgentTasks, registerIdentity } from './connection.js';
 import { ensureIdentityKeypair, signDelivery } from './identity.js';
 import { composeSystemPrompt, truncateToContract } from './scopeContract.js';
 import { runAgentLoop } from './agentLoop.js';
@@ -19,6 +19,11 @@ import { createAskBuyerTool } from './tools/askBuyer.js';
 import { loadState, saveState, deleteState, loadSession, saveSession, loadLastEventId, saveLastEventId } from './state.js';
 const POLL_INTERVAL_MS = 25_000;
 const HEARTBEAT_INTERVAL_MS = 45_000;
+// Every N poll cycles, reconcile the local active-task set against the
+// broker's authoritative task list. This catches missed `task.assigned`
+// events caused by broker restarts (in-memory event queue reset), network
+// partitions, or dropped SSE frames. 8 cycles at 25s = ~200s safety net.
+const RECONCILE_EVERY_N_POLLS = 8;
 // ---------------------------------------------------------------------------
 // Reconnect error classification (incident 2026-04-09 follow-up)
 //
@@ -164,6 +169,72 @@ export async function startSellerDaemon(config, opts) {
     let lastEventId = loadLastEventId();
     let lastHeartbeat = Date.now();
     const activeTasks = new Set();
+    let pollsSinceReconcile = 0;
+    /**
+     * Reconcile the local active-task set against the broker's authoritative
+     * task list. Picks up any `submitted` task assigned to this seller that we
+     * do not already have in flight, regardless of whether we ever saw the
+     * matching `task.assigned` event. This is the recovery path for missed
+     * events (broker restart wipes the in-memory event queue, network drop
+     * loses an event frame, etc.).
+     *
+     * Also handles `input-required` tasks in `question` input-type (buyer
+     * answered a prior question we never got the event for) and
+     * `working` tasks we have no record of (we crashed mid-task and need to
+     * resume — but without saved state the safest action is to notify the
+     * buyer; we just re-add to activeTasks so we do not re-accept).
+     */
+    async function reconcileTasks(reason) {
+        const activeSession = session;
+        if (activeSession === undefined)
+            return;
+        try {
+            const tasks = await listAgentTasks(activeSession);
+            let picked = 0;
+            for (const task of tasks) {
+                if (task.sellerAgentId !== activeSession.agentId)
+                    continue;
+                if (activeTasks.has(task.taskId))
+                    continue;
+                if (task.state === 'submitted') {
+                    if (activeTasks.size >= config.maxConcurrentTasks) {
+                        logger.info(`Reconcile: task ${task.taskId} submitted but seller at capacity, will retry.`);
+                        continue;
+                    }
+                    activeTasks.add(task.taskId);
+                    picked += 1;
+                    logger.info(`Reconcile (${reason}): picking up stuck submitted task ${task.taskId}`);
+                    handleTask(activeSession, task.taskId, config, logger, identityPrivateKey)
+                        .catch((err) => {
+                        logger.error(`Reconciled task ${task.taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
+                    })
+                        .finally(() => activeTasks.delete(task.taskId));
+                    continue;
+                }
+                if (task.state === 'input-required' && task.inputType === 'question') {
+                    activeTasks.add(task.taskId);
+                    picked += 1;
+                    logger.info(`Reconcile (${reason}): picking up input-required task ${task.taskId}`);
+                    handleBuyerMessage(activeSession, task.taskId, config, logger, identityPrivateKey)
+                        .catch((err) => {
+                        logger.error(`Reconciled message for ${task.taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
+                    })
+                        .finally(() => activeTasks.delete(task.taskId));
+                    continue;
+                }
+            }
+            if (picked > 0) {
+                logger.info(`Reconcile (${reason}): recovered ${picked} task(s).`);
+            }
+        }
+        catch (err) {
+            logger.error(`Reconcile (${reason}) failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // Startup reconcile — if the broker restarted while this daemon was down
+    // (or this daemon is resuming a long-running session across a broker
+    // deploy), pick up any submitted task assigned to us on the very first tick.
+    await reconcileTasks('startup');
     while (signal === undefined || !signal.aborted) {
         try {
             // Heartbeat
@@ -197,6 +268,14 @@ export async function startSellerDaemon(config, opts) {
                             logger.info(`Reconnected successfully (attempt ${attempt + 1}).`);
                             lastHeartbeat = Date.now();
                             reconnected = true;
+                            // Force a reconcile on the next tick: the broker may have
+                            // restarted and wiped its in-memory event queue, so our
+                            // lastEventId cursor is now stale relative to the fresh
+                            // nextEventId counter. Without this the seller polls forever
+                            // and never sees task.assigned events that happened while we
+                            // were disconnected or that were issued after the reset.
+                            pollsSinceReconcile = RECONCILE_EVERY_N_POLLS;
+                            await reconcileTasks('reconnect');
                             break;
                         }
                         catch (reconnectError) {
@@ -232,6 +311,8 @@ export async function startSellerDaemon(config, opts) {
                             logger.info(`Re-registered: agentId=${session.agentId}`);
                             lastHeartbeat = Date.now();
                             reconnected = true;
+                            pollsSinceReconcile = RECONCILE_EVERY_N_POLLS;
+                            await reconcileTasks('re-register');
                         }
                         catch (freshErr) {
                             const msg = freshErr instanceof Error ? freshErr.message : String(freshErr);
@@ -330,6 +411,16 @@ export async function startSellerDaemon(config, opts) {
             }
             // Persist cursor so restarts resume from here
             saveLastEventId(lastEventId);
+            // Periodic reconcile: even without a reconnect, poll the task list as a
+            // safety net. If a single `task.assigned` event was dropped (network
+            // partition, broker partial outage, client-side parse error) the seller
+            // would otherwise leave a buyer stuck indefinitely. Every N polls we
+            // re-check the authoritative task list and pick up anything missed.
+            pollsSinceReconcile += 1;
+            if (pollsSinceReconcile >= RECONCILE_EVERY_N_POLLS) {
+                pollsSinceReconcile = 0;
+                await reconcileTasks('periodic');
+            }
         }
         catch (error) {
             logger.error(`Poll error: ${error instanceof Error ? error.message : String(error)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyndo",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "The agent-to-agent CLI tool for sellers in the Zyndo Marketplace",
   "type": "module",
   "license": "MIT",