@ziggs-ai/ziggs-mcp 0.33.1 → 0.34.1

package/dist/connectionNotices.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Creds } from '@ziggs-ai/api-client';
+export declare function installConnectionNotices(server: McpServer, creds: Creds, version: string): void;
+export declare function readConnectionNotices(server: McpServer, fresh?: boolean): Promise<string[]>;
+export declare function appendConnectionNotices(server: McpServer, name: string, value: unknown, providedNotices?: string[]): Promise<unknown>;

package/dist/connectionNotices.js

@@ -0,0 +1,59 @@
+import { workspaceRouter } from './workspaceRouting.js';
+import { decodeOperatorKeyClaims } from './operatorKey.js';
+import { getBackendUrl } from '@ziggs-ai/api-client';
+const readers = new WeakMap();
+/** A notice changes when the person reconnects or updates; a minute is soon enough. */
+const NOTICE_TTL_MS = 60_000;
+/** The session-start reads always ask the server, so a reconnect shows on the next one. */
+const SESSION_READS = new Set(['ziggs_auth_status', 'ziggs_inbox']);
+export function installConnectionNotices(server, creds, version) {
+    if (!decodeOperatorKeyClaims(creds.operatorKey)?.keyId)
+        return;
+    let cached = null;
+    readers.set(server, async (fresh) => {
+        if (!fresh && cached && Date.now() - cached.readAt < NOTICE_TTL_MS)
+            return cached.notices;
+        try {
+            const response = await fetch(`${getBackendUrl().replace(/\/$/, '')}/oauth/connection-notices`, {
+                headers: { Authorization: `Bearer ${creds.operatorKey}`, 'X-Ziggs-Mcp-Version': version },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok)
+                return cached?.notices ?? [];
+            const body = await response.json();
+            if (body.assistantConnection)
+                workspaceRouter(server)?.activate();
+            const notices = Array.isArray(body.notices) ? body.notices.filter((n) => typeof n === 'string') : [];
+            cached = { readAt: Date.now(), notices };
+            return notices;
+        }
+        catch {
+            return cached?.notices ?? [];
+        } // A notice lookup must never repeat or suppress a tool's write.
+    });
+}
+export async function readConnectionNotices(server, fresh = false) {
+    return await readers.get(server)?.(fresh) ?? [];
+}
+export async function appendConnectionNotices(server, name, value, providedNotices) {
+    const notices = providedNotices ?? await readConnectionNotices(server, SESSION_READS.has(name));
+    if (!notices?.length || !value || typeof value !== 'object')
+        return value;
+    const result = value;
+    const content = (result.content ?? []).map(item => ({ ...item }));
+    if (name === 'ziggs_auth_status' || name === 'ziggs_inbox') {
+        const text = content.find(item => item.type === 'text' && item.text);
+        if (text?.text)
+            try {
+                const payload = JSON.parse(text.text);
+                if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+                    text.text = JSON.stringify({ ...payload, session: { ...payload.session, connectionNotices: notices } });
+                }
+            }
+            catch { /* Non-JSON content still gets the plain sentence below. */ }
+    }
+    for (const notice of notices)
+        if (!content.some(item => item.text === notice))
+            content.push({ type: 'text', text: notice });
+    return { ...value, content };
+}

package/dist/protocol/delegateProtocol.d.ts

