@ziggs-ai/agent-sdk 0.42.0 → 0.43.0

package/dist/runtime/kickoff.js

@@ -3,11 +3,6 @@ import { PROBE_CTX } from './validateWorkflow.js';
 import { hasDelegatedAgreement, hasOpenTaskForAgreement } from './taskBookkeeping.js';
 /** Reserved state name for the injected agreement-kickoff default (proposer). */
 export const KICKOFF_STATE = 'kickingOff';
-/**
- * reserved state for the injected claim/provider kickoff default.
- * Store listing claimed → open buyer chat + greet (not task_create).
- */
-export const CLAIM_KICKOFF_STATE = 'claimKickingOff';
 // Synthetic outcome used to ask "does this state already handle a proposer-side
 // approval?" — the same probe pattern validateWorkflow uses for the wait/error
 // fallthrough checks.
@@ -17,26 +12,6 @@ const PROBE_APPROVE = {
     proposal: { agreementId: '__kickoff_probe__' },
     proposedByMe: true,
 };
-/** Probe for claim/provider kickoff — must NOT match direct-proposal approver. */
-const PROBE_CLAIM_APPROVE = {
-    kind: 'proposal-resolved',
-    action: 'approve',
-    proposal: { agreementId: '__claim_kickoff_probe__' },
-    proposedByMe: false,
-    fromClaimWake: true,
-};
-/**
- * A bare counterparty approve — someone approved a proposal we did not make,
- * with no store claim behind it. Used as a NEGATIVE probe: a transition that
- * matches this as well as PROBE_CLAIM_APPROVE is a generic proposal-resolved
- * route, not a deliberate claim handler, so it does not suppress injection.
- */
-const PROBE_BARE_APPROVE = {
-    kind: 'proposal-resolved',
-    action: 'approve',
-    proposal: { agreementId: '__bare_approve_probe__' },
-    proposedByMe: false,
-};
 const KICKOFF_TRANSITION = {
     to: KICKOFF_STATE,
     when: (o, ctx) => o.kind === 'proposal-resolved' &&
@@ -50,15 +25,6 @@ const KICKOFF_TRANSITION = {
         // (2) we already hold an assigned task bound to it:
         !hasOpenTaskForAgreement(ctx, o.proposal.agreementId),
 };
-const CLAIM_KICKOFF_TRANSITION = {
-    to: CLAIM_KICKOFF_STATE,
-    when: (o, ctx) => o.kind === 'proposal-resolved' &&
-        o.action === 'approve' &&
-        o.proposedByMe === false &&
-        o.fromClaimWake === true &&
-        !hasDelegatedAgreement(ctx, o.proposal.agreementId) &&
-        !hasOpenTaskForAgreement(ctx, o.proposal.agreementId),
-};
 // A state "handles" proposer-approval if some transition would fire for it.
 // An unconditional (when-less) transition counts: it catches every outcome,
 // so the kickoff transition — appended LAST — would be unreachable dead code
@@ -81,33 +47,6 @@ function stateHandlesProposerApproval(state) {
         }
     });
 }
