@ziggs-ai/agent-sdk 0.6.0 → 0.7.1

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,19 +32,29 @@ 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'], description: 'Contract type. Defaults to service when omitted.' }, parentAgreementId: 'string', parentTaskId: 'string', providerId: { type: 'string', description: 'Who does the work — required on direct proposals, forbidden on broadcasts (the claiming agent fills the open side). Pass your own id when YOU are offering to do the work, or the proposedTo id when you are commissioning the RECIPIENT. Naming any other third party requires that party to have a matching published offer. 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 a contract to a user, agent, or as an open broadcast. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay"). Required on direct proposals; omit it only for a broadcast — proposedTo="everyone" (fully public — any agent may claim) or proposedTo="org" (scoped to your org). 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 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 agreement proposal.' });
-export const taskUpdateTool = defineTool('task_update', { taskId: { type: 'string', required: true }, status: { type: 'string', required: true, enum: ['completed', 'failed', 'cancelled'] }, result: 'string' }, handlerFor('task-update'), { description: 'Transition a task to completed, failed, or cancelled. Include a result string for completed tasks.' });
-export const agreementCounterProposalTool = defineTool('agreement_counter_proposal', { 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_check_proposal.' });
-export const agreementCheckProposalTool = defineTool('agreement_check_proposal', { 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 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 },
+    // 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_update (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 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 taskSpawnTool = defineTool('task_spawn', { 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: 'Spawn 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, agreementCounterProposalTool, agreementCheckProposalTool, agreementRevokeTool,
+    agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool,
     agreementFulfillTool,
-    taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool,
+    taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool,
 ];

package/dist/server/tools/tier2/chatTools.js

@@ -1,6 +1,6 @@
 import { CHAT_CAPABILITIES, openConversationCapability } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
-// ZIG-900 / ZIG-956 — open_conversation only (chat listing stays a
+// ZIG-900 / ZIG-956 — chat_open only (chat listing stays a
 // context-rail read, ZIG-626 rule); defined once in api-client's shared
 // capability layer.
 export const openConversationTool = toolFromCapability(openConversationCapability);

package/dist/server/tools/tier2/connectionTools.js

@@ -1,9 +1,9 @@
 import { connectionProxyCapability, requestConnectionCapability, ConnectionsClient, } from '@ziggs-ai/api-client';
 import { defineTool } from '../../../tools/defineTool.js';
 import { toolFromCapability } from '../../../tools/capabilityAdapter.js';
-// ZIG-956 — connection_proxy / request_connection are shared capability
+// ZIG-956 — connection_proxy / connection_request are shared capability
 // definitions (api-client). connection_list_grants stays SDK-only: the MCP
-// surface folds connection listing into ziggs_list_my_connections (ZIG-893
+// surface folds connection listing into ziggs_connection_list (ZIG-893
 // allowance in the parity table).
 export const connectionProxyTool = toolFromCapability(connectionProxyCapability);
 export const requestConnectionTool = toolFromCapability(requestConnectionCapability);

package/dist/server/tools/tier2/linkTools.d.ts

@@ -1,7 +1,4 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
-export declare const requestLinkTool: ToolDefinition;
-export declare const createLinkInviteTool: ToolDefinition;
-export declare const claimLinkInviteTool: ToolDefinition;
-export declare const listLinksTool: ToolDefinition;
-export declare const revokeLinkTool: ToolDefinition;
+export declare const linkCreateInviteTool: ToolDefinition;
+export declare const linkListTool: ToolDefinition;
 export declare const LINK_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/linkTools.js

@@ -1,12 +1,13 @@
-import { LINK_CAPABILITIES, requestLinkCapability, createLinkInviteCapability, claimLinkInviteCapability, listLinksCapability, revokeLinkCapability, } from '@ziggs-ai/api-client';
+import { LINK_CAPABILITIES, createLinkInviteCapability, listLinksCapability, } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
 // ZIG-898 / ZIG-956 — links are agreements with engagementKind 'link':
 // bilateral agent-to-agent trust that gives unpublished delegates cross-org
 // reach. Defined once in api-client's shared capability layer (including the
 // ZIG-670 linkSummary shaping); this file only adapts them onto the SDK.
-export const requestLinkTool = toolFromCapability(requestLinkCapability);
-export const createLinkInviteTool = toolFromCapability(createLinkInviteCapability);
-export const claimLinkInviteTool = toolFromCapability(claimLinkInviteCapability);
-export const listLinksTool = toolFromCapability(listLinksCapability);
-export const revokeLinkTool = toolFromCapability(revokeLinkCapability);
+//
+// ZIG-1021/1022 shrank the rail to two tools. The agreement verbs carry the
+// rest: request a direct link with agreement_propose (engagementKind 'link'),
+// claim an invite with agreement_claim, end a link with agreement_revoke.
+export const linkCreateInviteTool = toolFromCapability(createLinkInviteCapability);
+export const linkListTool = toolFromCapability(listLinksCapability);
 export const LINK_TOOLS = toolsFromCapabilities(LINK_CAPABILITIES);

package/dist/server/tools/tier2/marketplaceTools.d.ts

@@ -1,3 +1,3 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const marketplaceViewTool: ToolDefinition;
 export declare const MARKETPLACE_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/marketplaceTools.js

@@ -1,22 +1,9 @@
-import { defineTool } from '../../../tools/defineTool.js';
-import { pullQuests } from '@ziggs-ai/api-client';
-// Read-only marketplace access. Publishing an open quest is NOT here: it is the
-// tier-1 protocol verb agreement_propose({ proposedTo: "everyone" | "org" }).
-// This feed already returns only quests the caller may see — org-scoped quests
-// appear here only for members of the quest's org (filtered server-side).
-export const marketplaceViewTool = defineTool('marketplace_view', { limit: 'number', since: 'string' }, async (args, ctx) => {
-    const operatorKey = ctx?.['operatorKey'];
-    const agentId = ctx?.['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
-    const options = {
-        limit: typeof args['limit'] === 'number' ? args['limit'] : 20,
-    };
-    if (args['since'])
-        options.since = args['since'];
-    const quests = await pullQuests(options, { operatorKey, agentId });
-    return { quests, count: quests.length };
-}, { description: 'Browse open quests on the marketplace — work buyers have broadcast to willing agents. Returns public quests plus any org-scoped quests in your org. To claim a quest, use agreement_respond on the returned agreementId. To publish your own, use agreement_propose({ proposedTo: "everyone" }) for a public quest or proposedTo: "org" to keep it inside your org.' });
-export const MARKETPLACE_TOOLS = [marketplaceViewTool];
+import { MARKETPLACE_CAPABILITIES, marketplaceViewCapability } from '@ziggs-ai/api-client';
+import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
+// ZIG-1023 / ZIG-956 — the marketplace read (quests AND standing offers),
+// defined once in api-client's shared capability layer. Publishing is NOT
+// here: it is the tier-1 verb agreement_propose with proposedTo
+// "everyone" | "org" (providerId = own id for an offer, omitted for a quest);
+// claiming is agreement_claim.
+export const marketplaceViewTool = toolFromCapability(marketplaceViewCapability);
+export const MARKETPLACE_TOOLS = toolsFromCapabilities(MARKETPLACE_CAPABILITIES);

package/dist/tasks/protocolRegistry.d.ts

@@ -2,11 +2,12 @@ export declare const PROTOCOL_TOOL_TO_OPERATION: Readonly<{
     readonly agreement_propose: "agreement-propose";
     readonly agreement_subcontract: "agreement-subcontract";
     readonly agreement_respond: "agreement-respond";
-    readonly agreement_counter_proposal: "agreement-counter-proposal";
-    readonly agreement_check_proposal: "agreement-check-proposal";
+    readonly agreement_claim: "agreement-claim";
+    readonly agreement_counter: "agreement-counter-proposal";
+    readonly agreement_get: "agreement-check-proposal";
     readonly agreement_revoke: "agreement-revoke";
-    readonly task_spawn: "task-spawn";
-    readonly task_update: "task-update";
+    readonly task_create: "task-spawn";
+    readonly task_set_result: "task-update";
     readonly task_update_plan_step: "task-update-plan-step";
 }>;
 export type ProtocolToolName = keyof typeof PROTOCOL_TOOL_TO_OPERATION;

package/dist/tasks/protocolRegistry.js

@@ -2,11 +2,12 @@ export const PROTOCOL_TOOL_TO_OPERATION = Object.freeze({
     agreement_propose: 'agreement-propose',
     agreement_subcontract: 'agreement-subcontract',
     agreement_respond: 'agreement-respond',
-    agreement_counter_proposal: 'agreement-counter-proposal',
-    agreement_check_proposal: 'agreement-check-proposal',
+    agreement_claim: 'agreement-claim',
+    agreement_counter: 'agreement-counter-proposal',
+    agreement_get: 'agreement-check-proposal',
     agreement_revoke: 'agreement-revoke',
-    task_spawn: 'task-spawn',
-    task_update: 'task-update',
+    task_create: 'task-spawn',
+    task_set_result: 'task-update',
     task_update_plan_step: 'task-update-plan-step',
 });
 export const PROTOCOL_TOOL_NAMES = Object.freeze(Object.keys(PROTOCOL_TOOL_TO_OPERATION));

package/dist/tools/recordReport.d.ts

@@ -1,7 +1,7 @@
 import { type Creds } from '@ziggs-ai/api-client';
 /**
  * The canonical report shape (B1 convention — ZIG-561).
- * Matches Task.result as set by ziggs_set_task_result.
+ * Matches Task.result as set by ziggs_task_set_result.
  */
 export interface TaskReport {
     summary: string;

package/dist/types.d.ts

@@ -29,7 +29,7 @@ export interface TaskRef {
     parentTaskId?: string;
     executorId?: string;
     assigneeId?: string | null;
-    /** Work product set by task_update (safeJsonStringify'd string on the wire). */
+    /** Work product set by task_set_result (safeJsonStringify'd string on the wire). */
     result?: unknown;
     proposal?: {
         status?: 'pending' | 'approved' | 'rejected' | 'cancelled';
@@ -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). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.5.0",
+    "@ziggs-ai/api-client": "^0.6.1",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",