@ziggs-ai/agent-sdk 0.7.0 → 0.7.2

package/dist/runtime/runTurn.js

@@ -65,7 +65,15 @@ export async function runTurn(input) {
             return eff({ ...effect, runId, stateId, wakeKeys });
         }
         if (effect.kind === 'send-message' && !effect.messageId) {
-            return eff({ ...effect, messageId: wakeKeys?.messageKey() });
+            const send = effect;
+            return eff({
+                ...effect,
+                messageId: wakeKeys?.messageKey({
+                    text: send.text,
+                    sessionId: send.sessionId,
+                    receiverId: send.receiverId,
+                }),
+            });
         }
         return eff(effect);
     };
@@ -316,11 +324,12 @@ export async function runTurn(input) {
             const inboundFromAgent = String(incomingEvent?.senderType || '').toUpperCase() === 'AGENT';
             runtimeLog.info('runTurn', `streaming check: enabled=${streamRespondActions} receiverId=${decision.receiverId ?? 'none'} tool=${actionDef?.tool ?? 'none'} action=${chosenAction} inboundFromAgent=${inboundFromAgent}`);
             if (streamRespondActions && !inboundFromAgent && decision.receiverId && !actionDef?.tool && chosenAction !== 'wait') {
-                // Wake-derived when the wake has a durable identity: a crash-replay
-                // streams and persists under the SAME id, so the backend's
-                // (chatId, messageId) dedup drops the duplicate reply (ZIG-718).
-                const streamMessageId = wakeKeys?.messageKey() ?? crypto.randomUUID();
-                runtimeLog.info('runTurn', `stream-text start action=${chosenAction} receiverId=${decision.receiverId} msgId=${streamMessageId}`);
+                // Live chunks use a provisional id (text not known yet). The persisted
+                // send below switches to a content-derived wake key (ZIG-1045) once the
+                // reply text exists — a crash-replay of the same text reuses that key
+                // (ZIG-718), and a re-think with different text does not collide.
+                const chunkMessageId = crypto.randomUUID();
+                runtimeLog.info('runTurn', `stream-text start action=${chosenAction} receiverId=${decision.receiverId} msgId=${chunkMessageId}`);
                 const streamMessages = [
                     ...messages,
                     {
@@ -334,7 +343,7 @@ export async function runTurn(input) {
                 ];
                 let replyText = '';
                 try {
-                    const streamResult = await eff({ kind: 'stream-text', sessionId, receiverId: decision.receiverId, messageId: streamMessageId, messages: streamMessages });
+                    const streamResult = await eff({ kind: 'stream-text', sessionId, receiverId: decision.receiverId, messageId: chunkMessageId, messages: streamMessages });
                     replyText = streamResult.text ?? '';
                     // Count the streamed reply only when it actually produced the text we
                     // send (an empty resolve falls through to the llm-call fallback below,
@@ -356,6 +365,7 @@ export async function runTurn(input) {
                     // llm-call + send-message below so the user still gets a reply.
                     runtimeLog.error('runTurn', `stream-text failed: ${err.message} — falling back to non-streaming send`);
                 }
+                let persistMessageId = chunkMessageId;
                 try {
                     if (!replyText) {
                         const fallbackResponse = await effWithTrace({ kind: 'llm-call', messages: streamMessages, tools: [], sessionId });
@@ -369,16 +379,20 @@ export async function runTurn(input) {
                             throw new Error('fallback llm-call returned empty reply text');
                     }
                     const safeText = truncateMsg(replyText);
-                    // Reuse streamMessageId so any partial chunks already streamed to
-                    // the client reconcile against the final persisted message.
-                    await eff({ kind: 'send-message', sessionId, receiverId: decision.receiverId, text: safeText, messageId: streamMessageId });
+                    persistMessageId =
+                        wakeKeys?.messageKey({
+                            text: safeText,
+                            sessionId,
+                            receiverId: decision.receiverId,
+                        }) ?? chunkMessageId;
+                    await eff({ kind: 'send-message', sessionId, receiverId: decision.receiverId, text: safeText, messageId: persistMessageId });
                     allEmittedEvents.push({ type: 'message_sent', receiverId: decision.receiverId, chatId: sessionId, message: safeText, senderId: 'system' });
                     lastAction = chosenAction;
                     lastActionDef = actionDef;
                 }
                 catch (err) {
                     if (isReplySlotTaken(err)) {
-                        runtimeLog.warn('runTurn', `reply already persisted under ${streamMessageId} (idempotency 409) — a replay or second host answered this wake first; dropping duplicate`);
+                        runtimeLog.warn('runTurn', `reply already persisted under ${persistMessageId} (idempotency 409) — a replay or second host answered this wake first; dropping duplicate`);
                         allEmittedEvents.push({ type: 'message_duplicate_skipped', receiverId: decision.receiverId, chatId: sessionId, senderId: 'system' });
                         lastAction = chosenAction;
                         lastActionDef = actionDef;

package/dist/runtime/taskBookkeeping.d.ts

@@ -0,0 +1,35 @@
+import type { Ctx, TaskBookkeeping } from '../types.js';
+/**
+ * Reserved key for coordinator-side pending/collected state when the lane has
+ * an active agreement but no assigned parent task yet (kickoff → spawn).
+ * Never deleted by task-closed of a real taskId (ZIG-977).
+ */
+export declare const LANE_BOOK_KEY = "__lane__";
+export declare function emptyTaskBook(agreementId?: string | null): TaskBookkeeping;
+export declare function ensureTaskBook(ctx: Ctx, taskId: string, agreementId?: string | null): TaskBookkeeping;
+/** Focus task's book, or null when nothing is focused / missing. */
+export declare function focusTaskBook(ctx: Ctx): TaskBookkeeping | null;
+/**
+ * Book that receives task-delegated / subtask-finished when we know the parent
+ * engagement: focus task if assigned, else the coordinator lane bucket.
+ */
+export declare function bookForDelegation(ctx: Ctx): TaskBookkeeping;
+/** Find which engagement is awaiting this child taskId. */
+export declare function findBookHoldingPending(ctx: Ctx, childTaskId: string): TaskBookkeeping | null;
+export declare function allCollectedResults(ctx: Ctx): TaskBookkeeping['collectedResults'];
+export declare function allPendingSubtasks(ctx: Ctx): Record<string, TaskBookkeeping['pendingSubtasks'][string]>;
+export declare function allDelegatedAgreementIds(ctx: Ctx): string[];
+export declare function hasOpenTaskForAgreement(ctx: Ctx, agreementId: string): boolean;
+export declare function hasDelegatedAgreement(ctx: Ctx, agreementId: string): boolean;
+/**
+ * Remove one task's bookkeeping and retarget focus if we just closed the
+ * focused task. Leaves sibling entries (and the coordinator lane bucket) alone.
+ */
+export declare function removeTaskBook(ctx: Ctx, taskId: string): void;
+/** Refresh deprecated aggregate views from the per-task map. */
+export declare function syncAggregateTaskViews(ctx: Ctx): void;
+/**
+ * Migrate a pre-ZIG-977 persisted ctx (lane-level pendingSubtasks /
+ * collectedResults / delegatedAgreementIds) into the tasks map.
+ */
+export declare function migrateLegacyTaskFields(existing: Record<string, unknown>): Record<string, TaskBookkeeping>;

package/dist/runtime/taskBookkeeping.js

@@ -0,0 +1,149 @@
+/**
+ * Reserved key for coordinator-side pending/collected state when the lane has
+ * an active agreement but no assigned parent task yet (kickoff → spawn).
+ * Never deleted by task-closed of a real taskId (ZIG-977).
+ */
+export const LANE_BOOK_KEY = '__lane__';
+export function emptyTaskBook(agreementId = null) {
+    return {
+        agreementId,
+        pendingSubtasks: {},
+        collectedResults: [],
+        delegatedAgreementIds: [],
+    };
+}
+export function ensureTaskBook(ctx, taskId, agreementId) {
+    if (!ctx.tasks)
+        ctx.tasks = {};
+    let book = ctx.tasks[taskId];
+    if (!book) {
+        book = emptyTaskBook(agreementId ?? null);
+        ctx.tasks[taskId] = book;
+    }
+    else if (agreementId && !book.agreementId) {
+        book.agreementId = agreementId;
+    }
+    return book;
+}
+/** Focus task's book, or null when nothing is focused / missing. */
+export function focusTaskBook(ctx) {
+    if (!ctx.activeTaskId)
+        return null;
+    return ctx.tasks?.[ctx.activeTaskId] ?? null;
+}
+/**
+ * Book that receives task-delegated / subtask-finished when we know the parent
+ * engagement: focus task if assigned, else the coordinator lane bucket.
+ */
+export function bookForDelegation(ctx) {
+    if (ctx.activeTaskId) {
+        return ensureTaskBook(ctx, ctx.activeTaskId, ctx.activeAgreementId);
+    }
+    const book = ensureTaskBook(ctx, LANE_BOOK_KEY, ctx.activeAgreementId);
+    if (ctx.activeAgreementId && !book.agreementId)
+        book.agreementId = ctx.activeAgreementId;
+    return book;
+}
+/** Find which engagement is awaiting this child taskId. */
+export function findBookHoldingPending(ctx, childTaskId) {
+    if (!ctx.tasks)
+        return null;
+    for (const book of Object.values(ctx.tasks)) {
+        if (childTaskId in book.pendingSubtasks)
+            return book;
+    }
+    return null;
+}
+export function allCollectedResults(ctx) {
+    if (!ctx.tasks)
+        return [];
+    const out = [];
+    for (const book of Object.values(ctx.tasks)) {
+        out.push(...book.collectedResults);
+    }
+    return out;
+}
+export function allPendingSubtasks(ctx) {
+    if (!ctx.tasks)
+        return {};
+    const out = {};
+    for (const book of Object.values(ctx.tasks)) {
+        Object.assign(out, book.pendingSubtasks);
+    }
+    return out;
+}
+export function allDelegatedAgreementIds(ctx) {
+    if (!ctx.tasks)
+        return [];
+    const ids = [];
+    for (const book of Object.values(ctx.tasks)) {
+        for (const id of book.delegatedAgreementIds) {
+            if (!ids.includes(id))
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+export function hasOpenTaskForAgreement(ctx, agreementId) {
+    if (!agreementId || !ctx.tasks)
+        return false;
+    return Object.entries(ctx.tasks).some(([key, book]) => key !== LANE_BOOK_KEY && book.agreementId === agreementId);
+}
+export function hasDelegatedAgreement(ctx, agreementId) {
+    return allDelegatedAgreementIds(ctx).includes(agreementId);
+}
+/**
+ * Remove one task's bookkeeping and retarget focus if we just closed the
+ * focused task. Leaves sibling entries (and the coordinator lane bucket) alone.
+ */
+export function removeTaskBook(ctx, taskId) {
+    if (!taskId || !ctx.tasks)
+        return;
+    delete ctx.tasks[taskId];
+    if (ctx.activeTaskId === taskId) {
+        const nextId = Object.keys(ctx.tasks).find((id) => id !== LANE_BOOK_KEY) ?? null;
+        ctx.activeTaskId = nextId;
+        ctx.activeAgreementId = nextId ? (ctx.tasks[nextId]?.agreementId ?? null) : null;
+    }
+}
+/** Refresh deprecated aggregate views from the per-task map. */
+export function syncAggregateTaskViews(ctx) {
+    ctx.pendingSubtasks = allPendingSubtasks(ctx);
+    ctx.collectedResults = allCollectedResults(ctx);
+    ctx.delegatedAgreementIds = allDelegatedAgreementIds(ctx);
+}
+/**
+ * Migrate a pre-ZIG-977 persisted ctx (lane-level pendingSubtasks /
+ * collectedResults / delegatedAgreementIds) into the tasks map.
+ */
+export function migrateLegacyTaskFields(existing) {
+    if (existing.tasks && typeof existing.tasks === 'object') {
+        return existing.tasks;
+    }
+    const tasks = {};
+    const activeTaskId = existing.activeTaskId ?? null;
+    const activeAgreementId = existing.activeAgreementId ?? null;
+    const pendingSubtasks = existing.pendingSubtasks ?? {};
+    const collectedResults = existing.collectedResults ?? [];
+    const delegatedAgreementIds = existing.delegatedAgreementIds ?? [];
+    const hasLegacy = Object.keys(pendingSubtasks).length > 0 ||
+        collectedResults.length > 0 ||
+        delegatedAgreementIds.length > 0;
+    if (activeTaskId) {
+        tasks[activeTaskId] = {
+            agreementId: activeAgreementId,
+            pendingSubtasks,
+            collectedResults,
+            delegatedAgreementIds: [...delegatedAgreementIds],
+        };
+    }
+    else if (hasLegacy) {
+        tasks[LANE_BOOK_KEY] = {
+            agreementId: activeAgreementId,
+            pendingSubtasks,
+            collectedResults,
+            delegatedAgreementIds: [...delegatedAgreementIds],
+        };
+    }
+    return tasks;
+}

package/dist/runtime/taskIntake.js

@@ -35,7 +35,7 @@ export function buildTaskIntakeState(initial) {
         prompt: {
             role: 'A task was just assigned to you under one of your active agreements, and your workflow has no explicit route for it. This injected default exists so an assigned task is NEVER silently dropped — under a standing hire, new tasks keep arriving for the lifetime of the agreement.',
             goal: 'Resolve the assigned task this turn: deliver the result if you can produce it, otherwise fail it with a reason.',
-            constraints: 'The task is in <event> (and as activeTaskId / activeAgreementId in <machine_context>). If the deliverable can be produced in this turn (an answer, summary, plan, draft — most representation work), call task_set_result with status "completed" and the deliverable as result — the result is what the counterparty consumes, so make it the actual deliverable, not a status note. If the task genuinely needs abilities or tools you do not have, call task_set_result with status "failed" and a one-line reason — a visible failure the counterparty can re-route beats a silent drop. Never leave the task dangling or answer with a chat message alone.',
+            constraints: 'The task is in <event> (and as activeTaskId / activeAgreementId in <machine_context>). If the deliverable can be produced in this turn (an answer, summary, plan, draft — most representation work), call task_set_result with state "completed" and the deliverable as result — the result is what the counterparty consumes, so make it the actual deliverable, not a status note. If the task genuinely needs abilities or tools you do not have, call task_set_result with state "failed" and a one-line reason — a visible failure the counterparty can re-route beats a silent drop. Never leave the task dangling or answer with a chat message alone.',
         },
         actions: {
             ...dflt.actions,
@@ -43,7 +43,7 @@ export function buildTaskIntakeState(initial) {
                 prompt: {
                     when: 'You can produce the deliverable for the assigned task in this turn.',
                     instruction: 'Complete the assigned task, with the deliverable itself as the result.',
-                    format: '{"taskId": "<assigned task id from <event>>", "status": "completed", "result": "<the full deliverable>"}',
+                    format: '{"taskId": "<assigned task id from <event>>", "state": "completed", "result": "<the full deliverable>"}',
                 },
                 tool: 'task_set_result',
                 // Function form so a failed task_set_result surfaces as an error outcome
@@ -59,7 +59,7 @@ export function buildTaskIntakeState(initial) {
                 prompt: {
                     when: 'The task needs abilities, tools, or information you cannot obtain this turn.',
                     instruction: 'Fail the assigned task with a one-line reason so the counterparty can re-route it.',
-                    format: '{"taskId": "<assigned task id from <event>>", "status": "failed", "result": "<one-line reason>"}',
+                    format: '{"taskId": "<assigned task id from <event>>", "state": "failed", "result": "<one-line reason>"}',
                 },
                 tool: 'task_set_result',
                 produces: (result) => {

package/dist/runtime/wakeWriteKeys.d.ts

@@ -9,11 +9,13 @@ import type { WakeWriteKeys } from '../types.js';
  * - task transitions: `wk_<wake-hash>_t_<hash(taskId, state)>` — derived from
  *   the transition itself, so it dedups regardless of the order in which the
  *   replayed wake happens to re-issue its tool calls.
- * - chat messages:    `sdk_idem_wk_<wake-hash>_m<ordinal>` — used directly as
- *   the messageId (the backend dedups on (chatId, messageId), ZIG-718), drawn
- *   from the same ordinal stream as artifacts so one counter keys the wake's
- *   whole write sequence. The prefix matches the tool-layer convention for
- *   deterministic ids (`sdk_idem_<llm-key>`).
+ * - chat messages:    `sdk_idem_wk_<wake-hash>_m_<hash(chat, receiver, text)>`
+ *   — used directly as the messageId (the backend dedups on (chatId, messageId),
+ *   ZIG-718). Content-derived (ZIG-1045), not ordinal: a wake may emit several
+ *   distinct messages without colliding, and a crash-replay that re-sends the
+ *   same text reuses the key; a re-think with different text gets a new key
+ *   instead of 409-dropping on the old ordinal slot. The prefix matches the
+ *   tool-layer convention for deterministic ids (`sdk_idem_<llm-key>`).
  * - task spawns:      `wk_<wake-hash>_s_<hash(agreement, description, …)>` —
  *   derived from what the spawn writes, so it dedups regardless of re-issue
  *   order while still distinguishing multiple spawns in one wake.

package/dist/runtime/wakeWriteKeys.js

@@ -78,11 +78,13 @@ function sha(input) {
  * - task transitions: `wk_<wake-hash>_t_<hash(taskId, state)>` — derived from
  *   the transition itself, so it dedups regardless of the order in which the
  *   replayed wake happens to re-issue its tool calls.
- * - chat messages:    `sdk_idem_wk_<wake-hash>_m<ordinal>` — used directly as
- *   the messageId (the backend dedups on (chatId, messageId), ZIG-718), drawn
- *   from the same ordinal stream as artifacts so one counter keys the wake's
- *   whole write sequence. The prefix matches the tool-layer convention for
- *   deterministic ids (`sdk_idem_<llm-key>`).
+ * - chat messages:    `sdk_idem_wk_<wake-hash>_m_<hash(chat, receiver, text)>`
+ *   — used directly as the messageId (the backend dedups on (chatId, messageId),
+ *   ZIG-718). Content-derived (ZIG-1045), not ordinal: a wake may emit several
+ *   distinct messages without colliding, and a crash-replay that re-sends the
+ *   same text reuses the key; a re-think with different text gets a new key
+ *   instead of 409-dropping on the old ordinal slot. The prefix matches the
+ *   tool-layer convention for deterministic ids (`sdk_idem_<llm-key>`).
  * - task spawns:      `wk_<wake-hash>_s_<hash(agreement, description, …)>` —
  *   derived from what the spawn writes, so it dedups regardless of re-issue
  *   order while still distinguishing multiple spawns in one wake.
@@ -107,10 +109,11 @@ export function createWakeWriteKeys(laneKey, event) {
                 return undefined;
             return `wk_${wakeHash}_t_${sha(`${taskId}\n${state}`).slice(0, 16)}`;
         },
-        messageKey() {
+        messageKey(fields) {
             if (wakeHash === null)
                 return undefined;
-            return `sdk_idem_wk_${wakeHash}_m${ordinal++}`;
+            const msgHash = sha(`${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`).slice(0, 16);
+            return `sdk_idem_wk_${wakeHash}_m_${msgHash}`;
         },
         taskSpawnKey(fields) {
             if (wakeHash === null)

package/dist/server/ZiggsEffectHandler.js

@@ -1,5 +1,6 @@
 import { OutboxBuffer } from './OutboxBuffer.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
+import { artifactScopeForSession } from '@ziggs-ai/api-client';
 import { buildLlmIngestPayload, buildToolIngestPayload, isTelemetryIngestEnabled, sendTelemetry, } from './telemetryIngest.js';
 const CONTEXT_CACHE_MAX = 256;
 /**
@@ -69,12 +70,15 @@ function previewToolArgs(args) {
  * Chat timeline: `Message.tsx` parses `entryType: artifact`, `content_type: operation` with
  * `operation_*:{json}` where json includes `state` and `tool`.
  */
-async function emitToolOperationArtifact(client, chatId, phase, payload, idempotencyKey) {
+async function emitToolOperationArtifact(client, sessionId, phase, payload, idempotencyKey) {
     const prefix = phase === 'started' ? 'operation_started' : phase === 'completed' ? 'operation_completed' : 'operation_error';
     const text = `${prefix}:${JSON.stringify(payload)}`;
     try {
         await client.write({
-            chatId,
+            // ZIG-1032: an agreement lane (`agrn-…`) is a routing key, not a chat —
+            // passing it as chatId asked the backend to write into a chat that does
+            // not exist and 403'd every breadcrumb on agreement-lane work.
+            ...artifactScopeForSession(sessionId),
             text,
             content_type: 'operation',
             visibility: 'agent-private',
@@ -296,7 +300,7 @@ export function createZiggsEffectHandler(deps) {
                     }
                     else {
                         await deps.artifactsClient.write({
-                            chatId: effect.sessionId,
+                            ...artifactScopeForSession(effect.sessionId),
                             text: JSON.stringify(effect.entry),
                             content_type: String(effect.entry.kind ?? 'event'),
                             visibility: 'agent-private',

package/dist/server/tools/tier1/protocolRunner.d.ts

@@ -1,7 +1,7 @@
 import type { AgreementService } from '../../agreements/AgreementService.js';
 import type { TaskService } from '../../tasks/TaskService.js';
 import type { WakeWriteKeys } from '../../../types.js';
-import type { ContextReadClient } from '@ziggs-ai/api-client';
+import { type ContextReadClient } from '@ziggs-ai/api-client';
 interface Services {
     agreementService: AgreementService;
     taskService: TaskService;

package/dist/server/tools/tier1/protocolRunner.js

@@ -1,4 +1,17 @@
+import { linkSummary, } from '@ziggs-ai/api-client';
 import { applyFleetCounterPricing, applyFleetPricingForProtocol, } from '../../../pricing/fleetDefaults.js';
+/**
+ * ZIG-957 — same summary shape as MCP link mutations / link_* tools.
+ * Raw Mongo money/approvals noise must not reach the LLM on a trust link.
+ */
+function shapeAgreementResult(agreement) {
+    if (!agreement)
+        return agreement;
+    return agreement.engagementKind === 'link' ? linkSummary(agreement) : agreement;
+}
+function shapeRevokeResult(result) {
+    return { ...result, agreement: shapeAgreementResult(result.agreement) };
+}
 // Map legacy task-state aliases onto the canonical set.
 function normalizeState(state) {
     if (state === 'done')
@@ -49,12 +62,17 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
         case 'agreement-respond':
             if (!payload.agreementId || !payload.action)
                 return null;
-            return agreementService.respond(payload.agreementId, payload.action);
-        case 'agreement-claim':
+            return shapeAgreementResult(await agreementService.respond(payload.agreementId, payload.action));
+        case 'agreement-claim': {
             // ZIG-1021: the one claim verb — quest, standing offer, or link invite.
             if (!payload.agreementId)
                 throw new Error('agreement-claim requires `agreementId`');
-            return agreementService.claim(payload.agreementId);
+            const claimed = await agreementService.claim(payload.agreementId);
+            return {
+                ...claimed,
+                agreement: shapeAgreementResult(claimed.agreement),
+            };
+        }
         case 'agreement-counter-proposal':
             if (!payload.agreementId)
                 return null;
@@ -81,11 +99,11 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
         case 'agreement-revoke':
             if (!payload.agreementId)
                 return null;
-            return agreementService.revoke(payload.agreementId);
+            return shapeRevokeResult(await agreementService.revoke(payload.agreementId));
         case 'agreement-fulfill':
             if (!payload.agreementId)
                 return null;
-            return agreementService.fulfill(payload.agreementId);
+            return shapeRevokeResult(await agreementService.fulfill(payload.agreementId));
         case 'task-spawn': {
             if (!payload.agreementId || !payload.description)
                 return null;
@@ -165,9 +183,14 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
             });
         }
         case 'task-update': {
-            if (!payload.taskId || !payload.status)
+            // ZIG-957: canonical tool param is `state` (MCP + REST). Accept legacy
+            // `status` so fleet prompts that still emit it keep working.
+            const terminalRaw = (typeof payload.state === 'string' && payload.state) ||
+                (typeof payload.status === 'string' && payload.status) ||
+                '';
+            if (!payload.taskId || !terminalRaw)
                 return null;
-            const state = normalizeState(payload.status);
+            const state = normalizeState(terminalRaw);
             // Wake-derived idempotency key: a crash-replay re-issuing this transition
             // no-ops server-side instead of erroring on the already-terminal task.
             return taskService.updateState(payload.taskId, state, payload.result, wakeKeys?.taskStateKey(payload.taskId, state));
@@ -205,7 +228,7 @@ async function proposeAgreement(services, payload, chatId, _agents, actingAgentI
         if (isBroadcast) {
             throw new Error('A broadcast link is an invite — use link_create_invite instead; propose links to one agent id.');
         }
-        return services.agreementService.requestLink(payload.proposedTo, payload.description);
+        return shapeAgreementResult(await services.agreementService.requestLink(payload.proposedTo, payload.description));
     }
     if (!isBroadcast && !payload.providerId) {
         throw new Error('agreement-propose requires `providerId` — name who does the work: your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient).');

package/dist/server/tools/tier1/protocolTools.js

@@ -1,5 +1,18 @@
 import { defineTool } from '../../../tools/defineTool.js';
 import { dispatchProtocolOp } from './protocolRunner.js';
+/** ZIG-957 — keep these enums in lockstep with MCP ziggs_agreement_* / ziggs_task_create. */
+const LIFECYCLE_ENUM = ['open', 'time-bound', 'count-bound'];
+const PLAN_REVIEW_TIMING_ENUM = ['with_proposal', 'before_execution'];
+const lifecycleParam = {
+    type: 'string',
+    enum: [...LIFECYCLE_ENUM],
+    description: "Usually inferred: expiresAt → 'time-bound', maxExecutions → 'count-bound', neither → 'open' (standing).",
+};
+const planReviewTimingParam = {
+    type: 'string',
+    enum: [...PLAN_REVIEW_TIMING_ENUM],
+    description: 'When the buyer reviews the plan: with_proposal | before_execution',
+};
 function handlerFor(operation) {
     return async (args, ctx) => {
         const c = ctx;
@@ -19,17 +32,26 @@ function handlerFor(operation) {
         return result;
     };
 }
-export const agreementProposeTool = defineTool('agreement_propose', { description: { type: 'string', required: true }, proposedTo: { type: 'string', required: true }, engagementKind: { type: 'string', enum: ['hire', 'service', 'link'], description: "Contract type. Defaults to service. 'link' proposes a bilateral trust link (no work, no money)." }, parentAgreementId: 'string', parentTaskId: 'string', providerId: { type: 'string', description: 'Who does the work — required on direct proposals. Pass your own id when YOU are offering to do the work, or the proposedTo id when you are commissioning the RECIPIENT (any other third party needs a matching published offer). On a broadcast: omit for a quest (the claimer works, you pay), or pass your own id to publish a standing offer (you work, the claimer pays). The payer is always derived as the non-providing side.' }, price: 'number', lifecycle: 'string', expiresAt: 'string', maxExecutions: 'number', billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only): no providerId publishes a QUEST any agent may claim; providerId = your own id publishes a STANDING OFFER (claiming is agreement_claim; browsing is marketplace_view). engagementKind "link" with proposedTo = an agent id proposes bilateral trust. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
-export const agreementSubcontractTool = defineTool('agreement_subcontract', { description: { type: 'string', required: true }, executorId: { type: 'string', required: true }, parentAgreementId: { type: 'string', required: true }, parentTaskId: 'string', payerId: 'string', price: 'number', lifecycle: 'string', expiresAt: 'string', maxExecutions: 'number', agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-subcontract'), { description: 'Delegate work to another agent under an existing parent agreement. Requires parentAgreementId.', isAgreementCreation: true });
+export const agreementProposeTool = defineTool('agreement_propose', { description: { type: 'string', required: true }, proposedTo: { type: 'string', required: true }, engagementKind: { type: 'string', enum: ['hire', 'service', 'link'], description: "Contract type. Defaults to service. 'link' proposes a bilateral trust link (no work, no money)." }, parentAgreementId: 'string', parentTaskId: 'string', providerId: { type: 'string', description: 'Who does the work — required on direct proposals. Pass your own id when YOU are offering to do the work, or the proposedTo id when you are commissioning the RECIPIENT (any other third party needs a matching published offer). On a broadcast: omit for a quest (the claimer works, you pay), or pass your own id to publish a standing offer (you work, the claimer pays). The payer is always derived as the non-providing side.' }, price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00. Quote it to a human in the same units the agreement charges.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: planReviewTimingParam, requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only): no providerId publishes a QUEST any agent may claim; providerId = your own id publishes a STANDING OFFER (claiming is agreement_claim; browsing is marketplace_view). engagementKind "link" with proposedTo = an agent id proposes bilateral trust. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
+export const agreementSubcontractTool = defineTool('agreement_subcontract', { description: { type: 'string', required: true }, executorId: { type: 'string', required: true }, parentAgreementId: { type: 'string', required: true }, parentTaskId: 'string', payerId: 'string', price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00. Quote it to a human in the same units the agreement charges.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: planReviewTimingParam, requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-subcontract'), { description: 'Delegate work to another agent under an existing parent agreement. Requires parentAgreementId.', isAgreementCreation: true });
 export const agreementRespondTool = defineTool('agreement_respond', { agreementId: { type: 'string', required: true }, action: { type: 'string', required: true, enum: ['approve', 'reject'] } }, handlerFor('agreement-respond'), { description: 'Approve or reject a pending DIRECT agreement proposal addressed to you. Open broadcasts (quests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass.' });
 export const agreementClaimTool = defineTool('agreement_claim', { agreementId: { type: 'string', required: true, description: 'The open agreement to claim (quest / offer / link invite id)' } }, handlerFor('agreement-claim'), { description: 'Claim an open broadcast agreement by id — a quest (you do the work, the publisher pays), a standing offer (you buy, the publisher works), or a link invite (bilateral trust forms immediately). You become the open party and the agreement activates. Find quests/offers with marketplace_view; direct proposals are approved with agreement_respond instead, not claimed.' });
-export const taskSetResultTool = defineTool('task_set_result', { taskId: { type: 'string', required: true }, status: { type: 'string', required: true, enum: ['completed', 'failed', 'cancelled'] }, result: 'string' }, handlerFor('task-update'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Finished work is the task result: set it here, never as a chat message. Include a result string for completed tasks.' });
-export const agreementCounterTool = defineTool('agreement_counter', { agreementId: { type: 'string', required: true }, price: 'number', agreementDescription: 'string', expiresAt: 'string', lifecycle: 'string', maxExecutions: 'number', description: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-counter-proposal'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_get.' });
+export const taskSetResultTool = defineTool('task_set_result', {
+    taskId: { type: 'string', required: true },
+    // ZIG-957: same param name as MCP ziggs_task_set_result / PATCH /tasks/:id/state.
+    state: { type: 'string', required: true, enum: ['completed', 'failed', 'cancelled'] },
+    // Same object contract as MCP ({ summary, status, links, … }).
+    result: {
+        type: 'object',
+        description: 'Outcome payload (summary, status, links, …). Finished work is the task result — never a chat message.',
+    },
+}, handlerFor('task-update'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Finished work is the task result: set it here as an object ({ summary, status, links }), never as a chat message. Pass state (not status).' });
+export const agreementCounterTool = defineTool('agreement_counter', { agreementId: { type: 'string', required: true }, price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00. Quote it to a human in the same units the agreement charges.' }, agreementDescription: 'string', expiresAt: 'string', lifecycle: lifecycleParam, maxExecutions: 'integer', description: 'string', plan: { type: 'object' }, planReviewTiming: planReviewTimingParam, requireMidWorkPlanAck: 'boolean' }, handlerFor('agreement-counter-proposal'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_get.' });
 export const agreementGetTool = defineTool('agreement_get', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-check-proposal'), { description: 'Read the current proposal status for an agreement (pending, approved, rejected, countered, expired).' });
 export const agreementRevokeTool = defineTool('agreement_revoke', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-revoke'), { description: 'Revoke a pending proposal you created so it can no longer be approved. Use when the user has clearly moved on to a different request before responding to the previous proposal card.' });
 export const agreementFulfillTool = defineTool('agreement_fulfill', { agreementId: { type: 'string', required: true } }, handlerFor('agreement-fulfill'), { description: 'END an agreement you provide — permanently. Fulfilling terminates the whole relationship, not one deliverable: every grant it conferred is revoked, its shared space is torn down, and it cannot be reopened. Finished WORK is reported via task_set_result (the task closes; the agreement stays standing for the next task). Only fulfill when the engagement\'s full scope is delivered and nothing more is expected — never a standing hire that just finished a task.' });
 export const taskUpdatePlanStepTool = defineTool('task_update_plan_step', { taskId: { type: 'string', required: true }, stepId: { type: 'string', required: true }, status: { type: 'string', required: true }, result: 'string' }, handlerFor('task-update-plan-step'), { description: "Update the status of a single step within a task's plan." });
-export const taskCreateTool = defineTool('task_create', { agreementId: { type: 'string', required: true }, description: { type: 'string', required: true }, parentTaskId: 'string', assigneeId: { type: 'string', description: 'Explicitly hand this task to one specific agent (e.g. a worker your orchestrator selected via agent search) instead of leaving it unassigned. Must be a party on the agreement (payer, provider, creator, or creator agent).' }, inputArtifactIds: { type: 'array', items: { type: 'string' }, description: 'ZIG-734: prior-step output artifact handles for structured input links.' }, plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' }, handlerFor('task-spawn'), { description: 'Create a new task under an existing approved agreement. Use when the contract is already in place. Pass assigneeId to delegate the task to a specific agent rather than leaving it open.' });
+export const taskCreateTool = defineTool('task_create', { agreementId: { type: 'string', required: true }, description: { type: 'string', required: true }, parentTaskId: 'string', assigneeId: { type: 'string', description: 'Explicitly hand this task to one specific agent (e.g. a worker your orchestrator selected via agent search) instead of leaving it unassigned. Must be a party on the agreement (payer, provider, creator, or creator agent).' }, inputArtifactIds: { type: 'array', items: { type: 'string' }, description: 'ZIG-734: prior-step output artifact handles for structured input links.' }, plan: { type: 'object' }, planReviewTiming: planReviewTimingParam, requireMidWorkPlanAck: 'boolean' }, handlerFor('task-spawn'), { description: 'Create a new task under an existing approved agreement. Use when the contract is already in place. Pass assigneeId to delegate the task to a specific agent rather than leaving it open.' });
 export const PROTOCOL_TOOLS = [
     agreementProposeTool, agreementSubcontractTool,
     agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool,

package/dist/types.d.ts

@@ -70,6 +70,8 @@ export type Outcome = {
 } | {
     kind: 'task-closed';
     status: 'completed' | 'failed';
+    /** Task being closed — required to clear only that entry (ZIG-977). */
+    taskId?: string;
     result?: unknown;
 } | {
     kind: 'subtask-finished';
@@ -151,23 +153,49 @@ export interface CollectedSubtaskResult {
     /** task.result from the finishing event; null when the event carried none. */
     result: unknown;
 }
+/**
+ * Per-assigned-task (or coordinator-lane) bookkeeping under one chat lane.
+ * Keyed on Ctx.tasks by taskId (ZIG-977) — task-closed clears only its entry.
+ */
+export interface TaskBookkeeping {
+    agreementId: string | null;
+    /** Spawned-but-unfinished children of this engagement, keyed by child taskId. */
+    pendingSubtasks: Record<string, PendingSubtask>;
+    /** Finished children of this engagement, arrival order. */
+    collectedResults: CollectedSubtaskResult[];
+    /** Sub-agreement ids recorded on task-delegated under this engagement. */
+    delegatedAgreementIds: string[];
+}
 /**
  * Per-lane runtime state. Outcome is "what just happened"; Ctx is "what I know."
  *
- * Persistent identifiers (activeAgreementId, pendingProposalAgreementId,
- * pendingSubtasks) survive across outcomes — they're the memory of which
- * agreement the agent is currently bound to and which subtasks it's awaiting.
+ * Task bookkeeping lives in `tasks` (keyed by taskId). `activeTaskId` /
+ * `activeAgreementId` are the focus scalars for prompt + FSM convenience —
+ * assigning task B no longer destroys task A's pending/collected state, and
+ * closing A leaves B intact (ZIG-977).
  */
 export interface Ctx {
     identity: Identity;
-    activeAgreementId: string | null;
+    /**
+     * Open engagements in this lane, keyed by taskId (assigned work) or the
+     * reserved coordinator bucket (see LANE_BOOK_KEY) when spawning without an
+     * assigned parent task.
+     */
+    tasks: Record<string, TaskBookkeeping>;
+    /** Focus task — most recently assigned; prompts/FSM read this. */
     activeTaskId: string | null;
+    /** Focus agreement — sync'd with tasks[activeTaskId] when a task is focused. */
+    activeAgreementId: string | null;
     pendingProposalAgreementId: string | null;
-    delegatedAgreementIds: string[];
-    /** Durable barrier for orchestration: every spawned-but-unfinished subtask, keyed by taskId. */
+    /**
+     * Aggregate views over `tasks` (all engagements in the lane). Kept in sync by
+     * applyOutcomeToCtx / bootstrapCtx so existing workflow `when` guards that
+     * read these fields (e.g. motifs awaitingAll) keep working after ZIG-977.
+     * Prefer reading `tasks[taskId]` when you need per-task isolation.
+     */
     pendingSubtasks: Record<string, PendingSubtask>;
-    /** Every finished subtask of the current engagement, arrival order. Synthesis prompts render ALL of these. */
     collectedResults: CollectedSubtaskResult[];
+    delegatedAgreementIds: string[];
     toolResults: ToolResultEntry[];
     lastOutcome: Outcome;
     /** Claude Agent SDK session id for resume across ticks (claude-sdk cognition only). */
@@ -361,8 +389,18 @@ export interface WakeWriteKeys {
     artifactKey(): string | undefined;
     /** Key for a task state transition. Derived from (taskId, state), so it is stable regardless of tool-call order within the wake. */
     taskStateKey(taskId: string, state: string): string | undefined;
-    /** Default messageId for the next chat-message send of this wake — the backend dedups on (chatId, messageId). Draws the same per-wake ordinal as artifactKey — call exactly once per send, at the call site. */
-    messageKey(): string | undefined;
+    /**
+     * Default messageId for a chat-message send of this wake — the backend dedups
+     * on (chatId, messageId). Derived from the emission's content (text + chat +
+     * receiver), not a per-wake ordinal (ZIG-1045): a wake that says two things
+     * gets two keys, and a redelivered wake that re-says the same text reuses the
+     * same key, while a re-think with different text does not collide and drop.
+     */
+    messageKey(fields: {
+        text: string;
+        sessionId?: string;
+        receiverId?: string;
+    }): string | undefined;
     /** Key for a task spawn. Derived from what the spawn writes (agreement, description, assignee, parent), so it is stable regardless of tool-call order within the wake. */
     taskSpawnKey(fields: {
         agreementId: string;