zyndo 0.3.2 → 0.3.4

package/dist/connection.d.ts

@@ -42,6 +42,9 @@ export type TaskDetail = Readonly<{
         content: string;
     }>;
     createdAt: string;
+    revisionCount?: number;
+    pendingRevisionFeedback?: string;
+    pendingRevisionRequestedAt?: string;
     deliverablesSnapshot?: SkillDeliverablesSnapshot;
 }>;
 export type TaskMessage = Readonly<{
@@ -52,6 +55,29 @@ export type TaskMessage = Readonly<{
     content: string;
     createdAt: string;
 }>;
+export type ReconnectOpts = Readonly<{
+    role: 'seller' | 'buyer';
+    name: string;
+    description: string;
+}>;
+export type SessionHolder = {
+    current: AgentSession;
+    /**
+     * API key used to authenticate reconnect calls. Empty string disables
+     * automatic reconnect on 401 (used by tests and MCP buyer bridges that
+     * don't own a long-running session).
+     */
+    apiKey: string;
+    reconnectOpts: ReconnectOpts;
+};
+export declare function createSessionHolder(session: AgentSession, apiKey: string, reconnectOpts: ReconnectOpts): SessionHolder;
+/**
+ * Wrap a raw session in a holder for callers that don't need
+ * automatic reconnect-on-401 (e.g. MCP buyer-side bridges). Passing a bare
+ * holder means `withAuthRetry` will never attempt to reconnect — it will
+ * simply throw the original 401 error the way the old helpers did.
+ */
+export declare function bareSessionHolder(session: AgentSession): SessionHolder;
 export declare function connect(bridgeUrl: string, apiKey: string, opts: {
     role: 'seller' | 'buyer';
     name: string;
@@ -71,19 +97,19 @@ export declare function reconnect(session: AgentSession, apiKey: string, opts?:
     name?: string;
     description?: string;
 }): Promise<AgentSession>;
-export declare function heartbeat(session: AgentSession): Promise<void>;
-export declare function pollEvents(session: AgentSession, ack?: number): Promise<ReadonlyArray<AgentEvent>>;
-export declare function acceptTask(session: AgentSession, taskId: string): Promise<void>;
+export declare function heartbeat(holder: SessionHolder): Promise<void>;
+export declare function pollEvents(holder: SessionHolder, ack?: number): Promise<ReadonlyArray<AgentEvent>>;
+export declare function acceptTask(holder: SessionHolder, taskId: string): Promise<void>;
 /**
  * Slice 3b — register the seller's Ed25519 public key with the broker so
  * subsequent signed deliveries can be verified. Safe to call on every daemon
  * start; the broker upserts and tracks rotations.
  */
-export declare function registerIdentity(session: AgentSession, publicKeyB64: string): Promise<void>;
-export declare function deliverTask(session: AgentSession, taskId: string, content: string, signatureB64?: string): Promise<void>;
-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>;
+export declare function registerIdentity(holder: SessionHolder, publicKeyB64: string): Promise<void>;
+export declare function deliverTask(holder: SessionHolder, taskId: string, content: string, signatureB64?: string): Promise<void>;
+export declare function sendTaskMessage(holder: SessionHolder, taskId: string, type: 'question' | 'answer' | 'info', content: string): Promise<void>;
+export declare function getTaskMessages(holder: SessionHolder, taskId: string): Promise<ReadonlyArray<TaskMessage>>;
+export declare function getTaskDetail(holder: SessionHolder, 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:
@@ -93,4 +119,4 @@ export declare function getTaskDetail(session: AgentSession, taskId: string): Pr
  * 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>>;
+export declare function listAgentTasks(holder: SessionHolder): Promise<ReadonlyArray<TaskDetail>>;

package/dist/connection.js

@@ -1,11 +1,44 @@
 // ---------------------------------------------------------------------------
 // Connection module — connect, heartbeat, poll events, deliver
+//
+// Every network helper takes a SessionHolder (a mutable wrapper around the
+// current AgentSession) instead of the raw session. This makes broker
+// restart-mid-task survivable:
+//
+//   1. Seller daemon creates ONE holder at startup.
+//   2. All handlers (handleTask, handleRevision, handleMessage) receive that
+//      holder by reference and call network helpers with it.
+//   3. On any 401 response, `withAuthRetry` reconnects, mutates the holder's
+//      `.current` in place, and retries the original call once.
+//   4. In-flight handlers see the new token on their next network call
+//      because they hold the same holder reference.
+//
+// Before this change, `session` was passed by value to each handler. The
+// outer heartbeat loop could reconnect and update its own `session` variable,
+// but the already-running handler still held the stale object in its
+// closure and died with 401 on deliver. Incident 2026-04-14.
 // ---------------------------------------------------------------------------
 // Mirror of @zyndo/contracts MAX_AGENT_MESSAGE_CHARS. The CLI ships as a
 // standalone npm package, so we duplicate this small constant rather than
 // pulling in the contracts workspace as a dependency. Keep these values in
 // sync if the broker-side limit ever changes.
 export const MAX_AGENT_MESSAGE_CHARS = 50_000;
+export function createSessionHolder(session, apiKey, reconnectOpts) {
+    return { current: session, apiKey, reconnectOpts };
+}
+/**
+ * Wrap a raw session in a holder for callers that don't need
+ * automatic reconnect-on-401 (e.g. MCP buyer-side bridges). Passing a bare
+ * holder means `withAuthRetry` will never attempt to reconnect — it will
+ * simply throw the original 401 error the way the old helpers did.
+ */
+export function bareSessionHolder(session) {
+    return {
+        current: session,
+        apiKey: '',
+        reconnectOpts: { role: 'buyer', name: '', description: '' }
+    };
+}
 // ---------------------------------------------------------------------------
 // HTTP helpers
 // ---------------------------------------------------------------------------
@@ -22,7 +55,52 @@ async function jsonGet(url, token) {
     return fetch(url, { headers });
 }
 // ---------------------------------------------------------------------------
-// Connect
+// withAuthRetry — shared 401-retry wrapper used by every network helper
+// ---------------------------------------------------------------------------
+/**
+ * Make an authenticated request. If the broker returns 401, attempt a
+ * single reconnect, mutate the holder's `.current` in place, and retry
+ * the call once with the fresh token.
+ *
+ * - Never loops. At most one retry.
+ * - If the holder has no `apiKey` (bare holder), 401 is passed through
+ *   to the caller unchanged — this preserves the pre-holder semantics for
+ *   MCP buyer bridges and unit tests.
+ * - The first 401 triggers a reconnect attempt; if that reconnect itself
+ *   throws, the original 401 error surfaces with a note about the failure.
+ * - Non-401 error statuses are NEVER retried.
+ */
+async function withAuthRetry(holder, label, doCall) {
+    const firstRes = await doCall(holder.current.token);
+    if (firstRes.status !== 401)
+        return firstRes;
+    if (holder.apiKey.length === 0)
+        return firstRes;
+    // Drain the body so the socket can be reused.
+    try {
+        await firstRes.text();
+    }
+    catch { /* ignore */ }
+    try {
+        const fresh = await reconnect(holder.current, holder.apiKey, {
+            role: holder.reconnectOpts.role,
+            name: holder.reconnectOpts.name,
+            description: holder.reconnectOpts.description
+        });
+        holder.current = fresh;
+        process.stderr.write(`[zyndo] ${label}: session refreshed after 401, retrying once\n`);
+    }
+    catch (reconnectErr) {
+        const msg = reconnectErr instanceof Error ? reconnectErr.message : String(reconnectErr);
+        process.stderr.write(`[zyndo] ${label}: reconnect-on-401 failed: ${msg}\n`);
+        // Surface the reconnect error; the caller can decide whether to bubble
+        // it up or swallow it (pollEvents, for example, soft-fails).
+        throw new Error(`${label} 401 and reconnect failed: ${msg}`);
+    }
+    return doCall(holder.current.token);
+}
+// ---------------------------------------------------------------------------
+// Connect (no holder — creates one)
 // ---------------------------------------------------------------------------
 export async function connect(bridgeUrl, apiKey, opts) {
     const headers = {
@@ -45,14 +123,14 @@ export async function connect(bridgeUrl, apiKey, opts) {
         body: JSON.stringify(body)
     });
     if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Connect failed (${res.status}): ${body}`);
+        const errBody = await res.text();
+        throw new Error(`Connect failed (${res.status}): ${errBody}`);
     }
     const data = (await res.json());
     return { agentId: data.agentId, token: data.token, reconnectToken: data.reconnectToken, bridgeUrl };
 }
 // ---------------------------------------------------------------------------
-// Reconnect
+// Reconnect — called by withAuthRetry and by the seller daemon outer loop
 // ---------------------------------------------------------------------------
 export async function reconnect(session, apiKey, opts) {
     // The broker's /agent/connect endpoint is gated on x-zyndo-api-key when
@@ -82,27 +160,36 @@ export async function reconnect(session, apiKey, opts) {
 // ---------------------------------------------------------------------------
 // Heartbeat
 // ---------------------------------------------------------------------------
-export async function heartbeat(session) {
-    const res = await jsonPost(`${session.bridgeUrl}/agent/heartbeat`, {}, session.token);
-    if (!res.ok && res.status === 401) {
-        throw new Error('Heartbeat failed: session expired. Attempting reconnect.');
+export async function heartbeat(holder) {
+    const res = await withAuthRetry(holder, 'heartbeat', (token) => jsonPost(`${holder.current.bridgeUrl}/agent/heartbeat`, {}, token));
+    if (!res.ok) {
+        // A 401 after a successful retry cycle still reaches here, and any other
+        // non-ok status. The outer daemon heartbeat loop will catch this and
+        // attempt a fresh reconnect/re-register cycle as a last resort.
+        throw new Error(`Heartbeat failed (${res.status}): ${await res.text().catch(() => '<no body>')}`);
     }
 }
 // ---------------------------------------------------------------------------
-// Poll events
+// Poll events — soft-fails on any error (returns empty array) because the
+// seller daemon polls on a tick and can't die on a single failed poll.
 // ---------------------------------------------------------------------------
-export async function pollEvents(session, ack = 0) {
-    const res = await jsonGet(`${session.bridgeUrl}/agent/events?since=${ack}`, session.token);
-    if (!res.ok)
+export async function pollEvents(holder, ack = 0) {
+    try {
+        const res = await withAuthRetry(holder, 'pollEvents', (token) => jsonGet(`${holder.current.bridgeUrl}/agent/events?since=${ack}`, token));
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.events;
+    }
+    catch {
         return [];
-    const data = (await res.json());
-    return data.events;
+    }
 }
 // ---------------------------------------------------------------------------
 // Task operations
 // ---------------------------------------------------------------------------
-export async function acceptTask(session, taskId) {
-    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/accept`, {}, session.token);
+export async function acceptTask(holder, taskId) {
+    const res = await withAuthRetry(holder, `accept task ${taskId}`, (token) => jsonPost(`${holder.current.bridgeUrl}/agent/tasks/${taskId}/accept`, {}, token));
     if (!res.ok) {
         throw new Error(`Accept failed (${res.status}): ${await res.text()}`);
     }
@@ -112,23 +199,23 @@ export async function acceptTask(session, taskId) {
  * subsequent signed deliveries can be verified. Safe to call on every daemon
  * start; the broker upserts and tracks rotations.
  */
-export async function registerIdentity(session, publicKeyB64) {
-    const res = await jsonPost(`${session.bridgeUrl}/agent/identity/register`, { publicKeyB64 }, session.token);
+export async function registerIdentity(holder, publicKeyB64) {
+    const res = await withAuthRetry(holder, 'registerIdentity', (token) => jsonPost(`${holder.current.bridgeUrl}/agent/identity/register`, { publicKeyB64 }, token));
     if (!res.ok) {
         throw new Error(`Identity register failed (${res.status}): ${await res.text()}`);
     }
 }
-export async function deliverTask(session, taskId, content, signatureB64) {
+export async function deliverTask(holder, taskId, content, signatureB64) {
     const body = { output: { type: 'text', content } };
     if (signatureB64 !== undefined) {
         body.signature = signatureB64;
     }
-    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/deliver`, body, session.token);
+    const res = await withAuthRetry(holder, `deliver task ${taskId}`, (token) => jsonPost(`${holder.current.bridgeUrl}/agent/tasks/${taskId}/deliver`, body, token));
     if (!res.ok) {
         throw new Error(`Deliver failed (${res.status}): ${await res.text()}`);
     }
 }
-export async function sendTaskMessage(session, taskId, type, content) {
+export async function sendTaskMessage(holder, taskId, type, content) {
     // Pre-flight guard: fail fast locally instead of round-tripping to the broker
     // when the message obviously exceeds the marketplace limit. The broker will
     // also reject this — this is just for faster, clearer feedback to the agent.
@@ -136,20 +223,20 @@ export async function sendTaskMessage(session, taskId, type, content) {
         throw new Error(`Message content is ${content.length} characters, which exceeds the ${MAX_AGENT_MESSAGE_CHARS}-character marketplace limit. ` +
             `Trim the message before sending. Long context should be summarized or attached as a file delivery, not pasted into a chat message.`);
     }
-    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/messages`, { type, content }, session.token);
+    const res = await withAuthRetry(holder, `send message ${taskId}`, (token) => jsonPost(`${holder.current.bridgeUrl}/agent/tasks/${taskId}/messages`, { type, content }, token));
     if (!res.ok) {
         throw new Error(`Send message failed (${res.status}): ${await res.text()}`);
     }
 }
-export async function getTaskMessages(session, taskId) {
-    const res = await jsonGet(`${session.bridgeUrl}/agent/tasks/${taskId}/messages`, session.token);
+export async function getTaskMessages(holder, taskId) {
+    const res = await withAuthRetry(holder, `get messages ${taskId}`, (token) => jsonGet(`${holder.current.bridgeUrl}/agent/tasks/${taskId}/messages`, token));
     if (!res.ok)
         return [];
     const data = (await res.json());
     return data.messages;
 }
-export async function getTaskDetail(session, taskId) {
-    const res = await jsonGet(`${session.bridgeUrl}/agent/tasks/${taskId}`, session.token);
+export async function getTaskDetail(holder, taskId) {
+    const res = await withAuthRetry(holder, `get task ${taskId}`, (token) => jsonGet(`${holder.current.bridgeUrl}/agent/tasks/${taskId}`, token));
     if (!res.ok)
         return undefined;
     return (await res.json());
@@ -163,8 +250,8 @@ export async function getTaskDetail(session, taskId) {
  * 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);
+export async function listAgentTasks(holder) {
+    const res = await withAuthRetry(holder, 'list tasks', (token) => jsonGet(`${holder.current.bridgeUrl}/agent/tasks`, token));
     if (!res.ok)
         return [];
     const data = (await res.json());

package/dist/mcp/mcpCore.js

@@ -5,7 +5,7 @@
 // Streamable HTTP transport (mcpHttpServer.ts). All handlers are pure
 // functions that take a McpSessionState instead of reading module-level vars.
 // ---------------------------------------------------------------------------
-import { connect, reconnect, pollEvents } from '../connection.js';
+import { connect, reconnect, pollEvents, bareSessionHolder } from '../connection.js';
 // ---------------------------------------------------------------------------
 // Tool definitions
 // ---------------------------------------------------------------------------
@@ -268,7 +268,7 @@ async function handleHire(state, args) {
 async function handleCheckTasks(state) {
     if (state.agentSession === undefined)
         return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
-    const events = await pollEvents(state.agentSession, state.lastEventId);
+    const events = await pollEvents(bareSessionHolder(state.agentSession), state.lastEventId);
     const taskEvents = {};
     for (const event of events) {
         if (event.eventId > state.lastEventId)

package/dist/mcp/mcpServer.js

@@ -5,7 +5,7 @@
 // Manages a single McpSessionState and heartbeat timer for the stdio session.
 // ---------------------------------------------------------------------------
 import { createInterface } from 'node:readline';
-import { heartbeat } from '../connection.js';
+import { heartbeat, bareSessionHolder } from '../connection.js';
 import { handleMcpMethod, mcpError } from './mcpCore.js';
 // ---------------------------------------------------------------------------
 // Heartbeat with auto-reconnect
@@ -15,7 +15,7 @@ function startHeartbeat(state) {
         if (state.agentSession === undefined)
             return;
         try {
-            await heartbeat(state.agentSession);
+            await heartbeat(bareSessionHolder(state.agentSession));
         }
         catch {
             // Session expired — the next tool call will trigger auto-reconnect via mcpCore

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, listAgentTasks, registerIdentity } from './connection.js';
+import { connect, reconnect, createSessionHolder, 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';
@@ -16,14 +16,19 @@ import { createBashTool } from './tools/bash.js';
 import { createGlobTool } from './tools/glob.js';
 import { createGrepTool } from './tools/grep.js';
 import { createAskBuyerTool } from './tools/askBuyer.js';
-import { loadState, saveState, deleteState, loadSession, saveSession, loadLastEventId, saveLastEventId } from './state.js';
+import { loadState, saveState, deleteState, loadSession, saveSession, loadLastEventId, saveLastEventId, savePendingDelivery, loadPendingDelivery, deletePendingDelivery, incrementPendingDeliveryAttempts } 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;
+// Periodic reconcile safety net. Every N poll cycles, check /agent/tasks for
+// anything the daemon doesn't know about. Was 8 (~200s at 25s polls). Too
+// slow — users saw multi-minute hire pickup delays after broker restarts
+// broke the event cursor. 2 (~50s) is fast enough to be invisible while
+// still being cheap. Incident 2026-04-14.
+const RECONCILE_EVERY_N_POLLS = 2;
 // ---------------------------------------------------------------------------
 // Reconnect error classification (incident 2026-04-09 follow-up)
 //
@@ -154,19 +159,45 @@ export async function startSellerDaemon(config, opts) {
     }
     // Persist session for future restarts
     saveSession(session.agentId, session.reconnectToken);
+    // Wrap the session in a mutable holder. Every network helper reads
+    // holder.current.token at call time. When a broker restart invalidates
+    // the in-memory token map, withAuthRetry inside each helper calls
+    // reconnect(), mutates holder.current in place, and retries once. Any
+    // in-flight task handler that was mid-call sees the new token on its
+    // next network operation because the handler holds the SAME holder
+    // reference. Incident 2026-04-14.
+    const holder = createSessionHolder(session, config.apiKey, {
+        role: 'seller',
+        name: config.name,
+        description: config.description
+    });
     // Slice 3b — register the Ed25519 public key with the broker. Failures
     // are logged but non-fatal because signing is soft-enforced until
     // rollout > 80%.
     if (identityPublicKeyB64 !== undefined) {
         try {
-            await registerIdentity(session, identityPublicKeyB64);
+            await registerIdentity(holder, identityPublicKeyB64);
             logger.info('Identity public key registered with broker.');
         }
         catch (err) {
             logger.error(`Identity registration failed: ${err instanceof Error ? err.message : String(err)}. Deliveries will be unsigned.`);
         }
     }
-    let lastEventId = loadLastEventId();
+    // Reset the event cursor on every daemon startup. The persisted value from
+    // a previous session can be higher than the broker's in-memory event
+    // counter after a broker restart (Railway auto-deploys reset the counter),
+    // causing pollEvents to return empty indefinitely — tasks could only be
+    // recovered via the periodic reconcile loop, producing multi-minute hire
+    // pickup delays. Starting from 0 makes pollEvents instantly see any current
+    // event stream. The startup reconcile already catches any in-flight task
+    // the broker persisted, and the activeTasks Set dedupes any replayed
+    // events so no work is done twice. Incident 2026-04-14.
+    const persistedCursor = loadLastEventId();
+    if (persistedCursor > 0) {
+        logger.info(`Event cursor reset from ${persistedCursor} → 0 on startup (broker may have restarted; reconcile will recover in-flight tasks).`);
+    }
+    let lastEventId = 0;
+    saveLastEventId(0);
     let lastHeartbeat = Date.now();
     const activeTasks = new Set();
     let pollsSinceReconcile = 0;
@@ -185,14 +216,11 @@ export async function startSellerDaemon(config, opts) {
      * 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);
+            const tasks = await listAgentTasks(holder);
             let picked = 0;
             for (const task of tasks) {
-                if (task.sellerAgentId !== activeSession.agentId)
+                if (task.sellerAgentId !== holder.current.agentId)
                     continue;
                 if (activeTasks.has(task.taskId))
                     continue;
@@ -204,18 +232,65 @@ export async function startSellerDaemon(config, opts) {
                     activeTasks.add(task.taskId);
                     picked += 1;
                     logger.info(`Reconcile (${reason}): picking up stuck submitted task ${task.taskId}`);
-                    handleTask(activeSession, task.taskId, config, logger, identityPrivateKey)
+                    handleTask(holder, 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;
                 }
+                // `working` tasks with a pending delivery on disk are stuck deliveries
+                // from a previous run where deliverTask threw (network blip, broker
+                // mid-restart, 401 after the retry budget). Re-enter handleTask so it
+                // reads the pending delivery from disk and re-attempts the exact same
+                // bytes, no codex re-spawn.
+                if (task.state === 'working' && loadPendingDelivery(task.taskId) !== undefined) {
+                    if (activeTasks.size >= config.maxConcurrentTasks) {
+                        logger.info(`Reconcile: task ${task.taskId} has pending delivery but seller at capacity, will retry.`);
+                        continue;
+                    }
+                    activeTasks.add(task.taskId);
+                    picked += 1;
+                    logger.info(`Reconcile (${reason}): retrying stuck pending delivery for task ${task.taskId}`);
+                    handleTask(holder, task.taskId, config, logger, identityPrivateKey)
+                        .catch((err) => {
+                        logger.error(`Reconciled pending delivery ${task.taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
+                    })
+                        .finally(() => activeTasks.delete(task.taskId));
+                    continue;
+                }
+                // `working` tasks with `pendingRevisionFeedback` set on the broker side
+                // are stuck revisions from a lost `task.revision.requested` event. The
+                // broker stamps the feedback onto the task record in the same
+                // transaction that emits the event; if the event stream drops frames
+                // or the seller's cursor is ahead of the broker's reset-in-memory
+                // counter, the seller never sees the event. Reconcile picks it up by
+                // reading the feedback straight from the task detail. Incident
+                // 2026-04-14 — user requested a revision on a legacy task and the
+                // seller daemon sat idle for 8 minutes because this path didn't exist.
+                if (task.state === 'working'
+                    && typeof task.pendingRevisionFeedback === 'string'
+                    && task.pendingRevisionFeedback.length > 0) {
+                    if (activeTasks.size >= config.maxConcurrentTasks) {
+                        logger.info(`Reconcile: task ${task.taskId} has stuck revision but seller at capacity, will retry.`);
+                        continue;
+                    }
+                    activeTasks.add(task.taskId);
+                    picked += 1;
+                    const feedback = task.pendingRevisionFeedback;
+                    logger.info(`Reconcile (${reason}): picking up stuck revision for task ${task.taskId} (feedback=${feedback.slice(0, 80)}${feedback.length > 80 ? '…' : ''})`);
+                    handleRevision(holder, task.taskId, feedback, config, logger, identityPrivateKey)
+                        .catch((err) => {
+                        logger.error(`Reconciled revision ${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)
+                    handleBuyerMessage(holder, task.taskId, config, logger, identityPrivateKey)
                         .catch((err) => {
                         logger.error(`Reconciled message for ${task.taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
                     })
@@ -240,8 +315,13 @@ export async function startSellerDaemon(config, opts) {
             // Heartbeat
             if (Date.now() - lastHeartbeat >= HEARTBEAT_INTERVAL_MS) {
                 try {
-                    await heartbeat(session);
+                    await heartbeat(holder);
                     lastHeartbeat = Date.now();
+                    // Persist the (possibly refreshed) session on every successful
+                    // heartbeat so a daemon restart always picks up the freshest
+                    // reconnect token. withAuthRetry may have silently refreshed
+                    // holder.current mid-heartbeat.
+                    saveSession(holder.current.agentId, holder.current.reconnectToken);
                 }
                 catch {
                     logger.info('Heartbeat failed, attempting reconnect...');
@@ -259,21 +339,33 @@ export async function startSellerDaemon(config, opts) {
                         if (signal !== undefined && signal.aborted)
                             break;
                         try {
-                            session = await reconnect(session, config.apiKey, {
+                            const fresh = await reconnect(holder.current, config.apiKey, {
                                 role: 'seller',
                                 name: config.name,
                                 description: config.description
                             });
-                            saveSession(session.agentId, session.reconnectToken);
+                            holder.current = fresh;
+                            saveSession(holder.current.agentId, holder.current.reconnectToken);
                             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.
+                            // The broker almost certainly restarted (that's why the
+                            // heartbeat failed in the first place). Its in-memory event
+                            // counter has reset to 0 while our in-memory lastEventId is
+                            // still at the old high value — every subsequent pollEvents
+                            // call would return empty because we'd be asking for events
+                            // "since <high>" from a stream that now starts at 1. Reset
+                            // the cursor in memory AND on disk so the next poll sees the
+                            // current event stream. Incident 2026-04-14.
+                            if (lastEventId > 0) {
+                                logger.info(`Event cursor reset ${lastEventId} → 0 after reconnect (broker restart suspected).`);
+                            }
+                            lastEventId = 0;
+                            saveLastEventId(0);
+                            // Also run an immediate reconcile so any task that was
+                            // already assigned to us before the broker restarted (and
+                            // is now past the event horizon) gets picked up without
+                            // waiting for the periodic cycle.
                             pollsSinceReconcile = RECONCILE_EVERY_N_POLLS;
                             await reconcileTasks('reconnect');
                             break;
@@ -298,7 +390,7 @@ export async function startSellerDaemon(config, opts) {
                         // the user's API key back to the same stable seller agentId.
                         try {
                             logger.info(`Re-registering as seller "${config.name}"...`);
-                            session = await connect(config.bridgeUrl, config.apiKey, {
+                            const freshRegister = await connect(config.bridgeUrl, config.apiKey, {
                                 role: 'seller',
                                 name: config.name,
                                 description: config.description,
@@ -307,10 +399,19 @@ export async function startSellerDaemon(config, opts) {
                                 maxConcurrentTasks: config.maxConcurrentTasks,
                                 sellerSlug: config.id
                             });
-                            saveSession(session.agentId, session.reconnectToken);
-                            logger.info(`Re-registered: agentId=${session.agentId}`);
+                            holder.current = freshRegister;
+                            saveSession(holder.current.agentId, holder.current.reconnectToken);
+                            logger.info(`Re-registered: agentId=${holder.current.agentId}`);
                             lastHeartbeat = Date.now();
                             reconnected = true;
+                            // Same cursor reset as the reconnect branch — a fresh connect
+                            // against a post-restart broker means the event stream is
+                            // brand new, so ask for "since=0".
+                            if (lastEventId > 0) {
+                                logger.info(`Event cursor reset ${lastEventId} → 0 after re-register.`);
+                            }
+                            lastEventId = 0;
+                            saveLastEventId(0);
                             pollsSinceReconcile = RECONCILE_EVERY_N_POLLS;
                             await reconcileTasks('re-register');
                         }
@@ -327,7 +428,7 @@ export async function startSellerDaemon(config, opts) {
                 }
             }
             // Poll events
-            const events = await pollEvents(session, lastEventId);
+            const events = await pollEvents(holder, lastEventId);
             let minDeferredEventId;
             for (const event of events) {
                 if (event.type === 'task.assigned') {
@@ -349,7 +450,7 @@ export async function startSellerDaemon(config, opts) {
                     if (event.eventId > lastEventId)
                         lastEventId = event.eventId;
                     logger.info(`Task assigned: ${taskId} (active: ${activeTasks.size}/${config.maxConcurrentTasks})`);
-                    handleTask(session, taskId, config, logger, identityPrivateKey)
+                    handleTask(holder, taskId, config, logger, identityPrivateKey)
                         .catch((err) => {
                         logger.error(`Task ${taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
                     })
@@ -366,7 +467,7 @@ export async function startSellerDaemon(config, opts) {
                         continue; // Task handler is already running
                     activeTasks.add(taskId);
                     logger.info(`Message received for task: ${taskId}`);
-                    handleBuyerMessage(session, taskId, config, logger, identityPrivateKey)
+                    handleBuyerMessage(holder, taskId, config, logger, identityPrivateKey)
                         .catch((err) => {
                         logger.error(`Message handling for ${taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
                     })
@@ -379,7 +480,7 @@ export async function startSellerDaemon(config, opts) {
                         continue;
                     activeTasks.add(taskId);
                     logger.info(`Revision requested for task: ${taskId}`);
-                    handleRevision(session, taskId, feedback, config, logger, identityPrivateKey)
+                    handleRevision(holder, taskId, feedback, config, logger, identityPrivateKey)
                         .catch((err) => {
                         logger.error(`Revision for ${taskId} failed: ${err instanceof Error ? err.message : String(err)}`);
                     })
@@ -432,9 +533,40 @@ export async function startSellerDaemon(config, opts) {
 // ---------------------------------------------------------------------------
 // Task handler
 // ---------------------------------------------------------------------------
-async function handleTask(session, taskId, config, logger, identityPrivateKey) {
+async function handleTask(holder, taskId, config, logger, identityPrivateKey) {
+    // Recovery fast-path: if a pending delivery is already on disk for this
+    // task (from a previous run where codex finished but deliverTask failed),
+    // skip codex entirely and retry the same bytes. Incident 2026-04-14.
+    const pending = loadPendingDelivery(taskId);
+    if (pending !== undefined) {
+        logger.info(`Task ${taskId}: pending delivery found on disk (${pending.output.length} chars produced at ${pending.producedAt}, attempt ${pending.attempts + 1}), skipping codex and delivering cached bytes directly.`);
+        // Ensure the task is in a state the broker will accept delivery on.
+        // If we never accepted or already moved to working, accept is idempotent
+        // at the 409 level.
+        try {
+            await acceptTask(holder, taskId);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('409')) {
+                logger.info(`Task ${taskId}: acceptTask during pending replay returned ${msg.slice(0, 120)}; proceeding to deliver anyway.`);
+            }
+        }
+        incrementPendingDeliveryAttempts(taskId);
+        try {
+            await deliverTask(holder, taskId, pending.output, pending.signature);
+            deletePendingDelivery(taskId);
+            logger.info(`Task ${taskId}: cached delivery accepted by broker.`);
+            saveState({ taskId, messages: [], claudeCodeContext: '', originalContext: '', lastDelivery: pending.output });
+        }
+        catch (err) {
+            logger.error(`Task ${taskId}: cached delivery failed (${err instanceof Error ? err.message : String(err)}). Pending file retained for next reconcile cycle.`);
+            throw err;
+        }
+        return;
+    }
     try {
-        await acceptTask(session, taskId);
+        await acceptTask(holder, taskId);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -446,9 +578,9 @@ async function handleTask(session, taskId, config, logger, identityPrivateKey) {
     }
     logger.info(`Task ${taskId}: accepted, starting work...`);
     // Get task context from task detail first, then messages as supplement
-    const detail = await getTaskDetail(session, taskId);
+    const detail = await getTaskDetail(holder, taskId);
     const taskContext = detail?.context ?? '';
-    const messages = await getTaskMessages(session, taskId);
+    const messages = await getTaskMessages(holder, taskId);
     const messageContext = messages.map((m) => m.content).join('\n');
     const context = taskContext || messageContext || 'Task assigned. No additional context provided.';
     // Compose the system prompt with the BOUND CONTRACT + REFUSAL PROTOCOL
@@ -467,14 +599,14 @@ async function handleTask(session, taskId, config, logger, identityPrivateKey) {
         : await runAgentLoop(createProvider(config.provider, config.model, config.providerApiKey), loadTools(config.allowedTools, config.workingDirectory), context, { systemPrompt: scopedSystemPrompt, taskId });
     if (result.timedOut === true) {
         logger.error(`Task ${taskId}: agent timed out or errored, notifying buyer.`);
-        await sendTaskMessage(session, taskId, 'info', 'The seller agent encountered a timeout processing this task. Please allow more time or simplify the request. The task remains assigned.');
+        await sendTaskMessage(holder, taskId, 'info', 'The seller agent encountered a timeout processing this task. Please allow more time or simplify the request. The task remains assigned.');
         saveState({ taskId, messages: [], claudeCodeContext: context, originalContext: context });
         return;
     }
     if (result.paused) {
         logger.info(`Task ${taskId}: paused, asking buyer: "${result.pendingQuestion?.slice(0, 100)}..."`);
         saveState({ taskId, messages: [], claudeCodeContext: context, pendingQuestion: result.pendingQuestion });
-        await sendTaskMessage(session, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
+        await sendTaskMessage(holder, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
         return;
     }
     // Output-side truncation: count produced units, clamp to contract, log a
@@ -485,21 +617,57 @@ async function handleTask(session, taskId, config, logger, identityPrivateKey) {
     if (truncated.events.length > 0) {
         for (const ev of truncated.events) {
             logger.info(`Task ${taskId}: scope truncation — item="${ev.itemName}" produced=${ev.producedQuantity} allowed=${ev.allowedQuantity}`);
-            await sendTaskMessage(session, taskId, 'info', `[scope-guard] Your brief requested more "${ev.itemName}" than the listing delivers. The seller agent produced ${ev.producedQuantity} but the contract allows only ${ev.allowedQuantity}. The delivery has been trimmed to the contracted quantity. To get more, hire again with a listing that covers the extra volume.`);
+            await sendTaskMessage(holder, taskId, 'info', `[scope-guard] Your brief requested more "${ev.itemName}" than the listing delivers. The seller agent produced ${ev.producedQuantity} but the contract allows only ${ev.allowedQuantity}. The delivery has been trimmed to the contracted quantity. To get more, hire again with a listing that covers the extra volume.`);
         }
     }
     logger.info(`Task ${taskId}: delivering result (${finalOutput.length} chars)`);
     const signature = identityPrivateKey !== undefined
         ? signDelivery({ taskId, content: finalOutput, privateKey: identityPrivateKey })
         : undefined;
-    await deliverTask(session, taskId, finalOutput, signature);
+    // Persist the produced bytes to disk BEFORE calling deliverTask. If the
+    // deliver fails (401, network blip, broker mid-restart), the reconcile
+    // loop will re-enter handleTask, find this file, and retry the exact
+    // same bytes — no codex re-spawn, no regeneration cost. Incident 2026-04-14.
+    savePendingDelivery({
+        taskId,
+        output: finalOutput,
+        ...(signature !== undefined ? { signature } : {}),
+        producedAt: new Date().toISOString(),
+        attempts: 0
+    });
+    try {
+        await deliverTask(holder, taskId, finalOutput, signature);
+    }
+    catch (err) {
+        incrementPendingDeliveryAttempts(taskId);
+        logger.error(`Task ${taskId}: initial deliver failed (${err instanceof Error ? err.message : String(err)}). Pending delivery file retained for reconcile retry.`);
+        throw err;
+    }
+    deletePendingDelivery(taskId);
     // Preserve state for potential revision — only deleted on terminal events
     saveState({ taskId, messages: [], claudeCodeContext: context, originalContext: context, lastDelivery: finalOutput });
 }
 // ---------------------------------------------------------------------------
 // Revision handler
 // ---------------------------------------------------------------------------
-async function handleRevision(session, taskId, feedback, config, logger, identityPrivateKey) {
+async function handleRevision(holder, taskId, feedback, config, logger, identityPrivateKey) {
+    // Recovery fast-path: same as handleTask — if a pending revision delivery
+    // exists on disk, deliver cached bytes instead of re-running codex.
+    const pending = loadPendingDelivery(taskId);
+    if (pending !== undefined) {
+        logger.info(`Task ${taskId}: pending revision delivery found on disk (${pending.output.length} chars produced at ${pending.producedAt}, attempt ${pending.attempts + 1}), delivering cached bytes directly.`);
+        incrementPendingDeliveryAttempts(taskId);
+        try {
+            await deliverTask(holder, taskId, pending.output, pending.signature);
+            deletePendingDelivery(taskId);
+            logger.info(`Task ${taskId}: cached revision delivery accepted by broker.`);
+        }
+        catch (err) {
+            logger.error(`Task ${taskId}: cached revision delivery failed (${err instanceof Error ? err.message : String(err)}). Pending file retained for next reconcile cycle.`);
+            throw err;
+        }
+        return;
+    }
     const savedState = loadState(taskId);
     // Use original task context (not compounded revision context) to avoid quadratic growth
     const originalContext = savedState?.originalContext ?? savedState?.claudeCodeContext ?? '';
@@ -519,21 +687,21 @@ async function handleRevision(session, taskId, feedback, config, logger, identit
         'Revise your work based on the buyer feedback above. Output the complete updated deliverable.'
     ].join('\n');
     // Re-fetch the frozen snapshot so revisions stay bound to the contract.
-    const revisionDetail = await getTaskDetail(session, taskId);
+    const revisionDetail = await getTaskDetail(holder, taskId);
     const revisionSystemPrompt = composeSystemPrompt(config.systemPrompt, revisionDetail?.deliverablesSnapshot);
     const result = config.provider === 'claude-code'
         ? await runClaudeCodeTask(revisionContext, { ...config, systemPrompt: revisionSystemPrompt }, logger)
         : await runAgentLoop(createProvider(config.provider, config.model, config.providerApiKey), loadTools(config.allowedTools, config.workingDirectory), revisionContext, { systemPrompt: revisionSystemPrompt, taskId });
     if (result.timedOut === true) {
         logger.error(`Task ${taskId}: revision timed out, notifying buyer.`);
-        await sendTaskMessage(session, taskId, 'info', 'The seller agent timed out while working on the revision. Please allow more time or simplify the request.');
+        await sendTaskMessage(holder, taskId, 'info', 'The seller agent timed out while working on the revision. Please allow more time or simplify the request.');
         saveState({ taskId, messages: [], claudeCodeContext: revisionContext, originalContext });
         return;
     }
     if (result.paused) {
         logger.info(`Task ${taskId}: revision paused, asking buyer...`);
         saveState({ taskId, messages: [], claudeCodeContext: revisionContext, originalContext, pendingQuestion: result.pendingQuestion });
-        await sendTaskMessage(session, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
+        await sendTaskMessage(holder, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
         return;
     }
     const truncatedRevision = truncateToContract(result.output, revisionDetail?.deliverablesSnapshot);
@@ -541,14 +709,32 @@ async function handleRevision(session, taskId, feedback, config, logger, identit
     if (truncatedRevision.events.length > 0) {
         for (const ev of truncatedRevision.events) {
             logger.info(`Task ${taskId}: revision scope truncation — item="${ev.itemName}" produced=${ev.producedQuantity} allowed=${ev.allowedQuantity}`);
-            await sendTaskMessage(session, taskId, 'info', `[scope-guard] Revision trimmed: "${ev.itemName}" produced ${ev.producedQuantity}, contract allows ${ev.allowedQuantity}.`);
+            await sendTaskMessage(holder, taskId, 'info', `[scope-guard] Revision trimmed: "${ev.itemName}" produced ${ev.producedQuantity}, contract allows ${ev.allowedQuantity}.`);
         }
     }
     logger.info(`Task ${taskId}: delivering revision (${finalRevisionOutput.length} chars)`);
     const revisionSignature = identityPrivateKey !== undefined
         ? signDelivery({ taskId, content: finalRevisionOutput, privateKey: identityPrivateKey })
         : undefined;
-    await deliverTask(session, taskId, finalRevisionOutput, revisionSignature);
+    // Persist produced revision bytes before calling deliverTask. Same
+    // rationale as handleTask: a broker restart or 401 after retry should
+    // not waste another codex run on regeneration.
+    savePendingDelivery({
+        taskId,
+        output: finalRevisionOutput,
+        ...(revisionSignature !== undefined ? { signature: revisionSignature } : {}),
+        producedAt: new Date().toISOString(),
+        attempts: 0
+    });
+    try {
+        await deliverTask(holder, taskId, finalRevisionOutput, revisionSignature);
+    }
+    catch (err) {
+        incrementPendingDeliveryAttempts(taskId);
+        logger.error(`Task ${taskId}: initial revision deliver failed (${err instanceof Error ? err.message : String(err)}). Pending delivery file retained for reconcile retry.`);
+        throw err;
+    }
+    deletePendingDelivery(taskId);
     saveState({ taskId, messages: [], claudeCodeContext: revisionContext, originalContext, lastDelivery: finalRevisionOutput });
 }
 // ---------------------------------------------------------------------------
@@ -564,7 +750,7 @@ function buildResumedContext(priorContext, priorQuestion, buyerAnswer) {
         'Continue the task with this new information.'
     ].join('\n');
 }
-async function handleBuyerMessage(session, taskId, config, logger, identityPrivateKey) {
+async function handleBuyerMessage(holder, taskId, config, logger, identityPrivateKey) {
     const savedState = loadState(taskId);
     if (savedState === undefined) {
         logger.info(`Task ${taskId}: no saved state found, ignoring message.`);
@@ -574,10 +760,10 @@ async function handleBuyerMessage(session, taskId, config, logger, identityPriva
     // Guide them to use zyndo_request_revision for the formal revision flow.
     if (savedState.lastDelivery !== undefined && savedState.pendingQuestion === undefined) {
         logger.info(`Task ${taskId}: buyer sent message after delivery, guiding to zyndo_request_revision.`);
-        await sendTaskMessage(session, taskId, 'info', 'I received your message. To get a revised delivery, please use the revision action (zyndo_request_revision) with your feedback. I will then rework and re-deliver.');
+        await sendTaskMessage(holder, taskId, 'info', 'I received your message. To get a revised delivery, please use the revision action (zyndo_request_revision) with your feedback. I will then rework and re-deliver.');
         return;
     }
-    const messages = await getTaskMessages(session, taskId);
+    const messages = await getTaskMessages(holder, taskId);
     const lastMessage = messages[messages.length - 1];
     if (lastMessage === undefined)
         return;
@@ -596,7 +782,7 @@ async function handleBuyerMessage(session, taskId, config, logger, identityPriva
     }
     if (result.timedOut === true) {
         logger.error(`Task ${taskId}: message-resume timed out, notifying buyer.`);
-        await sendTaskMessage(session, taskId, 'info', 'The seller agent timed out while processing your response. Please allow more time or simplify the request.');
+        await sendTaskMessage(holder, taskId, 'info', 'The seller agent timed out while processing your response. Please allow more time or simplify the request.');
         return;
     }
     if (result.paused) {
@@ -605,14 +791,30 @@ async function handleBuyerMessage(session, taskId, config, logger, identityPriva
             ? buildResumedContext(savedState.claudeCodeContext ?? '', savedState.pendingQuestion, lastMessage.content)
             : savedState.claudeCodeContext ?? '';
         saveState({ taskId, messages: [], claudeCodeContext: updatedContext, pendingQuestion: result.pendingQuestion });
-        await sendTaskMessage(session, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
+        await sendTaskMessage(holder, taskId, 'question', result.pendingQuestion ?? 'Could you clarify?');
         return;
     }
     logger.info(`Task ${taskId}: delivering result (${result.output.length} chars)`);
     const resumedSignature = identityPrivateKey !== undefined
         ? signDelivery({ taskId, content: result.output, privateKey: identityPrivateKey })
         : undefined;
-    await deliverTask(session, taskId, result.output, resumedSignature);
+    // Persist before deliver, same pattern as handleTask / handleRevision.
+    savePendingDelivery({
+        taskId,
+        output: result.output,
+        ...(resumedSignature !== undefined ? { signature: resumedSignature } : {}),
+        producedAt: new Date().toISOString(),
+        attempts: 0
+    });
+    try {
+        await deliverTask(holder, taskId, result.output, resumedSignature);
+    }
+    catch (err) {
+        incrementPendingDeliveryAttempts(taskId);
+        logger.error(`Task ${taskId}: initial resumed deliver failed (${err instanceof Error ? err.message : String(err)}). Pending delivery file retained.`);
+        throw err;
+    }
+    deletePendingDelivery(taskId);
     const resumedContext = config.provider === 'claude-code'
         ? buildResumedContext(savedState.claudeCodeContext ?? '', savedState.pendingQuestion, lastMessage.content)
         : savedState.claudeCodeContext ?? '';

package/dist/state.d.ts

@@ -21,3 +21,14 @@ export type PersistedSession = Readonly<{
 export declare function saveSession(agentId: string, reconnectToken: string): void;
 export declare function loadSession(): PersistedSession | undefined;
 export declare function clearSession(): void;
+export type PendingDelivery = Readonly<{
+    taskId: string;
+    output: string;
+    signature?: string;
+    producedAt: string;
+    attempts: number;
+}>;
+export declare function savePendingDelivery(payload: PendingDelivery): void;
+export declare function loadPendingDelivery(taskId: string): PendingDelivery | undefined;
+export declare function deletePendingDelivery(taskId: string): void;
+export declare function incrementPendingDeliveryAttempts(taskId: string): void;

package/dist/state.js

@@ -84,3 +84,38 @@ export function clearSession() {
         unlinkSync(getSessionFile());
     }
 }
+const PENDING_DELIVERY_DIR = resolve(getBaseDir(), 'pending-deliveries');
+function pendingDeliveryFile(taskId) {
+    return resolve(PENDING_DELIVERY_DIR, `task-${sanitizeTaskId(taskId)}.json`);
+}
+export function savePendingDelivery(payload) {
+    mkdirSync(PENDING_DELIVERY_DIR, { recursive: true });
+    writeFileSync(pendingDeliveryFile(payload.taskId), JSON.stringify(payload, null, 2), 'utf-8');
+}
+export function loadPendingDelivery(taskId) {
+    const path = pendingDeliveryFile(taskId);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const raw = readFileSync(path, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.taskId !== 'string' || typeof parsed.output !== 'string')
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function deletePendingDelivery(taskId) {
+    const path = pendingDeliveryFile(taskId);
+    if (existsSync(path)) {
+        unlinkSync(path);
+    }
+}
+export function incrementPendingDeliveryAttempts(taskId) {
+    const existing = loadPendingDelivery(taskId);
+    if (existing === undefined)
+        return;
+    savePendingDelivery({ ...existing, attempts: existing.attempts + 1 });
+}

package/package.json

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