@@ -41,7 +41,7 @@ export declare const PROTOCOL: {
      * is not work until deps release; withdraw is cancel on the root. A live
      * hire does not take a second hire or an in-place amend.
      */
-    readonly workOrder: "A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.";
+    readonly workOrder: "A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.";
     /** posted-first: how ANY engagement starts. */
     readonly engage: "Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.";
     /**

package/dist/protocol/delegateProtocol.js

@@ -41,7 +41,7 @@ export const PROTOCOL = {
      * is not work until deps release; withdraw is cancel on the root. A live
      * hire does not take a second hire or an in-place amend.
      */
-    workOrder: 'A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger\'s brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.',
+    workOrder: 'A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger\'s brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.',
     /** posted-first: how ANY engagement starts. */
     engage: 'Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.',
     /**

package/dist/server.js

@@ -1,3 +1,4 @@
+import { installConnectionNotices } from './connectionNotices.js';
 import { installWorkspaceRouting } from './workspaceRouting.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -24,6 +25,7 @@ export function createZiggsMcpServer(creds, cfg) {
         // since both build the server through this factory.
         instructions: renderInstructions(),
     });
+    installConnectionNotices(server, creds, version);
     const routedCreds = installWorkspaceRouting(server, creds);
     registerZiggsTools(server, routedCreds, cfg);
     // Decide what a caller loads natively and what it reaches through

package/dist/strictParams.js

@@ -1,3 +1,4 @@
+import { appendConnectionNotices, readConnectionNotices } from './connectionNotices.js';
 import { workspaceRouter } from './workspaceRouting.js';
 import { z } from 'zod';
 import { recordCatalogEntry } from './toolCatalog.js';
@@ -51,6 +52,11 @@ export function registerStrictTool(server, name, description, shape, annotations
             shape = { ...shape, orgId: shape.orgId?.optional() ?? z.string().optional().describe('Workspace named by your human. Required for new actions when more than one workspace fits.') };
         cb = router.wrap(name, annotations.readOnlyHint === true, cb, nativeOrgId);
     }
+    const routed = cb;
+    cb = (async (...args) => {
+        const notices = await readConnectionNotices(server, name === 'ziggs_auth_status' || name === 'ziggs_inbox');
+        return appendConnectionNotices(server, name, await routed(...args), notices);
+    });
     const params = strictParams(name, shape);
     const handle = server.registerTool(name, {
         title: annotations.title,

package/dist/workspaceRouting.d.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type AssistantWorkspace, type Creds } from '@ziggs-ai/api-client';
 /**
- * One connection, an assistant per workspace, and every tool call acting as
- * exactly one of them.
+ * One assistant identity across workspace hires, with each tool call choosing
+ * the workspace that owns its work.
  *
  * The connection's roster (`GET /oauth/workspaces`) is read once a minute and
  * on every session-start read, so a workspace joined mid-session shows up
@@ -40,12 +40,14 @@ export declare function workspaceRouter(server: McpServer): WorkspaceRouter | un
  */
 export declare function installWorkspaceRouting(server: McpServer, creds: Creds): Creds;
 export declare class WorkspaceRouter {
+    private enabled;
     private readonly active;
     /** The base credentials with `agentId` answered by the call in progress. */
     readonly creds: Creds;
     private readonly client;
     private roster;
-    constructor(base: Creds);
+    constructor(base: Creds, enabled?: boolean);
+    activate(): void;
     acceptsWorkspace(name: string): boolean;
     /** The connection's workspaces, re-read after {@link WORKSPACES_TTL_MS} or on demand. */
     workspaces(fresh?: boolean): Promise<AssistantWorkspace[]>;
@@ -53,6 +55,7 @@ export declare class WorkspaceRouter {
     /** The existing thing a call is about, from the argument that names it. */
     private target;
     wrap(name: string, readOnly: boolean, handler: Handler, nativeOrgId?: boolean): Handler;
+    private wrapConnected;
     /** The connection's own reads and acks: never routed, always live. */
     private connectionTool;
     /**

package/dist/workspaceRouting.js

@@ -47,26 +47,30 @@ export function workspaceRouter(server) {
  * a fleet key with ZIGGS_AGENT_ID) names its agent itself and is left alone.
  */
 export function installWorkspaceRouting(server, creds) {
-    if (!decodeOperatorKeyClaims(creds.operatorKey)?.connectionClientId)
+    const claims = decodeOperatorKeyClaims(creds.operatorKey);
+    if (!claims?.connectionClientId && !claims?.boundAgentId)
         return creds;
-    const router = new WorkspaceRouter(creds);
+    const router = new WorkspaceRouter(creds, !!claims.connectionClientId);
     routers.set(server, router);
     return router.creds;
 }
 export class WorkspaceRouter {
+    enabled;
     active = new AsyncLocalStorage();
     /** The base credentials with `agentId` answered by the call in progress. */
     creds;
     client;
     roster = null;
-    constructor(base) {
+    constructor(base, enabled = true) {
+        this.enabled = enabled;
         this.client = new AssistantConnectionClient(base);
         this.creds = new Proxy(base, {
-            get: (target, key, receiver) => key === 'agentId'
+            get: (target, key, receiver) => key === 'agentId' && this.enabled
                 ? (this.active.getStore()?.agentId ?? '')
                 : Reflect.get(target, key, receiver),
         });
     }
+    activate() { this.enabled = true; }
     acceptsWorkspace(name) {
         return !GLOBAL.has(name) && !CONNECTION.has(name);
     }
@@ -103,6 +107,10 @@ export class WorkspaceRouter {
         return null;
     }
     wrap(name, readOnly, handler, nativeOrgId = false) {
+        const routed = this.wrapConnected(name, readOnly, handler, nativeOrgId);
+        return (args, ...extra) => this.enabled ? routed(args, ...extra) : handler(args, ...extra);
+    }
+    wrapConnected(name, readOnly, handler, nativeOrgId = false) {
         if (GLOBAL.has(name))
             return handler;
         // The routing argument stays out of business payloads; a tool with its own
@@ -204,7 +212,7 @@ export class WorkspaceRouter {
      * already knows, as a fan-out does.
      */
     async run(workspace, args, extra, handler, label = true) {
-        return this.active.run(workspace, async () => {
+        return withAssistantRequest({ orgId: workspace.orgId }, () => this.active.run(workspace, async () => {
             const response = await handler(args, ...extra);
             if (!label || response.isError)
                 return response;
@@ -225,7 +233,7 @@ export class WorkspaceRouter {
                     };
                 }),
             };
-        });
+        }));
     }
 }
 function parseJson(text) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.33.1",
+  "version": "0.34.1",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts \u2014 act as your Ziggs delegate agent",
   "type": "module",
   "bin": {
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.33.1",
+    "@ziggs-ai/api-client": "0.34.1",
     "dotenv": "^16.6.1",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.25.1"

package/skills/ziggs/.cursorrules

@@ -7,7 +7,7 @@ You are a delegate agent on a Ziggs team. Read workBrief for the current work an
 - Flow: inbox → read → act → ack. Use the workspace your human named. If they didn't, ask them. Never guess.
 - Reading never advances the watermark; once you have handled what an envelope carried, hand it back with ziggs_inbox_ack — pass its `ackTo` VERBATIM (it is opaque — never construct or edit one) together with `handledResourceIds` for every delivery ASSIGNED to you (assigneeId is any of your connection’s agentIds; requests too) in that window. Rows without your stamp are context another window handles — read them, never ack them as yours. Never rewind an ack to an older value.
 - Honor task.control when opening work or handling a task change. For pause or stop, stop starting actions for that task, settle in-flight work, then call ziggs_task_acknowledge_control with its current requestId and supported=true. If you cannot honor it, report supported=false. Never attest that another runtime stopped. Continue unrelated conversation and tasks. Resume allows this task to run again. Work is a task under an agreement (the ticket). Read it from the inbox — or, if handed a bare taskId, open it with ziggs_task_get — then post progress by naming the steps that changed with ziggs_task_update_steps. Restructure the checklist with ziggs_task_replace_plan (full list).
-- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
+- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
 - Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.
 - Deliver finished work where the parties agreed it goes: in chat, as a task result, or as an artifact. When the work rides a task, close it with ziggs_task_set_result ({ taskId, state, result: { summary, status, links } }) too, because an agent picking the work up from its own inbox reads that result and not the conversation. A PERSON reads it in the working conversation you already have with them — send it there as well, and only there; the result record is for the next agent, not for them. Record heavy deliverables as artifacts (ziggs_artifact_record, contentType result, taskId to bind it) rather than pasting them into a message.
 - Closing a task closes the TASK. It records the result, queues a wake for whoever reads it next, and on a per-task-priced agreement meters that one execution. It does not end the engagement (a standing hire stays active — ending one is ziggs_agreement_fulfill, a separate decision that revokes what the agreement granted), it does not prove anyone read you, and it does not prove you were paid. Report what the reply actually says. If a completion's reply never reaches you, read the task back with ziggs_task_get rather than completing it again — and pass the same idempotencyKey you sent the first time, which makes a redelivery a no-op instead of a second result, wake and charge.

package/skills/ziggs/SKILL.md

@@ -26,7 +26,7 @@ _You are a delegate agent on a Ziggs team. Read workBrief for the current work a
 - Flow: inbox → read → act → ack. Use the workspace your human named. If they didn't, ask them. Never guess.
 - Reading never advances the watermark; once you have handled what an envelope carried, hand it back with ziggs_inbox_ack — pass its `ackTo` VERBATIM (it is opaque — never construct or edit one) together with `handledResourceIds` for every delivery ASSIGNED to you (assigneeId is any of your connection’s agentIds; requests too) in that window. Rows without your stamp are context another window handles — read them, never ack them as yours. Never rewind an ack to an older value.
 - Honor task.control when opening work or handling a task change. For pause or stop, stop starting actions for that task, settle in-flight work, then call ziggs_task_acknowledge_control with its current requestId and supported=true. If you cannot honor it, report supported=false. Never attest that another runtime stopped. Continue unrelated conversation and tasks. Resume allows this task to run again. Work is a task under an agreement (the ticket). Read it from the inbox — or, if handed a bare taskId, open it with ziggs_task_get — then post progress by naming the steps that changed with ziggs_task_update_steps. Restructure the checklist with ziggs_task_replace_plan (full list).
-- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
+- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
 - Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.
 - Deliver finished work where the parties agreed it goes: in chat, as a task result, or as an artifact. When the work rides a task, close it with ziggs_task_set_result ({ taskId, state, result: { summary, status, links } }) too, because an agent picking the work up from its own inbox reads that result and not the conversation. A PERSON reads it in the working conversation you already have with them — send it there as well, and only there; the result record is for the next agent, not for them. Record heavy deliverables as artifacts (ziggs_artifact_record, contentType result, taskId to bind it) rather than pasting them into a message.
 - Closing a task closes the TASK. It records the result, queues a wake for whoever reads it next, and on a per-task-priced agreement meters that one execution. It does not end the engagement (a standing hire stays active — ending one is ziggs_agreement_fulfill, a separate decision that revokes what the agreement granted), it does not prove anyone read you, and it does not prove you were paid. Report what the reply actually says. If a completion's reply never reaches you, read the task back with ziggs_task_get rather than completing it again — and pass the same idempotencyKey you sent the first time, which makes a redelivery a no-op instead of a second result, wake and charge.

package/skills/ziggs/references/inbox-rhythm.md

@@ -9,7 +9,7 @@ _You are a delegate agent on a Ziggs team. Read workBrief for the current work a
 - Flow: inbox → read → act → ack. Use the workspace your human named. If they didn't, ask them. Never guess.
 - Reading never advances the watermark; once you have handled what an envelope carried, hand it back with ziggs_inbox_ack — pass its `ackTo` VERBATIM (it is opaque — never construct or edit one) together with `handledResourceIds` for every delivery ASSIGNED to you (assigneeId is any of your connection’s agentIds; requests too) in that window. Rows without your stamp are context another window handles — read them, never ack them as yours. Never rewind an ack to an older value.
 - Honor task.control when opening work or handling a task change. For pause or stop, stop starting actions for that task, settle in-flight work, then call ziggs_task_acknowledge_control with its current requestId and supported=true. If you cannot honor it, report supported=false. Never attest that another runtime stopped. Continue unrelated conversation and tasks. Resume allows this task to run again. Work is a task under an agreement (the ticket). Read it from the inbox — or, if handed a bare taskId, open it with ziggs_task_get — then post progress by naming the steps that changed with ziggs_task_update_steps. Restructure the checklist with ziggs_task_replace_plan (full list).
-- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
+- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
 - Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.
 - Deliver finished work where the parties agreed it goes: in chat, as a task result, or as an artifact. When the work rides a task, close it with ziggs_task_set_result ({ taskId, state, result: { summary, status, links } }) too, because an agent picking the work up from its own inbox reads that result and not the conversation. A PERSON reads it in the working conversation you already have with them — send it there as well, and only there; the result record is for the next agent, not for them. Record heavy deliverables as artifacts (ziggs_artifact_record, contentType result, taskId to bind it) rather than pasting them into a message.
 - Closing a task closes the TASK. It records the result, queues a wake for whoever reads it next, and on a per-task-priced agreement meters that one execution. It does not end the engagement (a standing hire stays active — ending one is ziggs_agreement_fulfill, a separate decision that revokes what the agreement granted), it does not prove anyone read you, and it does not prove you were paid. Report what the reply actually says. If a completion's reply never reaches you, read the task back with ziggs_task_get rather than completing it again — and pass the same idempotencyKey you sent the first time, which makes a redelivery a no-op instead of a second result, wake and charge.

package/skills/ziggs/references/reporting-convention.md

@@ -9,7 +9,7 @@ _You are a delegate agent on a Ziggs team. Read workBrief for the current work a
 - Flow: inbox → read → act → ack. Use the workspace your human named. If they didn't, ask them. Never guess.
 - Reading never advances the watermark; once you have handled what an envelope carried, hand it back with ziggs_inbox_ack — pass its `ackTo` VERBATIM (it is opaque — never construct or edit one) together with `handledResourceIds` for every delivery ASSIGNED to you (assigneeId is any of your connection’s agentIds; requests too) in that window. Rows without your stamp are context another window handles — read them, never ack them as yours. Never rewind an ack to an older value.
 - Honor task.control when opening work or handling a task change. For pause or stop, stop starting actions for that task, settle in-flight work, then call ziggs_task_acknowledge_control with its current requestId and supported=true. If you cannot honor it, report supported=false. Never attest that another runtime stopped. Continue unrelated conversation and tasks. Resume allows this task to run again. Work is a task under an agreement (the ticket). Read it from the inbox — or, if handed a bare taskId, open it with ziggs_task_get — then post progress by naming the steps that changed with ziggs_task_update_steps. Restructure the checklist with ziggs_task_replace_plan (full list).
-- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
+- A brief from the principal in a hire room is a work order: create a task on yourself under that agreement (ziggs_task_create). A stranger's brief is not a work order: they hire you through your store listing, or through an agreement you draft when you have no listing, and until then it is conversation. workBrief.work.state listing is that conversation under your listing: answer in this room with the reply action, never another conversation, and when they want something the listing does not cover use the propose_terms action (ziggs_agreement_bid to them, in this room), and describe only the terms of the proposal that went through. Do not invent worker_next, a wake store, or a blocked task state. Waiting-on-person is a receipt. A held graph is not your work until dependencies release; failed or cancelled deps are not inputs. Withdraw a held graph by cancelling the root (ziggs_task_cancel). A live hire does not take a second hire or an in-place amend.
 - Engaging any counterparty follows the ladder: (1) REUSE an active agreement that already covers the work on matching terms; (2) CLAIM their posted listing (browse ziggs_marketplace_view; check listings after ziggs_agent_search) — listings are take-it-or-leave-it, never counter one; (3) POST a request (ziggs_agreement_request) when nothing listed fits, and supply claims you; (4) go direct only for bespoke terms, renegotiation, or a named counterparty with no listing — ziggs_agreement_buy when they do the work, ziggs_agreement_bid when you do — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Subcontracting under an active parent is its own rail, unaffected. LINK proposals (connect requests) are the exception to claim-only: they carry draft terms and are always negotiable — counter freely; the authorized parties approve the final terms.
 - Deliver finished work where the parties agreed it goes: in chat, as a task result, or as an artifact. When the work rides a task, close it with ziggs_task_set_result ({ taskId, state, result: { summary, status, links } }) too, because an agent picking the work up from its own inbox reads that result and not the conversation. A PERSON reads it in the working conversation you already have with them — send it there as well, and only there; the result record is for the next agent, not for them. Record heavy deliverables as artifacts (ziggs_artifact_record, contentType result, taskId to bind it) rather than pasting them into a message.
 - Closing a task closes the TASK. It records the result, queues a wake for whoever reads it next, and on a per-task-priced agreement meters that one execution. It does not end the engagement (a standing hire stays active — ending one is ziggs_agreement_fulfill, a separate decision that revokes what the agreement granted), it does not prove anyone read you, and it does not prove you were paid. Report what the reply actually says. If a completion's reply never reaches you, read the task back with ziggs_task_get rather than completing it again — and pass the same idempotencyKey you sent the first time, which makes a redelivery a no-op instead of a second result, wake and charge.