@paigy/harness 0.3.3 → 0.3.4

package/dist/cli.js

@@ -23655,10 +23655,17 @@ function contactSchemaFrom(fields) {
     ),
     workId: fields.workId.describe(
       "The durable Work this contact advances. Pass the workId from check_replies or a prior reply when asking for a decision that blocks that work."
+    ),
+    // THE WAIT, CONTINUED (owner, 2026-09-06: "await should have been folded into contact").
+    // A contact that rang holds its first window itself; the host caps one tool call at
+    // ~60 s, so keeping the line is another contact — with ONLY this field. Nothing is sent.
+    wait: external_exports.string().uuid().optional().describe(
+      "KEEP WAITING on a live call: the notificationId a previous contact returned. Send it ALONE \u2014 no ask, nothing new goes to the user; contact just holds the next ~45 s window and returns the outcome in `wait`."
     )
   });
   const out = mcpInputSchema(surface);
-  out.required = ["ask"];
+  delete out.required;
+  out.anyOf = [{ required: ["ask"] }, { required: ["wait"] }];
   return out;
 }
 function normalizeWaiting(req) {
@@ -24334,7 +24341,7 @@ async function patchState(path, state, opts, operation) {
 function setTaskState(notificationId, state, opts = {}) {
   return patchState(`/api/notify/${encodeURIComponent(notificationId)}/state`, state, opts, "set_task_state");
 }
-var require2, __create2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __require2, __commonJS2, __copyProps2, __toESM2, require_nacl_fast, BACKEND_URL, NETWORK_MSG, PROXY_ENV, agent, INSTANCE_ID, WORKSPACE_ID, envSession, SESSION_ID, ignoreOverride, defaultOptions, getDefaultOptions, getRefs, getRelativePath, parseCatchDef, integerDateParser, isJsonSchema7AllOfType, emojiRegex2, zodPatterns, ALPHA_NUMERIC, primitiveMappings, asAnyOf, parseOptionalDef, parsePipelineDef, parseReadonlyDef, selectParser, get$ref, addMeta, zodToJsonSchema, OPTIONS_MIN, OPTIONS_MAX, MISSED_CALL_PLAN, CreateGoalSchema, UpdateGoalSchema, fmtMin, STANDARD_MEANS, CONTACT_DESCRIPTION, ContextSchema, ParticipantSchema, TransformSchema, OptionSchema, VisualSchema, NotifyLevelSchema, SelectShapeSchema, ReceiptEventSchema, AttentionSchema, NotifyRequestFields, NotifyRequestSchema, NotifyStatusSchema, AgentStateSchema, SetTaskStateSchema, SetWorkStateSchema, TurnSchema, UserAnswerSchema, IntentSchema, RideAlongSchema, AwaitItemSchema, CallbackTriggerSchema, ScheduleCallbackSchema, PendingRepliesSchema, NotifyResponseSchema, NotifyPlanUnitSchema, NotifyPlanSchema, UserResponseSchema, VoiceKeySchema, AgendaTurnSchema, CLAIM_STALE_MS, InboxItemSchema, SnoozeRequestSchema, APNS_TOKEN_RE, PushTokenSchema, MissedCallSchema, BrokerTuningSchema, UserSettingsSchema, HistoryItemSchema, ACTIVITY_LINES, ACTIVITY_LINE_MAX, AgentActivitySchema, ConnectionSummarySchema, MoveRingSchema, MoveSchema, CreateRequestSchema, HandoffSchema, NoteSourceSchema, NoteStatusSchema, NoteRepeatSchema, DecisionSchema, NoteSchema, CreateNoteSchema, RecordDecisionSchema, AssignNoteSchema, TriageVerdictSchema, TriageItemSchema, TriageAssignmentSchema, TriageStatusSchema, SubmitTriageSchema, TriageProposalSchema, AcceptTriageSchema, AcceptTriageResultSchema, DeliveryModeSchema, RegisterDeliverySchema, OAuthStartSchema, DeliveryConfigSchema, StatusSchema, EnvelopeRecipientSchema, EnvelopeHeaderSchema, EnvelopeSchema, SealedAnswerSchema, DeviceCredentialSchema, DeviceRosterSchema, WakeNudgeSchema, PairingStatusSchema, PairingRevealSchema, DeviceCodeRequestSchema, DeviceCodeSchema, DeviceInfoSchema, DeviceTokenRequestSchema, DeviceTokenSchema, DeviceCommitRequestSchema, DevicePeerCommitSchema, SupportRequestSchema, NotificationFeedbackKindSchema, NotificationFeedbackSchema, FeedbackResolutionSchema, FeedbackOutcomeSchema, CONTACT_SCHEMA, import_tweetnacl, import_tweetnacl2, import_tweetnacl3, import_tweetnacl4, import_tweetnacl5, B64, ok, ENVELOPE_VERSION, ENVELOPE_ALG, AGENT_NAME, TOKEN_PATH, KEY_PATH, sleep, UnpairedError, tokenOverride, authToken, sleep3, ReplyLeaseExpiredError, ReplyAckError;
+var require2, __create2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __require2, __commonJS2, __copyProps2, __toESM2, require_nacl_fast, BACKEND_URL, NETWORK_MSG, PROXY_ENV, agent, INSTANCE_ID, WORKSPACE_ID, envSession, SESSION_ID, ignoreOverride, defaultOptions, getDefaultOptions, getRefs, getRelativePath, parseCatchDef, integerDateParser, isJsonSchema7AllOfType, emojiRegex2, zodPatterns, ALPHA_NUMERIC, primitiveMappings, asAnyOf, parseOptionalDef, parsePipelineDef, parseReadonlyDef, selectParser, get$ref, addMeta, zodToJsonSchema, OPTIONS_MIN, OPTIONS_MAX, MISSED_CALL_PLAN, CreateGoalSchema, UpdateGoalSchema, fmtMin, STANDARD_MEANS, CONTACT_DESCRIPTION, ContextSchema, ParticipantSchema, TransformSchema, OptionSchema, VisualSchema, NotifyLevelSchema, SelectShapeSchema, ReceiptEventSchema, AttentionSchema, NotifyRequestFields, NotifyRequestSchema, NotifyStatusSchema, AgentStateSchema, SetTaskStateSchema, SetWorkStateSchema, TurnSchema, UserAnswerSchema, IntentSchema, RideAlongSchema, AwaitItemSchema, CallbackTriggerSchema, ScheduleCallbackSchema, PendingRepliesSchema, NotifyResponseSchema, NotifyPlanUnitSchema, NotifyPlanSchema, UserResponseSchema, VoiceKeySchema, AgendaTurnSchema, CLAIM_STALE_MS, InboxItemSchema, SnoozeRequestSchema, APNS_TOKEN_RE, PushTokenSchema, MissedCallSchema, BrokerTuningSchema, UserSettingsSchema, HistoryItemSchema, ACTIVITY_LINES, ACTIVITY_LINE_MAX, AgentActivitySchema, ConnectionSummarySchema, LedgerItemSchema, AgentLedgerSchema, ReassignResultSchema, MoveRingSchema, MoveSchema, CreateRequestSchema, HandoffSchema, NoteSourceSchema, NoteStatusSchema, NoteRepeatSchema, DecisionSchema, NoteSchema, CreateNoteSchema, RecordDecisionSchema, AssignNoteSchema, TriageVerdictSchema, TriageItemSchema, TriageAssignmentSchema, TriageStatusSchema, SubmitTriageSchema, TriageProposalSchema, AcceptTriageSchema, AcceptTriageResultSchema, DeliveryModeSchema, RegisterDeliverySchema, OAuthStartSchema, DeliveryConfigSchema, StatusSchema, EnvelopeRecipientSchema, EnvelopeHeaderSchema, EnvelopeSchema, SealedAnswerSchema, DeviceCredentialSchema, DeviceRosterSchema, WakeNudgeSchema, PairingStatusSchema, PairingRevealSchema, DeviceCodeRequestSchema, DeviceCodeSchema, DeviceInfoSchema, DeviceTokenRequestSchema, DeviceTokenSchema, DeviceCommitRequestSchema, DevicePeerCommitSchema, SupportRequestSchema, NotificationFeedbackKindSchema, NotificationFeedbackSchema, FeedbackResolutionSchema, FeedbackOutcomeSchema, CONTACT_SCHEMA, import_tweetnacl, import_tweetnacl2, import_tweetnacl3, import_tweetnacl4, import_tweetnacl5, B64, ok, ENVELOPE_VERSION, ENVELOPE_ALG, AGENT_NAME, TOKEN_PATH, KEY_PATH, sleep, UnpairedError, tokenOverride, authToken, sleep3, ReplyLeaseExpiredError, ReplyAckError;
 var init_dist = __esm({
   "../../packages/sdk/dist/index.js"() {
     "use strict";
@@ -27010,7 +27017,7 @@ var init_dist = __esm({
       const list = parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}` : parts[0] ?? "";
       return `Rings again ${list} after the missed call, then leaves it in your inbox`;
     })();
-    CONTACT_DESCRIPTION = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId? } \u2014 pass notificationId to the reply path named by the returned \`message\`, and parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN}-${OPTIONS_MAX} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim.`;
+    CONTACT_DESCRIPTION = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId?, wait? }. WHEN IT RANG, contact holds the first ~45 s window ITSELF and \`wait\` carries the outcome: { type:'reply', answer } to act on; { type:'partial', inFlight:true, turn } \u2014 what the user is saying to each turn, provisional: use it to PREPARE (fetch, draft, warm the build), never to act irreversibly, they can still revise it until the final reply (partial = intelligence, settled = authorization; if a partial's acts carry a question aimed at you and you know the answer, contact on the SAME parentId right away \u2014 they hear it on the same call); { type:'remind', remindInSeconds } \u2014 schedule a wake-up; { type:'idle' } \u2014 still waiting. TO KEEP WAITING, call contact again with ONLY { wait: notificationId } \u2014 no ask, nothing new is sent; it holds the next scoped ~45 s window (under the 60 s host cap, so it always returns) and never returns another notification's reply. Keep doing that until the reply \u2014 THAT one is the decision \u2014 so the user steps away and comes back to find you already continued; stop only to do other work and check back, or after an unreasonably long stretch worth telling them about. A message delivery has NO \`wait\`: never poll for it \u2014 the reply arrives through check_replies or your wake. Pass parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN}-${OPTIONS_MAX} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim. READING A CALL'S REPLY: it can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a question that blocks me'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's parentId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry \`intents\` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' ("call me after lunch") \u2192 register it NOW with schedule_callback \u2014 when the intent carries \`dueInSeconds\` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' ("you pick") \u2192 make the call yourself and tell them what you chose; 'channel' ("text me next time") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped "should I call you back?" because the follow-up is implied. \`transcript\` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions ("yes, IF tests pass") before acting. If your ask declared \`points\`, the reply carries \`covered\` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same parentId) or proceed knowingly partial; never treat a partial answer as complete.`;
     ContextSchema = external_exports.object({
       title: external_exports.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
       description: external_exports.array(external_exports.string().min(1)).describe(
@@ -27364,11 +27371,21 @@ var init_dist = __esm({
           acts: external_exports.array(IntentSchema).nullable().optional()
         })
       }),
-      external_exports.object({ type: external_exports.literal("idle"), also: external_exports.array(RideAlongSchema).optional() })
+      external_exports.object({
+        type: external_exports.literal("idle"),
+        also: external_exports.array(RideAlongSchema).optional(),
+        /** Is a call live for this agent's user right now? The SDK polls the partial stream
+         *  (#783) between idle ticks ONLY while this is not `false` — a partial can only exist
+         *  during a live call, and polling for one on a banner/message was a wasted HTTP call +
+         *  3 queries on every idle tick of every waiting agent (~80% of all traffic at scale).
+         *  Absent = an older API → the SDK keeps polling, exactly as before. */
+        inFlight: external_exports.boolean().optional()
+      })
     ]);
     CallbackTriggerSchema = external_exports.enum(["on_done", "on_blocked", "scheduled"]);
     ScheduleCallbackSchema = external_exports.object({
       parentId: external_exports.string().describe("The thread to call back on (from a prior contact / reply / request)."),
+      goalId: external_exports.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
       trigger: CallbackTriggerSchema,
       dueInSeconds: external_exports.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
       note: external_exports.string().optional().describe("What to tell the user when you follow up.")
@@ -27813,6 +27830,15 @@ var init_dist = __esm({
     ConnectionSummarySchema = external_exports.object({
       /** The connection = the agent's token id (used to address a request). */
       id: external_exports.string(),
+      /** The credential kind: "device" = a paired machine (mint-only — it hosts and mints, it
+       *  never talks); "agent" = an identity that sends. The roster and devices surfaces split
+       *  on this. Optional/absent reads as "agent" (a row predating the kind column). See
+       *  apps/api/src/tokens/devices-vs-agents-design.md. */
+      kind: external_exports.enum(["device", "agent"]).optional(),
+      /** For an agent, the token id of the DEVICE that minted it — so agents group under their
+       *  machine, and revoking a device cascades to them. Null on devices, and on unlinked
+       *  agents (phone-launched, provider-managed, or minted before the link existed). */
+      mintedByDevice: external_exports.string().nullable().optional(),
       device: external_exports.string().nullable(),
       /** The agent's display name (the single pairing name). */
       name: external_exports.string(),
@@ -27852,6 +27878,22 @@ var init_dist = __esm({
        *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
       managed: external_exports.boolean()
     });
+    LedgerItemSchema = external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), title: external_exports.string(), createdAt: external_exports.string() });
+    AgentLedgerSchema = external_exports.object({
+      agent: external_exports.object({ id: external_exports.string(), name: external_exports.string(), revokedAt: external_exports.string().nullable() }),
+      /** Its own questions you have not answered. */
+      asks: external_exports.array(LedgerItemSchema),
+      /** Its questions you answered that nobody acted on — still owed to somebody. */
+      answered: external_exports.array(LedgerItemSchema),
+      /** Requests you sent it that it never took. */
+      requests: external_exports.array(LedgerItemSchema),
+      goals: external_exports.array(external_exports.object({ id: external_exports.string(), outcome: external_exports.string(), state: external_exports.string() })),
+      callbacks: external_exports.array(external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), trigger: external_exports.string(), note: external_exports.string(), dueAt: external_exports.string().nullable() }))
+    });
+    ReassignResultSchema = external_exports.object({
+      moved: external_exports.object({ asks: external_exports.number(), answered: external_exports.number(), requests: external_exports.number(), goals: external_exports.number(), callbacks: external_exports.number() }),
+      parentId: external_exports.string().nullable()
+    });
     MoveRingSchema = external_exports.enum(["home", "travels", "retired", "quarantined"]);
     MoveSchema = external_exports.object({
       id: external_exports.string(),
@@ -28262,7 +28304,7 @@ var init_dist = __esm({
     ReplyLeaseExpiredError = class extends Error {
       constructor() {
         super(
-          "The Paigy reply lease expired before acknowledgement. The answer remains durable; call await_reply again to reclaim it before acting."
+          "The Paigy reply lease expired before acknowledgement. The answer remains durable; wait on it again (contact with only { wait: notificationId }) to reclaim it before acting."
         );
         this.name = "ReplyLeaseExpiredError";
       }
@@ -34886,13 +34928,20 @@ function contactSchemaFrom2(fields) {
     ),
     workId: fields.workId.describe(
       "The durable Work this contact advances. Pass the workId from check_replies or a prior reply when asking for a decision that blocks that work."
+    ),
+    // THE WAIT, CONTINUED (owner, 2026-09-06: "await should have been folded into contact").
+    // A contact that rang holds its first window itself; the host caps one tool call at
+    // ~60 s, so keeping the line is another contact — with ONLY this field. Nothing is sent.
+    wait: external_exports.string().uuid().optional().describe(
+      "KEEP WAITING on a live call: the notificationId a previous contact returned. Send it ALONE \u2014 no ask, nothing new goes to the user; contact just holds the next ~45 s window and returns the outcome in `wait`."
     )
   });
   const out = mcpInputSchema2(surface);
-  out.required = ["ask"];
+  delete out.required;
+  out.anyOf = [{ required: ["ask"] }, { required: ["wait"] }];
   return out;
 }
-var CONTACT_DESCRIPTION2 = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId? } \u2014 pass notificationId to the reply path named by the returned \`message\`, and parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS2}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN2}-${OPTIONS_MAX2} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim.`;
+var CONTACT_DESCRIPTION2 = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId?, wait? }. WHEN IT RANG, contact holds the first ~45 s window ITSELF and \`wait\` carries the outcome: { type:'reply', answer } to act on; { type:'partial', inFlight:true, turn } \u2014 what the user is saying to each turn, provisional: use it to PREPARE (fetch, draft, warm the build), never to act irreversibly, they can still revise it until the final reply (partial = intelligence, settled = authorization; if a partial's acts carry a question aimed at you and you know the answer, contact on the SAME parentId right away \u2014 they hear it on the same call); { type:'remind', remindInSeconds } \u2014 schedule a wake-up; { type:'idle' } \u2014 still waiting. TO KEEP WAITING, call contact again with ONLY { wait: notificationId } \u2014 no ask, nothing new is sent; it holds the next scoped ~45 s window (under the 60 s host cap, so it always returns) and never returns another notification's reply. Keep doing that until the reply \u2014 THAT one is the decision \u2014 so the user steps away and comes back to find you already continued; stop only to do other work and check back, or after an unreasonably long stretch worth telling them about. A message delivery has NO \`wait\`: never poll for it \u2014 the reply arrives through check_replies or your wake. Pass parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS2}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN2}-${OPTIONS_MAX2} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim. READING A CALL'S REPLY: it can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a question that blocks me'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's parentId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry \`intents\` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' ("call me after lunch") \u2192 register it NOW with schedule_callback \u2014 when the intent carries \`dueInSeconds\` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' ("you pick") \u2192 make the call yourself and tell them what you chose; 'channel' ("text me next time") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped "should I call you back?" because the follow-up is implied. \`transcript\` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions ("yes, IF tests pass") before acting. If your ask declared \`points\`, the reply carries \`covered\` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same parentId) or proceed knowingly partial; never treat a partial answer as complete.`;
 var ContextSchema2 = external_exports.object({
   title: external_exports.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: external_exports.array(external_exports.string().min(1)).describe(
@@ -35263,11 +35312,21 @@ var AwaitItemSchema2 = external_exports.discriminatedUnion("type", [
       acts: external_exports.array(IntentSchema2).nullable().optional()
     })
   }),
-  external_exports.object({ type: external_exports.literal("idle"), also: external_exports.array(RideAlongSchema2).optional() })
+  external_exports.object({
+    type: external_exports.literal("idle"),
+    also: external_exports.array(RideAlongSchema2).optional(),
+    /** Is a call live for this agent's user right now? The SDK polls the partial stream
+     *  (#783) between idle ticks ONLY while this is not `false` — a partial can only exist
+     *  during a live call, and polling for one on a banner/message was a wasted HTTP call +
+     *  3 queries on every idle tick of every waiting agent (~80% of all traffic at scale).
+     *  Absent = an older API → the SDK keeps polling, exactly as before. */
+    inFlight: external_exports.boolean().optional()
+  })
 ]);
 var CallbackTriggerSchema2 = external_exports.enum(["on_done", "on_blocked", "scheduled"]);
 var ScheduleCallbackSchema2 = external_exports.object({
   parentId: external_exports.string().describe("The thread to call back on (from a prior contact / reply / request)."),
+  goalId: external_exports.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
   trigger: CallbackTriggerSchema2,
   dueInSeconds: external_exports.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
   note: external_exports.string().optional().describe("What to tell the user when you follow up.")
@@ -35712,6 +35771,15 @@ var AgentActivitySchema2 = external_exports.object({
 var ConnectionSummarySchema2 = external_exports.object({
   /** The connection = the agent's token id (used to address a request). */
   id: external_exports.string(),
+  /** The credential kind: "device" = a paired machine (mint-only — it hosts and mints, it
+   *  never talks); "agent" = an identity that sends. The roster and devices surfaces split
+   *  on this. Optional/absent reads as "agent" (a row predating the kind column). See
+   *  apps/api/src/tokens/devices-vs-agents-design.md. */
+  kind: external_exports.enum(["device", "agent"]).optional(),
+  /** For an agent, the token id of the DEVICE that minted it — so agents group under their
+   *  machine, and revoking a device cascades to them. Null on devices, and on unlinked
+   *  agents (phone-launched, provider-managed, or minted before the link existed). */
+  mintedByDevice: external_exports.string().nullable().optional(),
   device: external_exports.string().nullable(),
   /** The agent's display name (the single pairing name). */
   name: external_exports.string(),
@@ -35751,6 +35819,22 @@ var ConnectionSummarySchema2 = external_exports.object({
    *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
   managed: external_exports.boolean()
 });
+var LedgerItemSchema2 = external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), title: external_exports.string(), createdAt: external_exports.string() });
+var AgentLedgerSchema2 = external_exports.object({
+  agent: external_exports.object({ id: external_exports.string(), name: external_exports.string(), revokedAt: external_exports.string().nullable() }),
+  /** Its own questions you have not answered. */
+  asks: external_exports.array(LedgerItemSchema2),
+  /** Its questions you answered that nobody acted on — still owed to somebody. */
+  answered: external_exports.array(LedgerItemSchema2),
+  /** Requests you sent it that it never took. */
+  requests: external_exports.array(LedgerItemSchema2),
+  goals: external_exports.array(external_exports.object({ id: external_exports.string(), outcome: external_exports.string(), state: external_exports.string() })),
+  callbacks: external_exports.array(external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), trigger: external_exports.string(), note: external_exports.string(), dueAt: external_exports.string().nullable() }))
+});
+var ReassignResultSchema2 = external_exports.object({
+  moved: external_exports.object({ asks: external_exports.number(), answered: external_exports.number(), requests: external_exports.number(), goals: external_exports.number(), callbacks: external_exports.number() }),
+  parentId: external_exports.string().nullable()
+});
 var MoveRingSchema2 = external_exports.enum(["home", "travels", "retired", "quarantined"]);
 var MoveSchema2 = external_exports.object({
   id: external_exports.string(),
@@ -37134,6 +37218,25 @@ function bridgeLine(r) {
 
 // src/cli.ts
 var STATUS_MARK = { ready: "\u2713", login: "\u25D0", "adapter-missing": "\u25D0", missing: "\u2717" };
+function printConnectLines(link, userCode) {
+  console.log("Connect this computer from your phone");
+  console.log(`  Open   ${link}`);
+  console.log(`  or scan the QR above \xB7 or type ${userCode} in Paigy \u2192 Devices \u2192 Connect a computer`);
+}
+function forwardCodexThreadId() {
+  const cfg = join5(process.env.CODEX_HOME || join5(homedir7(), ".codex"), "config.toml");
+  if (!existsSync5(cfg)) return;
+  const text = readFileSync4(cfg, "utf8");
+  const head = "[mcp_servers.paigy]\n";
+  const at = text.indexOf(head);
+  if (at < 0) return;
+  const block = text.slice(at + head.length, (() => {
+    const n = text.indexOf("\n[", at + head.length);
+    return n < 0 ? text.length : n;
+  })());
+  if (/^\s*env_vars\s*=/m.test(block)) return;
+  writeFileSync4(cfg, text.slice(0, at + head.length) + 'env_vars = ["CODEX_THREAD_ID", "CODEX_SESSION_ID"]\n' + text.slice(at + head.length));
+}
 async function main() {
   const parsed = parseArgs(process.argv.slice(2));
   if ("error" in parsed) {
@@ -37209,8 +37312,7 @@ async function main() {
     if (!live) {
       const code = await requestCode(hostname().replace(/\.local$/, ""), void 0, hostname().replace(/\.local$/, ""));
       console.log(await import_qrcode.default.toString(code.verification_uri_complete, { type: "terminal", small: true }));
-      console.log(`Open:  ${code.verification_uri_complete}`);
-      console.log(`Or scan the QR above, or enter code ${code.user_code} at ${code.verification_uri}`);
+      printConnectLines(code.verification_uri_complete, code.user_code);
       const deadline = Date.now() + code.expires_in * 1e3;
       let paired = false;
       while (!paired && Date.now() < deadline) {
@@ -37250,15 +37352,21 @@ async function main() {
     } else console.log("start hosting with: paigy-harness host   (keep it running under your init system)");
     const TERMINAL_AGENTS = [
       { cli: "claude", name: "Claude Code", wire: "claude plugin marketplace add paigy-ai/mcp; claude plugin install paigy@paigy" },
-      { cli: "codex", name: "Codex", wire: `codex mcp add paigy -c 'mcp_servers.paigy.env_vars=["CODEX_THREAD_ID","CODEX_SESSION_ID"]' -- npx -y @paigy/mcp@latest` },
+      // Plain add only. Forwarding CODEX_THREAD_ID is a SECOND step (forwardCodexThreadId):
+      // a `-c mcp_servers.paigy.env_vars=…` override on `mcp add` lands before the block is
+      // written, codex sees a half-table and rejects it ("invalid transport"), and nothing at
+      // all gets wired — which the old silent catch below hid entirely (found by QA 2026-09-06).
+      { cli: "codex", name: "Codex", wire: "codex mcp add paigy -- npx -y @paigy/mcp@latest" },
       { cli: "agy", name: "Antigravity" }
     ];
     for (const t of TERMINAL_AGENTS) {
       if (!which(t.cli) || !t.wire) continue;
       try {
         execSync(t.wire, { stdio: "ignore", shell: "/bin/sh" });
+        if (t.cli === "codex") forwardCodexThreadId();
         console.log(`\u2713 paigy wired for ${t.cli} \u2014 each session hatches its own identity (restart open sessions)`);
-      } catch {
+      } catch (e) {
+        console.log(`\u26A0 could not wire ${t.cli} (${e.message.split("\n")[0]}) \u2014 the harness still works; wire it by hand later`);
       }
     }
     if (which("claude")) {
@@ -37301,8 +37409,7 @@ async function main() {
     if (existing) console.log("\u26A0 this machine was logged out \u2014 reconnecting it now");
     const code = await requestCode(hostname().replace(/\.local$/, ""), void 0, hostname().replace(/\.local$/, ""));
     console.log(await import_qrcode.default.toString(code.verification_uri_complete, { type: "terminal", small: true }));
-    console.log(`Open:  ${code.verification_uri_complete}`);
-    console.log(`Or scan the QR above, or enter code ${code.user_code} at ${code.verification_uri}`);
+    printConnectLines(code.verification_uri_complete, code.user_code);
     const deadline = Date.now() + code.expires_in * 1e3;
     while (Date.now() < deadline) {
       const token = await pollToken(code.device_code).catch(() => null);

package/dist/main.js

@@ -12207,13 +12207,20 @@ function contactSchemaFrom(fields) {
     ),
     workId: fields.workId.describe(
       "The durable Work this contact advances. Pass the workId from check_replies or a prior reply when asking for a decision that blocks that work."
+    ),
+    // THE WAIT, CONTINUED (owner, 2026-09-06: "await should have been folded into contact").
+    // A contact that rang holds its first window itself; the host caps one tool call at
+    // ~60 s, so keeping the line is another contact — with ONLY this field. Nothing is sent.
+    wait: external_exports.string().uuid().optional().describe(
+      "KEEP WAITING on a live call: the notificationId a previous contact returned. Send it ALONE \u2014 no ask, nothing new goes to the user; contact just holds the next ~45 s window and returns the outcome in `wait`."
     )
   });
   const out = mcpInputSchema(surface);
-  out.required = ["ask"];
+  delete out.required;
+  out.anyOf = [{ required: ["ask"] }, { required: ["wait"] }];
   return out;
 }
-var CONTACT_DESCRIPTION = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId? } \u2014 pass notificationId to the reply path named by the returned \`message\`, and parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN}-${OPTIONS_MAX} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim.`;
+var CONTACT_DESCRIPTION = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId?, wait? }. WHEN IT RANG, contact holds the first ~45 s window ITSELF and \`wait\` carries the outcome: { type:'reply', answer } to act on; { type:'partial', inFlight:true, turn } \u2014 what the user is saying to each turn, provisional: use it to PREPARE (fetch, draft, warm the build), never to act irreversibly, they can still revise it until the final reply (partial = intelligence, settled = authorization; if a partial's acts carry a question aimed at you and you know the answer, contact on the SAME parentId right away \u2014 they hear it on the same call); { type:'remind', remindInSeconds } \u2014 schedule a wake-up; { type:'idle' } \u2014 still waiting. TO KEEP WAITING, call contact again with ONLY { wait: notificationId } \u2014 no ask, nothing new is sent; it holds the next scoped ~45 s window (under the 60 s host cap, so it always returns) and never returns another notification's reply. Keep doing that until the reply \u2014 THAT one is the decision \u2014 so the user steps away and comes back to find you already continued; stop only to do other work and check back, or after an unreasonably long stretch worth telling them about. A message delivery has NO \`wait\`: never poll for it \u2014 the reply arrives through check_replies or your wake. Pass parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN}-${OPTIONS_MAX} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim. READING A CALL'S REPLY: it can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a question that blocks me'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's parentId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry \`intents\` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' ("call me after lunch") \u2192 register it NOW with schedule_callback \u2014 when the intent carries \`dueInSeconds\` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' ("you pick") \u2192 make the call yourself and tell them what you chose; 'channel' ("text me next time") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped "should I call you back?" because the follow-up is implied. \`transcript\` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions ("yes, IF tests pass") before acting. If your ask declared \`points\`, the reply carries \`covered\` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same parentId) or proceed knowingly partial; never treat a partial answer as complete.`;
 var ContextSchema = external_exports.object({
   title: external_exports.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: external_exports.array(external_exports.string().min(1)).describe(
@@ -12622,11 +12629,21 @@ var AwaitItemSchema = external_exports.discriminatedUnion("type", [
       acts: external_exports.array(IntentSchema).nullable().optional()
     })
   }),
-  external_exports.object({ type: external_exports.literal("idle"), also: external_exports.array(RideAlongSchema).optional() })
+  external_exports.object({
+    type: external_exports.literal("idle"),
+    also: external_exports.array(RideAlongSchema).optional(),
+    /** Is a call live for this agent's user right now? The SDK polls the partial stream
+     *  (#783) between idle ticks ONLY while this is not `false` — a partial can only exist
+     *  during a live call, and polling for one on a banner/message was a wasted HTTP call +
+     *  3 queries on every idle tick of every waiting agent (~80% of all traffic at scale).
+     *  Absent = an older API → the SDK keeps polling, exactly as before. */
+    inFlight: external_exports.boolean().optional()
+  })
 ]);
 var CallbackTriggerSchema = external_exports.enum(["on_done", "on_blocked", "scheduled"]);
 var ScheduleCallbackSchema = external_exports.object({
   parentId: external_exports.string().describe("The thread to call back on (from a prior contact / reply / request)."),
+  goalId: external_exports.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
   trigger: CallbackTriggerSchema,
   dueInSeconds: external_exports.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
   note: external_exports.string().optional().describe("What to tell the user when you follow up.")
@@ -13071,6 +13088,15 @@ var AgentActivitySchema = external_exports.object({
 var ConnectionSummarySchema = external_exports.object({
   /** The connection = the agent's token id (used to address a request). */
   id: external_exports.string(),
+  /** The credential kind: "device" = a paired machine (mint-only — it hosts and mints, it
+   *  never talks); "agent" = an identity that sends. The roster and devices surfaces split
+   *  on this. Optional/absent reads as "agent" (a row predating the kind column). See
+   *  apps/api/src/tokens/devices-vs-agents-design.md. */
+  kind: external_exports.enum(["device", "agent"]).optional(),
+  /** For an agent, the token id of the DEVICE that minted it — so agents group under their
+   *  machine, and revoking a device cascades to them. Null on devices, and on unlinked
+   *  agents (phone-launched, provider-managed, or minted before the link existed). */
+  mintedByDevice: external_exports.string().nullable().optional(),
   device: external_exports.string().nullable(),
   /** The agent's display name (the single pairing name). */
   name: external_exports.string(),
@@ -13110,6 +13136,22 @@ var ConnectionSummarySchema = external_exports.object({
    *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
   managed: external_exports.boolean()
 });
+var LedgerItemSchema = external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), title: external_exports.string(), createdAt: external_exports.string() });
+var AgentLedgerSchema = external_exports.object({
+  agent: external_exports.object({ id: external_exports.string(), name: external_exports.string(), revokedAt: external_exports.string().nullable() }),
+  /** Its own questions you have not answered. */
+  asks: external_exports.array(LedgerItemSchema),
+  /** Its questions you answered that nobody acted on — still owed to somebody. */
+  answered: external_exports.array(LedgerItemSchema),
+  /** Requests you sent it that it never took. */
+  requests: external_exports.array(LedgerItemSchema),
+  goals: external_exports.array(external_exports.object({ id: external_exports.string(), outcome: external_exports.string(), state: external_exports.string() })),
+  callbacks: external_exports.array(external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), trigger: external_exports.string(), note: external_exports.string(), dueAt: external_exports.string().nullable() }))
+});
+var ReassignResultSchema = external_exports.object({
+  moved: external_exports.object({ asks: external_exports.number(), answered: external_exports.number(), requests: external_exports.number(), goals: external_exports.number(), callbacks: external_exports.number() }),
+  parentId: external_exports.string().nullable()
+});
 var MoveRingSchema = external_exports.enum(["home", "travels", "retired", "quarantined"]);
 var MoveSchema = external_exports.object({
   id: external_exports.string(),
@@ -14010,7 +14052,7 @@ var sleep3 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 var ReplyLeaseExpiredError = class extends Error {
   constructor() {
     super(
-      "The Paigy reply lease expired before acknowledgement. The answer remains durable; call await_reply again to reclaim it before acting."
+      "The Paigy reply lease expired before acknowledgement. The answer remains durable; wait on it again (contact with only { wait: notificationId }) to reclaim it before acting."
     );
     this.name = "ReplyLeaseExpiredError";
   }
@@ -15656,13 +15698,20 @@ function contactSchemaFrom2(fields) {
     ),
     workId: fields.workId.describe(
       "The durable Work this contact advances. Pass the workId from check_replies or a prior reply when asking for a decision that blocks that work."
+    ),
+    // THE WAIT, CONTINUED (owner, 2026-09-06: "await should have been folded into contact").
+    // A contact that rang holds its first window itself; the host caps one tool call at
+    // ~60 s, so keeping the line is another contact — with ONLY this field. Nothing is sent.
+    wait: external_exports.string().uuid().optional().describe(
+      "KEEP WAITING on a live call: the notificationId a previous contact returned. Send it ALONE \u2014 no ask, nothing new goes to the user; contact just holds the next ~45 s window and returns the outcome in `wait`."
     )
   });
   const out = mcpInputSchema2(surface);
-  out.required = ["ask"];
+  delete out.required;
+  out.anyOf = [{ required: ["ask"] }, { required: ["wait"] }];
   return out;
 }
-var CONTACT_DESCRIPTION2 = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId? } \u2014 pass notificationId to the reply path named by the returned \`message\`, and parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS2}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN2}-${OPTIONS_MAX2} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim.`;
+var CONTACT_DESCRIPTION2 = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId?, wait? }. WHEN IT RANG, contact holds the first ~45 s window ITSELF and \`wait\` carries the outcome: { type:'reply', answer } to act on; { type:'partial', inFlight:true, turn } \u2014 what the user is saying to each turn, provisional: use it to PREPARE (fetch, draft, warm the build), never to act irreversibly, they can still revise it until the final reply (partial = intelligence, settled = authorization; if a partial's acts carry a question aimed at you and you know the answer, contact on the SAME parentId right away \u2014 they hear it on the same call); { type:'remind', remindInSeconds } \u2014 schedule a wake-up; { type:'idle' } \u2014 still waiting. TO KEEP WAITING, call contact again with ONLY { wait: notificationId } \u2014 no ask, nothing new is sent; it holds the next scoped ~45 s window (under the 60 s host cap, so it always returns) and never returns another notification's reply. Keep doing that until the reply \u2014 THAT one is the decision \u2014 so the user steps away and comes back to find you already continued; stop only to do other work and check back, or after an unreasonably long stretch worth telling them about. A message delivery has NO \`wait\`: never poll for it \u2014 the reply arrives through check_replies or your wake. Pass parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS2}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN2}-${OPTIONS_MAX2} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim. READING A CALL'S REPLY: it can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction. Usually that's the only turn; if there are more (e.g. an end-of-call 'call me back when it's done / I have a question that blocks me'), read each one in order as a further follow-up instruction, not a single combined one. If they asked for a callback, re-engage in the SAME thread (contact with the reply's parentId) when the task is done or you hit a blocker \u2014 waiting:'hard' for a blocker, waiting:'none' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing). A call-mapped answer may carry \`intents\` \u2014 next steps the user attached, each { kind, detail } with detail quoting their words. ACT on them, don't just read them: 'defer' ("call me after lunch") \u2192 register it NOW with schedule_callback \u2014 when the intent carries \`dueInSeconds\` (Paigy pre-parsed the spoken time against the user's clock) pass it straight through; otherwise derive it from the detail yourself \u2014 then follow up on the same thread; 'delegate' ("you pick") \u2192 make the call yourself and tell them what you chose; 'channel' ("text me next time") \u2192 honor it on your next contact (channel:'message'); 'question' (an open question aimed back at you that the call couldn't answer) \u2192 you OWE them the answer \u2014 work it out and follow up on the same thread without being asked, the call deliberately skipped "should I call you back?" because the follow-up is implied. \`transcript\` is the user's raw words behind a shaped answer \u2014 read it for hedges and conditions ("yes, IF tests pass") before acting. If your ask declared \`points\`, the reply carries \`covered\` \u2014 the points actually addressed. Compare against what you declared: a missing point is STILL unanswered \u2014 re-ask it (contact on the same parentId) or proceed knowingly partial; never treat a partial answer as complete.`;
 var ContextSchema2 = external_exports.object({
   title: external_exports.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: external_exports.array(external_exports.string().min(1)).describe(
@@ -16033,11 +16082,21 @@ var AwaitItemSchema2 = external_exports.discriminatedUnion("type", [
       acts: external_exports.array(IntentSchema2).nullable().optional()
     })
   }),
-  external_exports.object({ type: external_exports.literal("idle"), also: external_exports.array(RideAlongSchema2).optional() })
+  external_exports.object({
+    type: external_exports.literal("idle"),
+    also: external_exports.array(RideAlongSchema2).optional(),
+    /** Is a call live for this agent's user right now? The SDK polls the partial stream
+     *  (#783) between idle ticks ONLY while this is not `false` — a partial can only exist
+     *  during a live call, and polling for one on a banner/message was a wasted HTTP call +
+     *  3 queries on every idle tick of every waiting agent (~80% of all traffic at scale).
+     *  Absent = an older API → the SDK keeps polling, exactly as before. */
+    inFlight: external_exports.boolean().optional()
+  })
 ]);
 var CallbackTriggerSchema2 = external_exports.enum(["on_done", "on_blocked", "scheduled"]);
 var ScheduleCallbackSchema2 = external_exports.object({
   parentId: external_exports.string().describe("The thread to call back on (from a prior contact / reply / request)."),
+  goalId: external_exports.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
   trigger: CallbackTriggerSchema2,
   dueInSeconds: external_exports.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
   note: external_exports.string().optional().describe("What to tell the user when you follow up.")
@@ -16482,6 +16541,15 @@ var AgentActivitySchema2 = external_exports.object({
 var ConnectionSummarySchema2 = external_exports.object({
   /** The connection = the agent's token id (used to address a request). */
   id: external_exports.string(),
+  /** The credential kind: "device" = a paired machine (mint-only — it hosts and mints, it
+   *  never talks); "agent" = an identity that sends. The roster and devices surfaces split
+   *  on this. Optional/absent reads as "agent" (a row predating the kind column). See
+   *  apps/api/src/tokens/devices-vs-agents-design.md. */
+  kind: external_exports.enum(["device", "agent"]).optional(),
+  /** For an agent, the token id of the DEVICE that minted it — so agents group under their
+   *  machine, and revoking a device cascades to them. Null on devices, and on unlinked
+   *  agents (phone-launched, provider-managed, or minted before the link existed). */
+  mintedByDevice: external_exports.string().nullable().optional(),
   device: external_exports.string().nullable(),
   /** The agent's display name (the single pairing name). */
   name: external_exports.string(),
@@ -16521,6 +16589,22 @@ var ConnectionSummarySchema2 = external_exports.object({
    *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
   managed: external_exports.boolean()
 });
+var LedgerItemSchema2 = external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), title: external_exports.string(), createdAt: external_exports.string() });
+var AgentLedgerSchema2 = external_exports.object({
+  agent: external_exports.object({ id: external_exports.string(), name: external_exports.string(), revokedAt: external_exports.string().nullable() }),
+  /** Its own questions you have not answered. */
+  asks: external_exports.array(LedgerItemSchema2),
+  /** Its questions you answered that nobody acted on — still owed to somebody. */
+  answered: external_exports.array(LedgerItemSchema2),
+  /** Requests you sent it that it never took. */
+  requests: external_exports.array(LedgerItemSchema2),
+  goals: external_exports.array(external_exports.object({ id: external_exports.string(), outcome: external_exports.string(), state: external_exports.string() })),
+  callbacks: external_exports.array(external_exports.object({ id: external_exports.string(), parentId: external_exports.string(), trigger: external_exports.string(), note: external_exports.string(), dueAt: external_exports.string().nullable() }))
+});
+var ReassignResultSchema2 = external_exports.object({
+  moved: external_exports.object({ asks: external_exports.number(), answered: external_exports.number(), requests: external_exports.number(), goals: external_exports.number(), callbacks: external_exports.number() }),
+  parentId: external_exports.string().nullable()
+});
 var MoveRingSchema2 = external_exports.enum(["home", "travels", "retired", "quarantined"]);
 var MoveSchema2 = external_exports.object({
   id: external_exports.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/harness",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Run Claude Code / Codex on this machine, bridged to Paigy — launchable from your phone.",
   "license": "MIT",
   "type": "module",