-function matches(t, probe) {
-    if (!t.when)
-        return false;
-    try {
-        return !!t.when(probe, PROBE_CTX);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * A state handles the claim kickoff itself only when it says so EXPLICITLY —
- * a transition that fires for a store-claim wake and does NOT also fire for a
- * bare counterparty approve. In practice that means keying on `fromClaimWake`.
- *
- * Two weaker rules read as "handled" when nothing was. A when-less fallthrough
- * counted, so a state shaped `idle → listening` never got the transition
- * injected and routed every claim into its idle loop; and a `when: o => o.kind
- * === 'proposal-resolved'` route counted too, because the claim probe is also a
- * proposal-resolved/approve. Neither author had written anything about claims.
- * Requiring the negative probe to MISS is what tells a deliberate claim handler
- * apart from a generic one, and the unconditional case is safe to inject over
- * because the claim transition goes in FIRST — see injectKickoffDefault.
- */
-function stateHandlesClaimKickoff(state) {
-    return state.transitions.some(t => matches(t, PROBE_CLAIM_APPROVE) && !matches(t, PROBE_BARE_APPROVE));
-}
 export function buildKickoffState(initial) {
     const dflt = thinkingDefaults({ initial });
     return {
@@ -142,27 +81,19 @@ export function buildKickoffState(initial) {
         ],
     };
 }
-/** provider side after a store/listing claim. */
 /**
- * Declare that THIS state answers a store-claim wake itself, so the injected
- * `claimKickingOff` greeting is not added to it.
+ * Route a store-claim wake from this state to `to`. The SDK no longer greets
+ * on a claim (a claim opens no room; the buyer writes first in the agreement's
+ * conversation), so this is only for an author who wants to act on the claim
+ * itself.
  *
- * The opt-out has to fire on a claim wake and NOT on a bare counterparty
- * approve — `stateHandlesClaimKickoff` uses that difference to tell a
- * deliberate claim handler from a generic `proposal-resolved` route that
- * happens to match. Writing that predicate by hand is easy to get subtly wrong,
- * and getting it wrong is silent: the agent greets on every claim while its
- * author believes it opted out. That cost one lab cast 100% of its token spend
- * and three wedged workers before anyone noticed.
+ * It fires on a claim wake and NOT on a bare counterparty approve, which also
+ * keeps it out of the way of the proposer-side kickoff.
  *
  *   transitions: [
  *     handlesClaimWake('idle'),   // a claim does not make this agent talk
  *     { to: 'idle', when: (o) => o.kind === 'proposal-resolved' && o.action === 'approve' },
  *   ]
- *
- * Note the second route is still worth keeping when you also want to sit out
- * the PROPOSER-side kickoff: that one probes with a bare approve, which this
- * helper deliberately does not match.
  */
 export function handlesClaimWake(to) {
     return {
@@ -170,120 +101,33 @@ export function handlesClaimWake(to) {
         when: (o) => o.kind === 'proposal-resolved' && o.action === 'approve' && o.fromClaimWake === true,
     };
 }
-export function buildClaimKickoffState(initial) {
-    const dflt = thinkingDefaults({ initial });
-    return {
-        kind: 'thinking',
-        prompt: {
-            role: "A buyer just claimed your store listing. chat_open with the buyer and the claimed agreementId returns the hire's room, which the server usually made at claim, or opens one when there is none. Then greet them and start serving the terms.",
-            goal: "Open or reuse the hire's room with the buyer and greet them so the engagement begins.",
-            constraints: "The claimed agreement id is in <event> / activeAgreementId. The buyer is the claim actor (Sender / actorId / Buyer on the event) — call chat_open with that participantId AND the claimed agreementId. That returns the hire's room the server usually made at claim, or opens one when there is none. Then chat_send a short greeting that acknowledges the hire and offers to serve the agreement terms. Do not chat_send to an agrn-* session id. Do not spawn task_create here unless the terms require it after the greeting. Do not re-negotiate — the agreement is already active.",
-        },
-        actions: {
-            ...dflt.actions,
-            openChat: {
-                prompt: {
-                    when: "Call chat_open with the buyer and the claimed agreementId. The server usually already made the hire's room at claim; this returns it, or opens one when there is none.",
-                    instruction: "Open or reuse the hire's room with the buyer who claimed the listing.",
-                    format: '{"participantId": "<buyer actorId / Sender from the event>", "agreementId": "<the claimed agreement id>"}',
-                },
-                tool: 'chat_open',
-                produces: (result) => {
-                    const r = result;
-                    return r?.chatId ? 'tool-result' : 'error';
-                },
-                /**
-                 * Deliberately does NOT terminate the turn.
-                 *
-                 * It used to, with "stay in this state so the next turn can greet in the
-                 * opened chat" — but the next turn re-enters this state from scratch,
-                 * reads the same prompt ("there is not yet a real chat"), and opens the
-                 * chat again. Nothing in a re-entered state says a chat is already open:
-                 * `chat_open` is idempotent, so every retry succeeds, produces
-                 * `tool-result`, and re-enters. Measured: three lab workers called
-                 * `chat_open` twelve times each, sent zero messages, and tripped the
-                 * depth guard — the greeting never happened and the wake was spent.
-                 *
-                 * Letting the turn continue puts the chatId in front of the model as a
-                 * tool result, so `greetBuyer` runs in the SAME turn. `message_sent`
-                 * outranks `tool_result` when the outcome is picked, so the turn leaves
-                 * on `message-sent` → initial: one turn, one greeting, no re-entry.
-                 */
-            },
-            greetBuyer: {
-                prompt: {
-                    when: 'A chat with the buyer is open (chat_open just returned a chatId, or one already exists).',
-                    instruction: 'Greet the buyer and acknowledge you will serve the claimed agreement terms.',
-                    format: '{"receiverId": "<buyer id>", "message": "<short greeting>", "chatId": "<chatId from chat_open when available>"}',
-                },
-                produces: 'message-sent',
-                terminatesLoop: true,
-            },
-        },
-        transitions: [
-            // After chat_open, re-enter so greetBuyer can run in the same kickoff.
-            { to: CLAIM_KICKOFF_STATE, when: o => o.kind === 'tool-result' },
-            { to: initial, when: o => o.kind === 'message-sent' },
-            ...dflt.transitions,
-        ],
-    };
-}
 /**
- * Agreement-kickoff defaults. For every state whose transitions do not already
- * handle the corresponding probe, add a transition to the injected kickoff
- * state. Returns a NEW workflow — input states are not mutated.
- *
- * Two kickoffs:
- *  - `kickingOff` — proposer-side approval → task_create
- *  - `claimKickingOff` — store-claim provider wake → chat_open + greet
- * Direct-proposal counterparties (lifecycle approve, !proposedByMe, no
- * fromClaimWake) still never auto-kickoff.
+ * Agreement-kickoff default. For every state whose transitions do not already
+ * handle a proposer-side approval, append a transition to the injected
+ * `kickingOff` state, which spawns the first task. Appended LAST: the approval
+ * is of a proposal THIS agent made, so a route its author wrote keeps winning.
+ * Returns a NEW workflow; input states are not mutated.
  *
- * **They are ordered differently on purpose** (first match wins in
- * AgentMachine._evaluateTransitions):
- *
- *  - `kickingOff` is appended LAST. It fires on an approval of a proposal THIS
- *    agent made, which the author was already expecting — whatever route they
- *    wrote for it should keep winning.
- *  - `claimKickingOff` is inserted FIRST. It fires on a wake the author never
- *    wrote a route for, and it has to beat the unconditional fallthrough an
- *    `idle` state uses to reach its listening loop — otherwise the claim is
- *    swallowed into the idle loop and the buyer is never greeted. Going first
- *    is safe because its `when` is narrow: only a `fromClaimWake` approve
- *    matches, so nothing else is shadowed. An author who wants the claim for
- *    themselves keys on `fromClaimWake`, which suppresses the injection
- *    outright (stateHandlesClaimKickoff).
+ * Counterparties never auto-kickoff, and neither does a store claim: a claim
+ * opens no room, and the buyer's first message or task is what wakes the
+ * provider.
  */
 export function injectKickoffDefault(workflow) {
     if (workflow.states[KICKOFF_STATE]) {
         throw new Error(`[defineAgent] state name "${KICKOFF_STATE}" is reserved for the injected agreement-kickoff default — rename the state`);
     }
-    if (workflow.states[CLAIM_KICKOFF_STATE]) {
-        throw new Error(`[defineAgent] state name "${CLAIM_KICKOFF_STATE}" is reserved for the injected claim-kickoff default — rename the state`);
-    }
     const states = {};
-    let injectedProposer = false;
-    let injectedClaim = false;
+    let injected = false;
     for (const [name, state] of Object.entries(workflow.states)) {
-        const transitions = [...state.transitions];
-        if (!stateHandlesProposerApproval(state)) {
-            transitions.push(KICKOFF_TRANSITION);
-            injectedProposer = true;
-        }
-        if (!stateHandlesClaimKickoff(state)) {
-            transitions.unshift(CLAIM_KICKOFF_TRANSITION);
-            injectedClaim = true;
+        if (stateHandlesProposerApproval(state)) {
+            states[name] = state;
+            continue;
         }
-        states[name] =
-            transitions.length === state.transitions.length
-                ? state
-                : { ...state, transitions };
+        states[name] = { ...state, transitions: [...state.transitions, KICKOFF_TRANSITION] };
+        injected = true;
     }
-    if (!injectedProposer && !injectedClaim)
+    if (!injected)
         return workflow;
-    if (injectedProposer)
-        states[KICKOFF_STATE] = buildKickoffState(workflow.initial);
-    if (injectedClaim)
-        states[CLAIM_KICKOFF_STATE] = buildClaimKickoffState(workflow.initial);
+    states[KICKOFF_STATE] = buildKickoffState(workflow.initial);
     return { ...workflow, states };
 }

package/dist/runtime/messageCommand.d.ts

@@ -0,0 +1,9 @@
+import type { MessageCommand } from '@ziggs-ai/contracts';
+import type { EffectHandler } from '../types.js';
+/** Compose an FSM response from a fresh, exact trigger. A session locates the
+ * wake context; it is never a room, principal or authority identifier. */
+export declare function responseCommand(eff: EffectHandler, sessionId: string, text: string, options?: {
+    operationId?: string;
+    recipientId?: string;
+    answer?: boolean;
+}): Promise<MessageCommand>;

package/dist/runtime/messageCommand.js

@@ -0,0 +1,23 @@
+import { randomUUID } from 'node:crypto';
+/** Compose an FSM response from a fresh, exact trigger. A session locates the
+ * wake context; it is never a room, principal or authority identifier. */
+export async function responseCommand(eff, sessionId, text, options = {}) {
+    const snapshot = await eff({ kind: 'read-context', sessionId, opts: { includeHistory: false } });
+    if (snapshot.unavailable)
+        throw new Error('Required response context is unavailable');
+    const parent = snapshot.messageRecord;
+    const recipient = options.recipientId ?? (parent && !parent.sender.isSelf ? parent.sender.ref : undefined);
+    if (!recipient)
+        throw new Error('Name an explicit recipient or read an exact message before replying');
+    const slots = parent?.requestedAnswers.filter(r => r.responsible.isSelf) ?? [];
+    if (options.answer && slots.length > 1)
+        throw new Error('Select the exact requested-answer slot with message_send');
+    const answer = options.answer && slots.length === 1 && recipient === parent?.sender.ref ? slots[0].action : undefined;
+    return {
+        operationId: options.operationId ?? randomUUID(), content: { text },
+        audience: { kind: 'explicit', principalIds: [recipient] }, deliveries: { kind: 'explicit', principalIds: [recipient] },
+        effect: answer ? { kind: 'answer', action: answer, artifacts: [] } : { kind: 'none' },
+        ...(snapshot.messageMandate ? { mandate: snapshot.messageMandate } : {}),
+        ...(parent ? { relationships: { replyToMessageId: parent.messageId } } : {}),
+    };
+}

package/dist/runtime/requiredContext.d.ts

@@ -0,0 +1,6 @@
+/** A failed required read is retryable work, never a successfully handled wake. */
+export declare class RequiredContextUnavailable extends Error {
+    readonly code = "REQUIRED_CONTEXT_UNAVAILABLE";
+    constructor();
+}
+export declare function assertRequiredContext(snapshot: unknown): void;

package/dist/runtime/requiredContext.js

@@ -0,0 +1,23 @@
+/** A failed required read is retryable work, never a successfully handled wake. */
+export class RequiredContextUnavailable extends Error {
+    code = 'REQUIRED_CONTEXT_UNAVAILABLE';
+    constructor() {
+        super('Required context is unavailable. Leave the responsibility pending until access or the read recovers.');
+        this.name = 'RequiredContextUnavailable';
+    }
+}
+export function assertRequiredContext(snapshot) {
+    const record = (value) => value && typeof value === 'object' ? value : {};
+    const root = record(snapshot);
+    const unavailable = (work) => {
+        const packet = record(work);
+        return packet.unavailable === true
+            || (Array.isArray(packet.contexts) && packet.contexts.some(unavailable));
+    };
+    // minimumComplete=false can mean paginated/truncated input awaiting expansion.
+    // authorization.active=false can be a readable proposal awaiting a decision.
+    // Those packets still support recovery; operation/task policy gates new work.
+    if (snapshot == null || root.unavailable === true || unavailable(root.work)) {
+        throw new RequiredContextUnavailable();
+    }
+}

package/dist/runtime/runTurn.js

@@ -1,5 +1,6 @@
+import { responseCommand } from './messageCommand.js';
 import { permitsAutomaticMandate } from './agreementContext.js';
-import { isAgreementId } from '@ziggs-ai/api-client';
+import { assertRequiredContext } from './requiredContext.js';
 import { outcomeFromActionResult } from './buildOutcome.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { safeParseJSON } from '../utils/jsonExtractor.js';
@@ -57,10 +58,6 @@ export async function runTurn(input) {
     const runId = crypto.randomUUID();
     // Wrap eff to stamp runId + stateId onto llm-call and tool-call effects,
     // and the wake's replay-stable write keys onto tool-call effects.
-    // Send-message effects without an explicit messageId get a wake-derived one
-    // here — a crash-replay of the wake re-derives the same id and the backend's
-    // (chatId, messageId) dedup drops the duplicate. Undefined on
-    // keyless wakes, where the transport generates a fresh id as before.
     const effWithTrace = (effect) => {
         if (effect.kind === 'llm-call') {
             return eff({ ...effect, runId, stateId });
@@ -68,16 +65,12 @@ export async function runTurn(input) {
         if (effect.kind === 'tool-call') {
             return eff({ ...effect, runId, stateId, writeKeys });
         }
-        if (effect.kind === 'send-message' && !effect.messageId) {
+        if (effect.kind === 'send-message' && writeKeys) {
             const send = effect;
-            return eff({
-                ...effect,
-                messageId: writeKeys?.messageKey({
-                    text: send.text,
-                    sessionId: send.sessionId,
-                    receiverId: send.receiverId,
-                }),
-            });
+            const { operationId: _operationId, ...payload } = send.command;
+            const operationId = writeKeys.messageKey({ text: JSON.stringify(payload), sessionId: send.sessionId });
+            if (operationId)
+                return eff({ ...send, command: { ...send.command, operationId } });
         }
         return eff(effect);
     };
@@ -112,39 +105,13 @@ export async function runTurn(input) {
         })
         : [];
     const serverContext = await effWithTrace({ kind: 'read-context', sessionId, opts: {} });
+    assertRequiredContext(serverContext);
     const ctxObj = normalizeContextSnapshot(serverContext);
-    // A wake whose chat no longer resolves (deleted, or never visible to this
-    // agent) has no world to decide over — deciding anyway means reasoning
-    // about a fabricated empty history plus whatever stale scraps other
-    // fetches returned. Skip the LLM and park. Resource wakes used to slip
-    // past a message-only gate and burn a full turn. A bare
-    // agreement id as sessionId is a mis-keyed lane — loud-log the empty
-    // snapshot rather than staying silent.
-    if (ctxObj.chatMissing) {
-        const looksLikeBareAgreement = isAgreementId(sessionId);
-        if (looksLikeBareAgreement) {
-            runtimeLog.warn('runTurn', `chatMissing on non-chat sessionId=${sessionId} (state=${stateId}) — ` +
-                `lane was keyed by agreementId instead of the agreement's origin/notification chat; ` +
-                `wake continues with an empty snapshot`);
-        }
-        else {
-            // Any wake in a room this agent cannot read — not only
-            // message wakes. Resource notices used to spend a full turn here.
-            runtimeLog.warn('runTurn', `chat ${sessionId} not readable — skipping wake (state=${stateId})`);
-            return {
-                outcome: { kind: 'wait' },
-                toolResults: [],
-                llmCalls: 0,
-                tokens: { total: 0, input: 0, output: 0 },
-                skippedReason: `chat_unreadable:${sessionId}`,
-            };
-        }
-    }
     const prompt = promptBuilder.buildFromState({
         statePrompt, actions,
         serverContext: { context: ctxObj, tools: tools },
         incomingEvent, definition,
-        chatId: sessionId, stateId, ctx,
+        addressId: sessionId, stateId, ctx,
         omitMessageFromRespond: streamRespondActions,
     });
     const systemContent = tools.length > 0
@@ -400,24 +367,15 @@ export async function runTurn(input) {
                             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' });
+                    await eff({ kind: 'send-message', sessionId, command: await responseCommand(eff, sessionId, safeText, { recipientId: decision.receiverId, operationId: persistMessageId, answer: true }) });
+                    allEmittedEvents.push({ type: 'message_sent', receiverId: decision.receiverId, addressId: sessionId, message: safeText, senderId: 'system' });
                     lastAction = chosenAction;
                     lastActionDef = actionDef;
                 }
                 catch (err) {
-                    if (isReplySlotTaken(err)) {
-                        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;
-                    }
-                    else {
-                        // Both the streaming path AND the non-streaming fallback failed —
-                        // the user got nothing. End the turn with a loud send-failed error.
-                        runtimeLog.error('runTurn', `respond send failed after stream fallback: ${err.message}`);
-                        turnError = { source: 'protocol', cause: 'send-failed' };
-                    }
+                    // A conflict is a refusal, never proof that this answer was delivered.
+                    runtimeLog.error('runTurn', `respond send failed after stream fallback: ${err.message}`);
+                    turnError = { source: 'protocol', cause: 'send-failed' };
                 }
                 break;
             }
@@ -671,47 +629,17 @@ function truncateMsg(msg) {
         return msg;
     return msg.slice(0, MAX_MSG_CHARS) + `\n\n[truncated to ${MAX_MSG_CHARS} of ${msg.length} chars]`;
 }
-/**
- * A send rejected with 409 hit the backend's (chatId, messageId) idempotency
- * gate on a wake-derived id: this wake's reply already exists. Two legal ways
- * that happens — a crash-replay re-ran the wake, or a second host raced the
- * same at-least-once delivery — and in both the re-run LLM produced different
- * text, so the backend rejects instead of no-op'ing (treats
- * same-key-same-content as replay, same-key-different-content as conflict).
- * The user already has the winner's reply. Re-sending under a fresh id would
- * double-message; failing the turn marks an answered wake as an error. Treat
- * it as delivered-by-the-other-attempt and move on.
- */
-function isReplySlotTaken(err) {
-    return err?.status === 409;
-}
 async function executeSendMessage(decision, eff, sessionId) {
-    // Callers guarantee message text. receiverId is set only when the model
-    // named someone; an answer without one is sent without one. sessionId is
-    // always ctx.identity.sessionId. A send failure throws to the turn loop,
-    // which converts it into the 'send-failed' error outcome — no silent nulls,
-    // and message_sent is only emitted after the send effect resolved.
-    // `decision.chatId` is what the LLM emitted in its JSON decision; honor it
-    // for cross-session sends (e.g. reporting to a parent task chat), fall back
-    // to the current session otherwise.
-    const targetSessionId = decision.chatId || sessionId;
+    if (decision.addressId && decision.addressId !== sessionId)
+        throw new Error('A response cannot route through a room. Use message_send with explicit recipients and mandate.');
+    const targetSessionId = sessionId;
     const safeMessage = truncateMsg(decision.message);
     const receiverId = decision.receiverId || undefined;
-    try {
-        await eff({
-            kind: 'send-message',
-            sessionId: targetSessionId,
-            ...(receiverId ? { receiverId } : {}),
-            text: safeMessage,
-        });
-    }
-    catch (err) {
-        if (!isReplySlotTaken(err))
-            throw err;
-        runtimeLog.warn('runTurn', `reply already persisted for this wake (idempotency 409) — a replay or second host answered first; dropping duplicate${receiverId ? ` to ${receiverId}` : ''}`);
-        return [{ type: 'message_duplicate_skipped', ...(receiverId ? { receiverId } : {}), chatId: targetSessionId, senderId: 'system' }];
-    }
-    const events = [{ type: 'message_sent', ...(receiverId ? { receiverId } : {}), chatId: targetSessionId, message: safeMessage, senderId: 'system' }];
+    await eff({
+        kind: 'send-message', sessionId,
+        command: await responseCommand(eff, sessionId, safeMessage, { recipientId: receiverId, answer: true }),
+    });
+    const events = [{ type: 'message_sent', ...(receiverId ? { receiverId } : {}), addressId: targetSessionId, message: safeMessage, senderId: 'system' }];
     if (targetSessionId !== sessionId)
         events.push({ type: 'report_sent', message: 'Reported to owner.', senderId: 'system' });
     return events;
@@ -734,29 +662,26 @@ async function executeSendMessages(decision, eff, sessionId) {
             failures.push({ receiverId: msg.receiverId || '<missing>', error: 'missing message' });
             continue;
         }
-        const targetSessionId = msg.chatId || sessionId;
+        if (msg.addressId && msg.addressId !== sessionId) {
+            failures.push({ receiverId: msg.receiverId, error: 'Use message_send with explicit recipients and mandate for a separate destination' });
+            continue;
+        }
+        const targetSessionId = sessionId;
         const safeMessage = truncateMsg(msg.message);
         attempted++;
         try {
             await eff({
                 kind: 'send-message',
-                sessionId: targetSessionId,
-                ...(msg.receiverId ? { receiverId: msg.receiverId } : {}),
-                text: safeMessage,
+                sessionId, command: await responseCommand(eff, sessionId, safeMessage, { recipientId: msg.receiverId, answer: true }),
             });
         }
         catch (err) {
-            if (isReplySlotTaken(err)) {
-                runtimeLog.warn('runTurn', `reply already persisted for this wake (idempotency 409) — dropping duplicate to ${msg.receiverId}`);
-                events.push({ type: 'message_duplicate_skipped', receiverId: msg.receiverId, chatId: targetSessionId, senderId: 'system' });
-                continue;
-            }
             // Scenario: backend rejected or transport dropped this one send. Record
             // it and keep going — remaining recipients must still get their message.
             failures.push({ receiverId: msg.receiverId, error: err.message });
             continue;
         }
-        events.push({ type: 'message_sent', receiverId: msg.receiverId, chatId: targetSessionId, message: safeMessage, senderId: 'system' });
+        events.push({ type: 'message_sent', receiverId: msg.receiverId, addressId: targetSessionId, message: safeMessage, senderId: 'system' });
         if (targetSessionId !== sessionId)
             events.push({ type: 'report_sent', message: 'Reported to owner.', senderId: 'system' });
     }
@@ -842,12 +767,12 @@ async function echoOptInToolSummaryIfNeeded({ allEmittedEvents, eff, sessionId,
     const safe = truncateMsg(summary);
     const wasTruncated = safe !== summary;
     try {
-        await eff({ kind: 'send-message', sessionId, receiverId, text: safe });
+        await eff({ kind: 'send-message', sessionId, command: await responseCommand(eff, sessionId, safe, { recipientId: receiverId }) });
     }
     catch {
         return;
     }
-    const event = { type: 'message_sent', receiverId, chatId: sessionId, message: safe, senderId: 'system' };
+    const event = { type: 'message_sent', receiverId, addressId: sessionId, message: safe, senderId: 'system' };
     if (wasTruncated) {
         event['truncated'] = true;
         event['originalLength'] = summary.length;

package/dist/runtime/taskIntake.js

@@ -1,5 +1,5 @@
 import { thinkingDefaults } from './defaults.js';
-import { CLAIM_KICKOFF_STATE, KICKOFF_STATE } from './kickoff.js';
+import { KICKOFF_STATE } from './kickoff.js';
 import { PROBE_CTX } from './validateWorkflow.js';
 /** Reserved state name for the injected assigned-task-intake default. */
 export const TASK_INTAKE_STATE = 'workingAssignedTask';
@@ -35,15 +35,17 @@ 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 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.',
+            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.summary — 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 as result.summary — 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,
-            completeTask: {
+            // One action for both outcomes. Two actions bound to task_set_result
+            // left a native tool call ambiguous, so the runtime dropped it.
+            setTaskResult: {
                 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>>", "state": "completed", "result": "<the full deliverable>"}',
+                    when: 'You can produce the deliverable for the assigned task in this turn, or it needs abilities, tools or information you cannot obtain.',
+                    instruction: 'Close the assigned task: state "completed" with the deliverable itself as the result, or state "failed" with a one-line reason.',
+                    format: '{"taskId": "<assigned task id from <event>>", "state": "completed" | "failed", "result": {"summary": "<the full deliverable, or the one-line reason>"}}',
                 },
                 tool: 'task_set_result',
                 // Function form so a failed task_set_result surfaces as an error outcome
@@ -56,21 +58,6 @@ export function buildTaskIntakeState(initial) {
                 },
                 terminatesLoop: true,
             },
-            failTask: {
-                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>>", "state": "failed", "result": "<one-line reason>"}',
-                },
-                tool: 'task_set_result',
-                produces: (result) => {
-                    // `state` only cut `status` from the wire.
-                    const r = result;
-                    const state = r?.task?.state ?? r?.state;
-                    return state === 'completed' || state === 'failed' ? 'task-closed' : 'error';
-                },
-                terminatesLoop: true,
-            },
         },
         transitions: [
             { to: initial, when: o => o.kind === 'task-closed' },
@@ -102,7 +89,6 @@ export function injectTaskIntakeDefault(workflow) {
         // a task-assigned route must not force the intake state into a workflow
         // whose author states all handle assignment.
         if (name === KICKOFF_STATE ||
-            name === CLAIM_KICKOFF_STATE ||
             stateHandlesTaskAssigned(state)) {
             states[name] = state;
             continue;

package/dist/runtime/wakeEffects.d.ts

@@ -15,26 +15,17 @@ export declare function contextScopesFromWake(event: unknown, sessionId: string)
 /** Per-wake observation, including effects nested inside tools and cross-room sends. */
 export declare class WakeEffects {
     private readonly initialScope;
-    private readonly sessionId?;
     private readonly inferScope;
     sentMessage: boolean;
     taskWrite: boolean;
     readonly planVersions: Set<string>;
     readonly sentMessageKeys: Set<string>;
-    /** Agreements the wake's OWN room reported, from its fenced snapshot. */
-    private roomAgreementIds;
     /** Confirmed task writes: work this wake actually performed. */
     private taskWrites;
-    constructor(initialScope: WorkScope, sessionId?: string | undefined, inferScope?: boolean);
+    constructor(initialScope: WorkScope, inferScope?: boolean);
     static forWake(event: unknown, sessionId: string): WakeEffects;
-    /**
-     * Structured wake fields first. Otherwise the room's one agreement is the
-     * scope — spend follows who the agent acts for, and in a room that is the
-     * room's agreement — and a confirmed task write names its task only when
-     * the server tied the write to that same agreement. A plan written for
-     * customer A from customer B's room stays billed to B and names no task; a
-     * write whose agreement the server did not report adds nothing but the room.
-     */
+    /** Structured work wins. A confirmed task write may identify work performed;
+     * reading a context snapshot never selects billing or execution authority. */
     get scope(): WorkScope;
     observe(effect: Effect, response: unknown): void;
 }