@paigy/harness 0.3.16 → 0.3.28

package/dist/cli.js

@@ -16098,13 +16098,13 @@ var require_headers = __commonJS({
           return this.#headersList[kHeadersSortedMap];
         }
         const headers = [];
-        const names = this.#headersList.toSortedArray();
+        const names2 = this.#headersList.toSortedArray();
         const cookies = this.#headersList.cookies;
         if (cookies === null || cookies.length === 1) {
-          return this.#headersList[kHeadersSortedMap] = names;
+          return this.#headersList[kHeadersSortedMap] = names2;
         }
-        for (let i = 0; i < names.length; ++i) {
-          const { 0: name, 1: value } = names[i];
+        for (let i = 0; i < names2.length; ++i) {
+          const { 0: name, 1: value } = names2[i];
           if (name === "set-cookie") {
             for (let j = 0; j < cookies.length; ++j) {
               headers.push([name, cookies[j]]);
@@ -23809,9 +23809,9 @@ async function claimGoal(goalId, opts = {}) {
   if (!res.ok) await fail("claim_goal", res);
   return await res.json();
 }
-async function getGoal(goalId, opts = {}) {
+async function getGoal(goalId, opts = {}, read = {}) {
   const token = authToken(opts.token) ?? "";
-  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}`, {
+  const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/goals/${encodeURIComponent(goalId)}${read.history ? "?history=1" : ""}`, {
     method: "GET",
     headers: { authorization: `Bearer ${token}`, "x-paigy-model": "goal-entry-v1" }
   }));
@@ -24170,7 +24170,7 @@ async function subscribeWake(onNudge, opts = {}) {
     }
   };
 }
-var import_undici, require2, BACKEND_URL, NETWORK_MSG, PROXY_ENV, agent, INSTANCE_ID, WORKSPACE_ID, envSession, lineage, 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, OptionSchema, OptionInputSchema, NIGHT, AskInputSchema, StartContactSchema, ContactSchema, CONTACT_SCHEMA, CONTACT_DESCRIPTION, CreateGoalSchema, CreateGoalToolSchema, CREATE_GOAL_DESCRIPTION, UpdateGoalSchema, UpdateGoalToolSchema, ClaimGoalSchema, GetGoalSchema, GET_GOAL_DESCRIPTION, UPDATE_GOAL_DESCRIPTION, CLAIM_GOAL_DESCRIPTION, CHECK_REPLIES_DESCRIPTION, CheckRepliesSchema, AGENT_TOOLS, AGENT_TOOL_NAMES, LIVE_MS, ContextSchema, ParticipantSchema, TransformSchema, VisualSchema, NotifyLevelSchema, SelectShapeSchema, ReceiptEventSchema, AttentionSchema, NotifyRequestFields, NotifyRequestSchema, NotifyStatusSchema, AgentStateSchema, TurnSchema, UserAnswerSchema, IntentSchema, RideAlongSchema, AwaitItemSchema, VoiceKeySchema, AgendaTurnSchema, CLAIM_STALE_MS, InboxItemSchema, APNS_TOKEN_RE, PushTokenSchema, MissedCallSchema, clock, QUIET, BrokerTuningSchema, UserSettingsSchema, HistoryItemSchema, ACTIVITY_LINES, ACTIVITY_LINE_MAX, AgentActivitySchema, ConnectionSummarySchema, LedgerItemSchema, AgentLedgerSchema, ReassignResultSchema, MoveRingSchema, MoveSchema, QueueQuestionSchema, QueueReplySchema, QueueItemSchema, COLD_AFTER_MS, NoteSourceSchema, NoteStatusSchema, NoteRepeatSchema, DecisionSchema, NoteSchema, TriageItemSchema, TriageAssignmentSchema, TriageStatusSchema, SubmitTriageSchema, TriageProposalSchema, AcceptTriageSchema, AcceptTriageResultSchema, DeliveryModeSchema, WAKE_EVENT, wakeChannel, RegisterDeliverySchema, OAuthStartSchema, DeliveryConfigSchema, WakeNudgeSchema, PairingStatusSchema, DeviceCodeSchema, DeviceInfoSchema, DeviceTokenSchema, SupportRequestSchema, NotificationFeedbackKindSchema, TOKEN_PATH, KEY_PATH, sleep, UnpairedError, ApiError, tokenOverride, authToken, AWAIT_WINDOW_MS, asked, NOT_SENT, HEARTBEAT_MS, RETRY_MS, JOIN, JOIN_TIMEOUT_MS, lines;
+var import_undici, require2, BACKEND_URL, NETWORK_MSG, PROXY_ENV, agent, INSTANCE_ID, WORKSPACE_ID, envSession, lineage, 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, OptionSchema, OptionInputSchema, NIGHT, AskInputSchema, StartContactSchema, ContactSchema, CONTACT_SCHEMA, CONTACT_DESCRIPTION, CreateGoalSchema, CreateGoalToolSchema, CREATE_GOAL_DESCRIPTION, UpdateGoalSchema, UpdateGoalToolSchema, ClaimGoalSchema, GetGoalSchema, GET_GOAL_DESCRIPTION, UPDATE_GOAL_DESCRIPTION, CLAIM_GOAL_DESCRIPTION, CHECK_REPLIES_DESCRIPTION, CheckRepliesSchema, AGENT_TOOLS, AGENT_TOOL_NAMES, LIVE_MS, ContextSchema, ParticipantSchema, TransformSchema, VisualSchema, NotifyLevelSchema, SelectShapeSchema, ReceiptEventSchema, AttentionSchema, NotifyRequestFields, NotifyRequestSchema, NotifyStatusSchema, AgentStateSchema, TurnSchema, UserAnswerSchema, IntentSchema, RideAlongSchema, AwaitItemSchema, VoiceKeySchema, AgendaTurnSchema, CLAIM_STALE_MS, InboxItemSchema, APNS_TOKEN_RE, PushTokenSchema, MissedCallSchema, clock, QUIET, BrokerTuningSchema, UserSettingsSchema, HistoryItemSchema, ACTIVITY_LINES, ACTIVITY_LINE_MAX, AgentActivitySchema, ConnectionSummarySchema, LedgerItemSchema, AgentLedgerSchema, ReassignResultSchema, MoveRingSchema, MoveSchema, QueueQuestionSchema, QueueReplySchema, QueueItemSchema, COLD_AFTER_MS, NoteSourceSchema, NoteStatusSchema, NoteRepeatSchema, DecisionSchema, NoteSchema, TriageItemSchema, TriageAssignmentSchema, TriageStatusSchema, SubmitTriageSchema, TriageProposalSchema, AcceptTriageSchema, AcceptTriageResultSchema, DeliveryModeSchema, WAKE_EVENT, wakeChannel, RegisterDeliverySchema, OAuthStartSchema, DeliveryConfigSchema, WakeNudgeSchema, PairingStatusSchema, DeviceCodeSchema, DeviceInfoSchema, DeviceTokenSchema, SupportRequestSchema, NotificationFeedbackKindSchema, SlimOptionSchema, QuestionRowSchema, WorkStateSchema, WorkRowSchema, ComputerRowSchema, AgentRowSchema, SnapshotSchema, TOKEN_PATH, KEY_PATH, sleep, UnpairedError, ApiError, tokenOverride, authToken, AWAIT_WINDOW_MS, asked, NOT_SENT, HEARTBEAT_MS, RETRY_MS, JOIN, JOIN_TIMEOUT_MS, lines;
 var init_dist = __esm({
   "../../packages/sdk/dist/index.js"() {
     "use strict";
@@ -24639,8 +24639,13 @@ var init_dist = __esm({
     }).strict();
     UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({ goalId: external_exports.string().uuid() }).strict();
     ClaimGoalSchema = external_exports.object({ goalId: external_exports.string().uuid().optional() }).strict();
-    GetGoalSchema = external_exports.object({ goalId: external_exports.string().uuid() }).strict();
-    GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), and `next`, the one step to take. Foreign or sibling-owned Goals are not disclosed.";
+    GetGoalSchema = external_exports.object({
+      goalId: external_exports.string().uuid(),
+      /** Every entry in full. Without it the read carries the person's words, open questions and your
+       *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
+      history: external_exports.boolean().optional()
+    }).strict();
+    GET_GOAL_DESCRIPTION = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
     UPDATE_GOAL_DESCRIPTION = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
     CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
     CHECK_REPLIES_DESCRIPTION = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
@@ -25059,7 +25064,13 @@ var init_dist = __esm({
          *  request Entry's author, as the same three facts the item's own `tokenId`/`name`/`voice`
          *  carry for the call's one agent, so the phone draws it with the same seed. Absent when the
          *  author is not an agent this account holds (unpaired since, or a person). */
-        agent: external_exports.object({ tokenId: external_exports.string(), name: external_exports.string(), voice: VoiceKeySchema.optional() }).optional()
+        agent: external_exports.object({ tokenId: external_exports.string(), name: external_exports.string(), voice: VoiceKeySchema.optional() }).optional(),
+        /** ITS OPTIONS, WHEN THERE IS SOMETHING TO SEE (owner, 2026-09-25: "Yes, add it"): the options
+         *  its need offers, exactly as its own card carries them, present only when one of them has a
+         *  preview (`html` or `image`). The call screen opens them from the agenda row, so a preview is
+         *  never re-sent as a second card to be seen mid-call. Words-only options are absent — the bot
+         *  says those, and the list stays small (an `html` is up to 16 KB). */
+        options: external_exports.array(OptionSchema).optional()
       })).optional(),
       visuals: external_exports.array(VisualSchema).optional(),
       /** The connected agent's name (the single pairing name — user-typed, or the
@@ -25455,7 +25466,19 @@ var init_dist = __esm({
       /** When its owner last SAID something about it (`goals.last_progress_at`, written by every
        *  `update_goal` that changes `progress`). `updatedAt` moves for reasons nobody chose — a
        *  state recomputed, a review flag — so it cannot tell work in hand from work gone quiet. */
-      lastProgressAt: external_exports.string().nullable().optional()
+      lastProgressAt: external_exports.string().nullable().optional(),
+      /** THE GOAL'S NEWEST WORD, FROM EITHER SIDE (owner, 2026-09-27): the newest Entry on it, of any
+       *  kind — what the person added ("Add to this"), their reply, the agent's ask or its progress
+       *  note. A progress note is an Entry, so this is already the newer of the two: the person's note
+       *  shows the moment it is written, and the agent's reply or next note replaces it by being newer.
+       *  `said` is bounded to 280 characters server-side (a line, not the conversation). Null when the
+       *  Goal carries no readable Entry; optional, so hand-built queues need not spell it. */
+      latest: external_exports.object({
+        from: external_exports.enum(["person", "agent"]),
+        said: external_exports.string(),
+        at: external_exports.string(),
+        entryId: external_exports.string()
+      }).nullable().optional()
     });
     COLD_AFTER_MS = 3 * 24 * 60 * 60 * 1e3;
     NoteSourceSchema = external_exports.enum(["app", "call"]);
@@ -25633,6 +25656,104 @@ var init_dist = __esm({
       "other"
       // anything else — the note carries it.
     ]);
+    SlimOptionSchema = OptionSchema.omit({ html: true });
+    QuestionRowSchema = external_exports.object({
+      /** The card's id (`deliveryId:needId`, or `deliveryId:entryId` for an update), as the inbox mints it. */
+      id: external_exports.string(),
+      deliveryId: external_exports.string(),
+      entryId: external_exports.string(),
+      /** The decision it waits on; null for an update, which asks nothing. */
+      needId: external_exports.string().nullable(),
+      goalIds: external_exports.array(external_exports.string()),
+      /** The name of the work it is about, when the read could word it. */
+      goalTitle: external_exports.string().optional(),
+      tokenId: external_exports.string().optional(),
+      name: external_exports.string(),
+      title: external_exports.string(),
+      body: external_exports.string(),
+      select: external_exports.enum(["one", "many", "rank", "confirm", "text"]),
+      options: external_exports.array(SlimOptionSchema),
+      hasPreview: external_exports.boolean(),
+      blocking: external_exports.boolean(),
+      askedAt: external_exports.string().datetime(),
+      ring: InboxItemSchema.shape.ring,
+      onCall: external_exports.literal(true).optional(),
+      sealed: external_exports.boolean()
+    });
+    WorkStateSchema = external_exports.enum(["ready", "active", "waiting", "done", "cancelled"]);
+    WorkRowSchema = external_exports.object({
+      id: external_exports.string(),
+      parentId: external_exports.string().nullable(),
+      title: external_exports.string(),
+      /** Straight off the Goal. */
+      state: WorkStateSchema,
+      owner: external_exports.string().nullable(),
+      revision: external_exports.number().int(),
+      /** Open questions on it, counted to 100. */
+      waiting: external_exports.number().int(),
+      /** Held by a gate on work that is not done. */
+      blocked: external_exports.boolean(),
+      lastProgressAt: external_exports.string().datetime().nullable(),
+      /** The line written for its newest progress note, else that note's first words. */
+      line: external_exports.string().nullable(),
+      /** Work directly under it, counted to 100; the list carries up to 12 of them. */
+      children: external_exports.number().int(),
+      createdAt: external_exports.string().datetime(),
+      updatedAt: external_exports.string().datetime(),
+      /** When anything at or under it last moved — the order the list is in. */
+      activeAt: external_exports.string().datetime(),
+      /** A sealed outcome has no title here; the work's page opens it. */
+      sealed: external_exports.boolean()
+    });
+    ComputerRowSchema = ConnectionSummarySchema.omit({ activity: true });
+    AgentRowSchema = ComputerRowSchema.extend({
+      /** Open questions it is asking the person, over every open card; null when that read failed. */
+      asking: external_exports.number().int().nullable(),
+      oldestAskAt: external_exports.string().datetime().nullable(),
+      /** Up to three of the live Goals it holds, oldest first (the order it picks them up), and how
+       *  many in all among the account's 200 most recently active agent-held live Goals
+       *  (`agent_holds`); null when that read failed. */
+      holds: external_exports.array(external_exports.object({ id: external_exports.string(), title: external_exports.string() })).nullable(),
+      held: external_exports.number().int().nullable(),
+      /** The earliest instant any Goal it holds went quiet, by the one rule (`coldSince`); null
+       *  while none has, or when that read failed. */
+      cold: external_exports.string().datetime().nullable(),
+      /** The newest line of its working log, and when the harness saw it. */
+      line: external_exports.string().nullable(),
+      lineAt: external_exports.string().datetime().nullable()
+    });
+    SnapshotSchema = external_exports.object({
+      /** The API's clock, taken before the first read: what a later delta will start from. */
+      at: external_exports.string().datetime(),
+      questions: external_exports.object({
+        /** The newest 30 open cards, questions before updates. */
+        items: external_exports.array(QuestionRowSchema),
+        /** Every open question, and apart from them every update, and what was put off. */
+        total: external_exports.number().int(),
+        updates: external_exports.number().int(),
+        putOff: external_exports.number().int()
+      }).nullable(),
+      agents: external_exports.object({
+        /** Up to 60, most recently seen first. */
+        items: external_exports.array(AgentRowSchema),
+        more: external_exports.boolean()
+      }).nullable(),
+      work: external_exports.object({
+        /** The 60 most recently active roots, each followed by up to 12 children; 240 rows at most. */
+        items: external_exports.array(WorkRowSchema),
+        /** How much work is behind each of the Work tab's four filters, each counted to 100, read with
+         *  the rows. `work_list` (20260928023533) owns the predicates: Live is `ready`, `active` or
+         *  `waiting`; Waiting on you is live work with an open question or an unmet gate; Not started
+         *  is `ready`; Done is `done` or `cancelled`. */
+        counts: external_exports.object({ live: external_exports.number().int(), waiting: external_exports.number().int(), notStarted: external_exports.number().int(), done: external_exports.number().int() })
+      }).nullable(),
+      you: external_exports.object({
+        settings: UserSettingsSchema,
+        callable: external_exports.boolean(),
+        /** Up to 20 paired computers; null when the roster read failed. */
+        computers: external_exports.array(ComputerRowSchema).nullable()
+      }).nullable()
+    });
     TOKEN_PATH = join22(homedir22(), ".paigy", "token.json");
     KEY_PATH = join22(homedir22(), ".paigy", "key.json");
     sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -30239,7 +30360,7 @@ var require_lib = __commonJS({
 
 // src/triage/judge.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir9 } from "os";
 import { delimiter as delimiter3 } from "path";
 function pickOllamaModel(tags) {
   if (tags.length === 0) return null;
@@ -30322,7 +30443,7 @@ async function judgeFor(asked2, deps = {}) {
       const out = spawnSync2(bin, runner.argv(null), {
         input: prompt,
         encoding: "utf8",
-        cwd: homedir7(),
+        cwd: homedir9(),
         timeout: RUN_TIMEOUT_MS,
         maxBuffer: 32 * 1024 * 1024,
         env: { ...process.env, PATH: [process.env["PATH"], ...probeDirs()].filter(Boolean).join(delimiter3) }
@@ -30364,8 +30485,8 @@ var init_judge = __esm({
 });
 
 // src/triage/evidence.ts
-function assigneeToken(note) {
-  const ref = note.assignee ?? "";
+function assigneeToken(note2) {
+  const ref = note2.assignee ?? "";
   return ref.startsWith("agent:") ? ref.slice("agent:".length) : null;
 }
 function words(text) {
@@ -30393,23 +30514,23 @@ function overlap(a, b) {
   for (const w of A) if (B.has(w)) shared++;
   return shared / (A.size + B.size - shared);
 }
-function supersededBy(note, all) {
-  const mine = `${note.title} ${note.intent}`;
-  const at = Date.parse(note.createdAt);
+function supersededBy(note2, all) {
+  const mine = `${note2.title} ${note2.intent}`;
+  const at = Date.parse(note2.createdAt);
   let best = null;
   for (const other of all) {
-    if (other.id === note.id) continue;
+    if (other.id === note2.id) continue;
     if (Date.parse(other.createdAt) <= at) continue;
     const score = overlap(mine, `${other.title} ${other.intent}`);
     if (score >= SUPERSEDE_AT && (!best || score > best.score)) best = { note: other, score };
   }
   return best?.note ?? null;
 }
-function doneEcho(note, all) {
-  const mine = `${note.title} ${note.intent}`;
+function doneEcho(note2, all) {
+  const mine = `${note2.title} ${note2.intent}`;
   let best = null;
   for (const other of all) {
-    if (other.id === note.id || other.status !== "done") continue;
+    if (other.id === note2.id || other.status !== "done") continue;
     const score = overlap(mine, `${other.title} ${other.intent}`);
     if (score >= SUPERSEDE_AT && (!best || score > best.score)) best = { note: other, score };
   }
@@ -30463,8 +30584,8 @@ function dossier(notes, connections, now) {
     today: new Date(now).toISOString().slice(0, 10)
   };
 }
-function affinityWhy(note, agent2) {
-  const shared = note.repoHints.filter((r) => agent2.repos.includes(r));
+function affinityWhy(note2, agent2) {
+  const shared = note2.repoHints.filter((r) => agent2.repos.includes(r));
   if (shared.length && agent2.recentNotes)
     return `worked ${agent2.recentNotes} note${agent2.recentNotes === 1 ? "" : "s"} in ${shared[0]} this week`;
   if (agent2.recentNotes >= 2) return `took ${agent2.recentNotes} notes this week`;
@@ -30473,12 +30594,12 @@ function affinityWhy(note, agent2) {
     return `last spoke ${agent2.lastContactDays === 0 ? "today" : `${agent2.lastContactDays}d ago`}`;
   return null;
 }
-function staleWhy(note) {
-  if (note.doneEcho) return `a later note says this shipped: "${note.doneEcho.title}"`;
-  if (note.supersededBy) return `superseded by "${note.supersededBy.title}"`;
-  if (note.rides >= 3) return `carried on ${note.rides} calls and still open`;
-  if (note.idleDays >= 30) return `no movement in ${note.idleDays} days`;
-  if (note.idleDays >= 14 && note.status === "open") return `unassigned for ${note.idleDays} days`;
+function staleWhy(note2) {
+  if (note2.doneEcho) return `a later note says this shipped: "${note2.doneEcho.title}"`;
+  if (note2.supersededBy) return `superseded by "${note2.supersededBy.title}"`;
+  if (note2.rides >= 3) return `carried on ${note2.rides} calls and still open`;
+  if (note2.idleDays >= 30) return `no movement in ${note2.idleDays} days`;
+  if (note2.idleDays >= 14 && note2.status === "open") return `unassigned for ${note2.idleDays} days`;
   return null;
 }
 var OPEN_STATUSES, DAY_MS, daysBetween, STOP, SUPERSEDE_AT, RECENT_DAYS;
@@ -30653,22 +30774,22 @@ function toProposal(verdicts, d, meta) {
   const stale = [];
   const assignments = /* @__PURE__ */ new Map();
   for (const v of verdicts) {
-    const note = byId.get(v.id);
-    if (!note) continue;
-    const item = (why) => ({ noteId: note.id, title: note.title, why });
+    const note2 = byId.get(v.id);
+    if (!note2) continue;
+    const item = (why) => ({ noteId: note2.id, title: note2.title, why });
     if (v.verdict === "close") {
-      close.push(item(staleWhy(note) ?? v.why ?? "looks finished"));
+      close.push(item(staleWhy(note2) ?? v.why ?? "looks finished"));
       continue;
     }
     if (v.verdict === "stale") {
-      stale.push(item(staleWhy(note) ?? v.why ?? `no movement in ${note.idleDays} days`));
+      stale.push(item(staleWhy(note2) ?? v.why ?? `no movement in ${note2.idleDays} days`));
       continue;
     }
     if (v.verdict !== "assign" || !v.agent) continue;
     const agent2 = agentById.get(v.agent);
     if (!agent2) continue;
     const group = assignments.get(agent2.token) ?? { agent: agent2.token, agentName: agent2.name, notes: [] };
-    group.notes.push(item(affinityWhy(note, agent2) ?? v.why ?? "best match for this work"));
+    group.notes.push(item(affinityWhy(note2, agent2) ?? v.why ?? "best match for this work"));
     assignments.set(agent2.token, group);
   }
   return {
@@ -30891,6 +31012,15 @@ function parseArgs(argv) {
     return { error: "--yes-close/--yes-stale/--yes-assign only apply with --apply" };
   return args;
 }
+var MCP_WIRES = [
+  { cli: "claude", name: "Claude Code", wire: "claude plugin marketplace add paigy-ai/mcp; claude plugin install paigy@paigy" },
+  // 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", wire: "agy mcp list | grep -q '^paigy ' || agy mcp add paigy -- npx -y @paigy/mcp@latest" }
+];
 var ENABLE_TOOLS_COMMAND = "npx -y -p @paigy/mcp@latest paigy-enable-tools";
 function onEnter(input, onLine) {
   if (!input.isTTY) return () => {
@@ -30910,10 +31040,10 @@ function onEnter(input, onLine) {
 init_dist();
 var import_qrcode = __toESM(require_lib(), 1);
 import { hostname } from "os";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { execFile as execFile2, execSync } from "child_process";
-import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
 
 // src/run.ts
 init_dist();
@@ -30921,29 +31051,34 @@ init_dist();
 // src/harness/session.ts
 import { spawn } from "child_process";
 import { existsSync as existsSync3 } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { resolve, delimiter as delimiter2 } from "path";
 
 // src/harness/acp.ts
 var none = { events: [], writes: [] };
+var NOTHING_TO_RESUME = /* @__PURE__ */ new Set([-32002, -32601]);
 function optionFor(options, decision) {
   const want = decision.allow ? "allow_once" : "reject_once";
   return options.find((o) => o.kind === want)?.optionId ?? null;
 }
 function createAcpDriver(opts) {
-  return new AcpDriver(opts.cwd, opts.mode, opts.resume);
+  return new AcpDriver(opts.cwd, opts.mode, opts.resume, opts.meta);
 }
 var AcpDriver = class {
   /** `resume`: the id of an existing session to continue rather than open a new one (#1637) —
-   *  the session a bound identity belongs to, so the process this drives IS its holder. */
-  constructor(cwd, mode, resume) {
+   *  the session a bound identity belongs to, so the process this drives IS its holder.
+   *  `meta`: the adapter's own `_meta` on the frame that opens the session — where a switch only
+   *  one adapter understands rides (`session.ts`, a Claude session's tools). */
+  constructor(cwd, mode, resume, meta) {
     this.cwd = cwd;
     this.mode = mode;
     this.resume = resume;
+    this.meta = meta;
   }
   cwd;
   mode;
   resume;
+  meta;
   nextId = 1;
   initId;
   sessionNewId;
@@ -30963,6 +31098,11 @@ var AcpDriver = class {
   /** The turn being streamed: text accumulates, tools append, both flush on stopReason. */
   text = "";
   tools = [];
+  /** Tool calls opened and not yet reported `completed` or `failed`, by `toolCallId` — whoever
+   *  started them. A running tool is the one long silence that is still a working turn (`quiet`). */
+  running = /* @__PURE__ */ new Set();
+  /** The prompt in flight was already cancelled for silence: once is the whole remedy. */
+  cancelled = false;
   /** The opening frame. Everything after is driven by responses in `handleLine`. */
   open() {
     this.initId = this.nextId++;
@@ -30994,6 +31134,29 @@ var AcpDriver = class {
       optionId ? frame2({ id: request.id, result: { outcome: { outcome: "selected", optionId } } }) : frame2({ id: request.id, result: { outcome: { outcome: "cancelled" } } })
     ];
   }
+  /**
+   * THE ANSWER THAT NEVER COMES (2026-09-26, session "mute"). A turn ends when the adapter answers
+   * its prompt, and nothing else ends one. claude-agent-acp can fold a prompt into a turn the agent
+   * started on its own and never answer it (agentclientprotocol/claude-agent-acp#1145): the prompt
+   * stayed in flight, no `idle` came, the pump never saw the agent rest, and the session was deaf
+   * for twelve hours with its heartbeat alive.
+   *
+   * The caller's clock says nothing has crossed the pipe for `ms`; this says whether that silence
+   * is still a turn. A running tool is (a ten-minute build streams nothing), and so is a permission
+   * waiting on the person. Anything else, with a prompt in flight, is a turn that is over without
+   * its answer, and the remedy is the protocol's own settle: `session/cancel`, which the adapter
+   * answers `stopReason: "cancelled"` through the ordinary response path above — a turn that
+   * ended, not one that failed. Once per prompt, and said as a crumb: a silent recovery is
+   * indistinguishable from a working turn.
+   */
+  quiet(ms) {
+    if (this.promptId === void 0 || this.cancelled || this.running.size || this.pending.size) return none;
+    this.cancelled = true;
+    return {
+      events: [{ kind: "error", message: `turn settled: no reply after ${Math.round(ms / 1e3)}s quiet with no tool running \u2014 sent session/cancel` }],
+      writes: [frame2({ method: "session/cancel", params: { sessionId: this.sessionId } })]
+    };
+  }
   /** Cancel anything still blocked — called on stop so the process can exit cleanly. */
   close() {
     const writes = [...this.pending.values()].map(
@@ -31022,20 +31185,26 @@ var AcpDriver = class {
     if (msg.id === this.initId) {
       this.initId = void 0;
       if (msg.error) {
-        return { events: [{ kind: "error", message: `initialize failed: ${msg.error.message}` }], writes: [] };
+        return { events: [{ kind: "error", message: `initialize failed: ${msg.error.message}`, fatal: true }], writes: [] };
       }
       this.sessionNewId = this.nextId++;
-      return {
-        events: [],
-        writes: [frame2(this.resume ? { id: this.sessionNewId, method: "session/resume", params: { sessionId: this.resume, cwd: this.cwd, mcpServers: [] } } : { id: this.sessionNewId, method: "session/new", params: { cwd: this.cwd, mcpServers: [] } })]
-      };
+      return { events: [], writes: [frame2(this.opening(this.sessionNewId))] };
     }
     if (msg.id === this.sessionNewId) {
       this.sessionNewId = void 0;
+      const resuming = this.resume !== void 0;
+      if (resuming && msg.error?.code !== void 0 && NOTHING_TO_RESUME.has(msg.error.code)) {
+        this.resume = void 0;
+        this.sessionNewId = this.nextId++;
+        return {
+          events: [{ kind: "error", message: `session/resume found nothing to resume (${msg.error.message}) \u2014 opening a new conversation` }],
+          writes: [frame2(this.opening(this.sessionNewId))]
+        };
+      }
       const sessionId2 = msg.error ? void 0 : msg.result?.sessionId ?? this.resume;
       if (!sessionId2) {
         return {
-          events: [{ kind: "error", message: `${this.resume ? "session/resume" : "session/new"} failed: ${msg.error?.message ?? "no sessionId"}` }],
+          events: [{ kind: "error", message: `${resuming ? "session/resume" : "session/new"} failed: ${msg.error?.message ?? "no sessionId"}`, fatal: true }],
           writes: []
         };
       }
@@ -31054,6 +31223,8 @@ var AcpDriver = class {
     }
     if (msg.id === this.promptId) {
       this.promptId = void 0;
+      this.running.clear();
+      this.cancelled = false;
       const events = [];
       const report = this.text.slice(this.reportFrom).trim() || this.text.trim();
       if (report || this.tools.length) {
@@ -31085,6 +31256,10 @@ var AcpDriver = class {
   handleNotification(msg) {
     if (msg.method !== "session/update") return none;
     const update = msg.params?.update;
+    if (update?.toolCallId) {
+      if (update.status === "completed" || update.status === "failed") this.running.delete(update.toolCallId);
+      else if (update.sessionUpdate === "tool_call") this.running.add(update.toolCallId);
+    }
     switch (update?.sessionUpdate) {
       case "agent_message_chunk":
         this.text += update.content?.text ?? "";
@@ -31092,9 +31267,9 @@ var AcpDriver = class {
       case "tool_call": {
         const title = update.title?.trim() || update.kind || "tool";
         this.tools.push(title);
-        const note = this.text.slice(this.reportFrom).trim();
+        const note2 = this.text.slice(this.reportFrom).trim();
         this.reportFrom = this.text.length;
-        return { events: [{ kind: "work", tool: title, ...note ? { note } : {} }], writes: [] };
+        return { events: [{ kind: "work", tool: title, ...note2 ? { note: note2 } : {} }], writes: [] };
       }
       default:
         return none;
@@ -31128,6 +31303,12 @@ var AcpDriver = class {
       writes: []
     };
   }
+  /** The frame that opens the conversation: a resume of `resume` while there is one to try,
+   *  else a new session. */
+  opening(id) {
+    const params = { cwd: this.cwd, mcpServers: [], ...this.meta ? { _meta: this.meta } : {} };
+    return this.resume ? { id, method: "session/resume", params: { sessionId: this.resume, ...params } } : { id, method: "session/new", params };
+  }
   /** Send the queued prompts as one turn, if the agent can take one right now. */
   flush() {
     if (!this.sessionId || this.promptId !== void 0 || !this.queued.length) return [];
@@ -31147,11 +31328,93 @@ var frame2 = (body) => JSON.stringify({ jsonrpc: "2.0", ...body });
 
 // src/harness/session.ts
 init_catalog();
+
+// src/paigy/inbox.ts
+import { mkdirSync as mkdirSync2, readdirSync, renameSync, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { randomUUID as randomUUID4 } from "crypto";
+var MIDTURN_HOOK = `d="$PAIGY_INBOX"; [ -n "$d" ] || { cat >/dev/null; exit 0; }; set -- "$d"/*.note; [ -e "$1" ] || { cat >/dev/null; exit 0; }; grep '"agent_id"' >/dev/null && exit 0; mkdir -p "$d/taken"; o=""; for f in "$@"; do n=\${f##*/}; mv "$f" "$d/taken/$n" 2>/dev/null || continue; touch "$d/taken/$n"; o="$o\${o:+\\n\\n}$(cat "$d/taken/$n")"; done; [ -n "$o" ] || exit 0; printf '{"hookSpecificOutput":{"hookEventName":"PostToolUse","additionalContext":"%s"}}' "$o"`;
+var missing = (error) => error.code === "ENOENT";
+function openInbox(dir) {
+  mkdirSync2(dir, { recursive: true });
+  let written = 0;
+  const receipt = (name) => join4(dir, "taken", `${name}.note`);
+  const taken = (name) => {
+    try {
+      return statSync2(receipt(name)).mtimeMs;
+    } catch (error) {
+      if (missing(error)) return null;
+      throw error;
+    }
+  };
+  return {
+    dir,
+    put(text) {
+      const name = `${Date.now()}-${String(++written).padStart(6, "0")}`;
+      const tmp = join4(dir, `${name}.tmp`);
+      writeFileSync2(tmp, JSON.stringify(text).slice(1, -1));
+      renameSync(tmp, join4(dir, `${name}.note`));
+      return name;
+    },
+    taken,
+    settle(name) {
+      try {
+        renameSync(join4(dir, `${name}.note`), join4(dir, `${name}.back`));
+        rmSync2(join4(dir, `${name}.back`), { force: true });
+        return "retracted";
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+      const seen = taken(name) !== null;
+      rmSync2(receipt(name), { force: true });
+      return seen ? "taken" : "retracted";
+    },
+    close() {
+      rmSync2(dir, { recursive: true, force: true });
+    }
+  };
+}
+var INBOX_ROOT = join4(homedir3(), ".paigy", "inbox");
+var alive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+function inboxFor(root = INBOX_ROOT) {
+  try {
+    for (const name of readdirSync(root)) {
+      const pid = Number(name.split("-")[0]);
+      if (!Number.isInteger(pid) || !alive(pid)) rmSync2(join4(root, name), { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (!missing(error)) throw error;
+  }
+  return openInbox(join4(root, `${process.pid}-${randomUUID4().slice(0, 8)}`));
+}
+
+// src/harness/session.ts
 var ADAPTER_BIN = {
   claude: "claude-agent-acp",
   codex: "codex-acp",
   agy: "paigy-agy-acp"
 };
+var CLAUDE_ONE_WAY_IN = {
+  env: { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1" },
+  disallowedTools: ["Monitor", "ScheduleWakeup", "CronCreate", "Workflow"]
+};
+var CLAUDE_META = {
+  claudeCode: {
+    options: {
+      disallowedTools: CLAUDE_ONE_WAY_IN.disallowedTools,
+      settings: { hooks: { PostToolUse: [{ matcher: "*", hooks: [{ type: "command", command: MIDTURN_HOOK }] }] } }
+    }
+  }
+};
+var QUIET_MS = 15 * 6e4;
 function splitLines(buffer, chunk) {
   const combined = buffer + chunk;
   const parts = combined.split("\n");
@@ -31159,7 +31422,7 @@ function splitLines(buffer, chunk) {
   return { lines: parts.filter((l) => l.trim()), rest };
 }
 function startSession(opts) {
-  const cwd = resolve(opts.cwd.replace(/^~(?=$|\/)/, homedir3()));
+  const cwd = resolve(opts.cwd.replace(/^~(?=$|\/)/, homedir4()));
   if (!existsSync3(cwd)) {
     queueMicrotask(() => opts.onEvent({ kind: "error", message: `workspace does not exist: ${cwd}` }));
   }
@@ -31173,25 +31436,43 @@ function startSession(opts) {
       ...process.env,
       PATH: [process.env.PATH, ...probeDirs()].filter(Boolean).join(delimiter2),
       ...opts.token ? { PAIGY_TOKEN: opts.token } : {},
-      ...opts.resume ? { PAIGY_SESSION_ID: opts.resume } : {},
+      ...opts.resume ?? opts.session ? { PAIGY_SESSION_ID: opts.resume ?? opts.session } : {},
       // A PUMP DRIVES THIS PROCESS (2026-09-22, #2265): every run `runHarness` starts has the
       // bridge's pump typing answers in, so nothing inside it may start a second delivery path.
       // Exported on EVERY spawn — `PAIGY_SESSION_ID` above is the conversation to resume, and a
       // fresh spawn has none, which is how a fresh run read as "not harness-started" to the
       // session-start hook and the `listen` tool (they now test either mark; listening.ts).
-      PAIGY_HARNESS: "1"
+      PAIGY_HARNESS: "1",
+      ...opts.harness === "claude" ? CLAUDE_ONE_WAY_IN.env : {},
+      ...opts.harness === "claude" && opts.inbox ? { PAIGY_INBOX: opts.inbox } : {}
     },
     stdio: ["pipe", "pipe", "pipe"]
   });
+  let ended2 = false;
+  child.stdin?.on("error", () => {
+  });
   const write = (frames) => {
+    if (ended2) return;
     for (const f of frames) child.stdin?.write(`${f}
 `);
+    if (frames.length) listen();
+  };
+  const apply = ({ events, writes }) => {
+    write(writes);
+    for (const event of events) opts.onEvent(event);
+  };
+  let hush;
+  const listen = () => {
+    clearTimeout(hush);
+    if (!ended2) hush = setTimeout(() => apply(driver.quiet(QUIET_MS)), QUIET_MS);
   };
   child.stderr?.on("data", (chunk) => {
     const text = String(chunk).trim();
     if (text) opts.onEvent({ kind: "error", message: text });
   });
   child.on("exit", (code) => {
+    ended2 = true;
+    clearTimeout(hush);
     opts.onEvent({ kind: "idle", failed: code !== 0, ...code ? { result: `exited ${code}` } : {} });
     opts.onExit?.();
   });
@@ -31199,16 +31480,18 @@ function startSession(opts) {
     opts.onEvent({ kind: "error", message: e.message });
     opts.onExit?.();
   });
-  const driver = createAcpDriver({ cwd, mode: opts.mode, ...opts.resume ? { resume: opts.resume } : {} });
+  const driver = createAcpDriver({
+    cwd,
+    mode: opts.mode,
+    ...opts.resume ? { resume: opts.resume } : {},
+    ...opts.harness === "claude" ? { meta: CLAUDE_META } : {}
+  });
   let buffer = "";
   child.stdout?.on("data", (chunk) => {
+    listen();
     const { lines: lines2, rest } = splitLines(buffer, String(chunk));
     buffer = rest;
-    for (const line of lines2) {
-      const { events, writes } = driver.handleLine(line);
-      write(writes);
-      for (const event of events) opts.onEvent(event);
-    }
+    for (const line of lines2) apply(driver.handleLine(line));
   });
   write(driver.open());
   return {
@@ -31220,6 +31503,8 @@ function startSession(opts) {
     },
     stop() {
       write(driver.close());
+      ended2 = true;
+      clearTimeout(hush);
       child.kill();
     }
   };
@@ -32632,8 +32917,13 @@ var UpdateGoalSchema2 = external_exports.object({
 }).strict();
 var UpdateGoalToolSchema2 = UpdateGoalSchema2.omit({ operationId: true }).extend({ goalId: external_exports.string().uuid() }).strict();
 var ClaimGoalSchema2 = external_exports.object({ goalId: external_exports.string().uuid().optional() }).strict();
-var GetGoalSchema2 = external_exports.object({ goalId: external_exports.string().uuid() }).strict();
-var GET_GOAL_DESCRIPTION2 = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), and `next`, the one step to take. Foreign or sibling-owned Goals are not disclosed.";
+var GetGoalSchema2 = external_exports.object({
+  goalId: external_exports.string().uuid(),
+  /** Every entry in full. Without it the read carries the person's words, open questions and your
+   *  newest entry, and counts what it left out (`apps/api/src/goal/collapse.ts`). */
+  history: external_exports.boolean().optional()
+}).strict();
+var GET_GOAL_DESCRIPTION2 = "Read one Goal without claiming it: its outcome, state, revision, progress, blockers, the conversation on it (each question with its options and what was decided), `next`, the one step to take, and `more`, where to read further. The conversation carries everything the person said, every open question and your newest entry; your older entries are left out and counted \u2014 history: true reads every entry in full. Another account's Goals, and another agent's Goal that is not below one of yours, are not disclosed.";
 var UPDATE_GOAL_DESCRIPTION2 = `Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, title, and review acknowledgement are explicit; stale revisions are rejected. title is the work's name in one to five words, as a person would refer to it out loud (it is spoken on a call and heads every list); null clears it. reviewed: true acknowledges new evidence and closes the Deliveries addressed to you on that Goal, never over an open decision. dueAt (an ISO instant, or null) makes the Goal wait until then; when it passes you are woken for it \u2014 use it for a promise to follow up later. state: done means the work was accomplished, and it can be reopened: when the person says it is not done ("it's not working"), set state: active on that same Goal instead of starting a new one; its parent reopens with it. cancelled is final. Returns the Goal as get_goal reads it, at its new revision.`;
 var CLAIM_GOAL_DESCRIPTION2 = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Another agent's Goal that has gone quiet for 3 days (check_replies lists them as stalledOthers) is taken over when you claim it, and becomes yours to finish or cancel. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION2 = "What is waiting for you: your open Deliveries (a request the user started toward you, a handoff), one row each with its Goals, how many decisions are still open, and the newest words in brief; `assigned`, your Goals nobody has started yet, however they became yours (claim_goal({goalId}) starts one); and `review`, your Goals with something new on them \u2014 the user's answers and notes are Entries on the Goal, not Deliveries. A pure read with no arguments: nothing is consumed, acknowledged or claimed by reading it, so call it on startup, after a long wait, or whenever you want to know what is outstanding. To act on one, claim its Goal (claim_goal) or reread a Delivery in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true clears the Goal from `review` and closes the Deliveries addressed to you on it.";
@@ -32647,6 +32937,7 @@ var AGENT_TOOLS2 = [
   { name: "update_goal", description: UPDATE_GOAL_DESCRIPTION2, inputSchema: mcpInputSchema2(UpdateGoalToolSchema2) }
 ];
 var AGENT_TOOL_NAMES2 = AGENT_TOOLS2.map((t) => t.name);
+var DONE_MESSAGE = "When the work is done, send one message through contact saying what is done and anything the person needs to do or check.";
 function entryWords(entry) {
   const content = entry.content;
   if (content && "sealed" in content) return "";
@@ -33067,7 +33358,13 @@ var InboxItemSchema2 = external_exports.object({
      *  request Entry's author, as the same three facts the item's own `tokenId`/`name`/`voice`
      *  carry for the call's one agent, so the phone draws it with the same seed. Absent when the
      *  author is not an agent this account holds (unpaired since, or a person). */
-    agent: external_exports.object({ tokenId: external_exports.string(), name: external_exports.string(), voice: VoiceKeySchema2.optional() }).optional()
+    agent: external_exports.object({ tokenId: external_exports.string(), name: external_exports.string(), voice: VoiceKeySchema2.optional() }).optional(),
+    /** ITS OPTIONS, WHEN THERE IS SOMETHING TO SEE (owner, 2026-09-25: "Yes, add it"): the options
+     *  its need offers, exactly as its own card carries them, present only when one of them has a
+     *  preview (`html` or `image`). The call screen opens them from the agenda row, so a preview is
+     *  never re-sent as a second card to be seen mid-call. Words-only options are absent — the bot
+     *  says those, and the list stays small (an `html` is up to 16 KB). */
+    options: external_exports.array(OptionSchema2).optional()
   })).optional(),
   visuals: external_exports.array(VisualSchema2).optional(),
   /** The connected agent's name (the single pairing name — user-typed, or the
@@ -33463,7 +33760,19 @@ var QueueItemSchema2 = external_exports.object({
   /** When its owner last SAID something about it (`goals.last_progress_at`, written by every
    *  `update_goal` that changes `progress`). `updatedAt` moves for reasons nobody chose — a
    *  state recomputed, a review flag — so it cannot tell work in hand from work gone quiet. */
-  lastProgressAt: external_exports.string().nullable().optional()
+  lastProgressAt: external_exports.string().nullable().optional(),
+  /** THE GOAL'S NEWEST WORD, FROM EITHER SIDE (owner, 2026-09-27): the newest Entry on it, of any
+   *  kind — what the person added ("Add to this"), their reply, the agent's ask or its progress
+   *  note. A progress note is an Entry, so this is already the newer of the two: the person's note
+   *  shows the moment it is written, and the agent's reply or next note replaces it by being newer.
+   *  `said` is bounded to 280 characters server-side (a line, not the conversation). Null when the
+   *  Goal carries no readable Entry; optional, so hand-built queues need not spell it. */
+  latest: external_exports.object({
+    from: external_exports.enum(["person", "agent"]),
+    said: external_exports.string(),
+    at: external_exports.string(),
+    entryId: external_exports.string()
+  }).nullable().optional()
 });
 var COLD_AFTER_MS2 = 3 * 24 * 60 * 60 * 1e3;
 var NoteSourceSchema2 = external_exports.enum(["app", "call"]);
@@ -33639,6 +33948,104 @@ var NotificationFeedbackKindSchema2 = external_exports.enum([
   "other"
   // anything else — the note carries it.
 ]);
+var SlimOptionSchema2 = OptionSchema2.omit({ html: true });
+var QuestionRowSchema2 = external_exports.object({
+  /** The card's id (`deliveryId:needId`, or `deliveryId:entryId` for an update), as the inbox mints it. */
+  id: external_exports.string(),
+  deliveryId: external_exports.string(),
+  entryId: external_exports.string(),
+  /** The decision it waits on; null for an update, which asks nothing. */
+  needId: external_exports.string().nullable(),
+  goalIds: external_exports.array(external_exports.string()),
+  /** The name of the work it is about, when the read could word it. */
+  goalTitle: external_exports.string().optional(),
+  tokenId: external_exports.string().optional(),
+  name: external_exports.string(),
+  title: external_exports.string(),
+  body: external_exports.string(),
+  select: external_exports.enum(["one", "many", "rank", "confirm", "text"]),
+  options: external_exports.array(SlimOptionSchema2),
+  hasPreview: external_exports.boolean(),
+  blocking: external_exports.boolean(),
+  askedAt: external_exports.string().datetime(),
+  ring: InboxItemSchema2.shape.ring,
+  onCall: external_exports.literal(true).optional(),
+  sealed: external_exports.boolean()
+});
+var WorkStateSchema2 = external_exports.enum(["ready", "active", "waiting", "done", "cancelled"]);
+var WorkRowSchema2 = external_exports.object({
+  id: external_exports.string(),
+  parentId: external_exports.string().nullable(),
+  title: external_exports.string(),
+  /** Straight off the Goal. */
+  state: WorkStateSchema2,
+  owner: external_exports.string().nullable(),
+  revision: external_exports.number().int(),
+  /** Open questions on it, counted to 100. */
+  waiting: external_exports.number().int(),
+  /** Held by a gate on work that is not done. */
+  blocked: external_exports.boolean(),
+  lastProgressAt: external_exports.string().datetime().nullable(),
+  /** The line written for its newest progress note, else that note's first words. */
+  line: external_exports.string().nullable(),
+  /** Work directly under it, counted to 100; the list carries up to 12 of them. */
+  children: external_exports.number().int(),
+  createdAt: external_exports.string().datetime(),
+  updatedAt: external_exports.string().datetime(),
+  /** When anything at or under it last moved — the order the list is in. */
+  activeAt: external_exports.string().datetime(),
+  /** A sealed outcome has no title here; the work's page opens it. */
+  sealed: external_exports.boolean()
+});
+var ComputerRowSchema2 = ConnectionSummarySchema2.omit({ activity: true });
+var AgentRowSchema2 = ComputerRowSchema2.extend({
+  /** Open questions it is asking the person, over every open card; null when that read failed. */
+  asking: external_exports.number().int().nullable(),
+  oldestAskAt: external_exports.string().datetime().nullable(),
+  /** Up to three of the live Goals it holds, oldest first (the order it picks them up), and how
+   *  many in all among the account's 200 most recently active agent-held live Goals
+   *  (`agent_holds`); null when that read failed. */
+  holds: external_exports.array(external_exports.object({ id: external_exports.string(), title: external_exports.string() })).nullable(),
+  held: external_exports.number().int().nullable(),
+  /** The earliest instant any Goal it holds went quiet, by the one rule (`coldSince`); null
+   *  while none has, or when that read failed. */
+  cold: external_exports.string().datetime().nullable(),
+  /** The newest line of its working log, and when the harness saw it. */
+  line: external_exports.string().nullable(),
+  lineAt: external_exports.string().datetime().nullable()
+});
+var SnapshotSchema2 = external_exports.object({
+  /** The API's clock, taken before the first read: what a later delta will start from. */
+  at: external_exports.string().datetime(),
+  questions: external_exports.object({
+    /** The newest 30 open cards, questions before updates. */
+    items: external_exports.array(QuestionRowSchema2),
+    /** Every open question, and apart from them every update, and what was put off. */
+    total: external_exports.number().int(),
+    updates: external_exports.number().int(),
+    putOff: external_exports.number().int()
+  }).nullable(),
+  agents: external_exports.object({
+    /** Up to 60, most recently seen first. */
+    items: external_exports.array(AgentRowSchema2),
+    more: external_exports.boolean()
+  }).nullable(),
+  work: external_exports.object({
+    /** The 60 most recently active roots, each followed by up to 12 children; 240 rows at most. */
+    items: external_exports.array(WorkRowSchema2),
+    /** How much work is behind each of the Work tab's four filters, each counted to 100, read with
+     *  the rows. `work_list` (20260928023533) owns the predicates: Live is `ready`, `active` or
+     *  `waiting`; Waiting on you is live work with an open question or an unmet gate; Not started
+     *  is `ready`; Done is `done` or `cancelled`. */
+    counts: external_exports.object({ live: external_exports.number().int(), waiting: external_exports.number().int(), notStarted: external_exports.number().int(), done: external_exports.number().int() })
+  }).nullable(),
+  you: external_exports.object({
+    settings: UserSettingsSchema2,
+    callable: external_exports.boolean(),
+    /** Up to 20 paired computers; null when the roster read failed. */
+    computers: external_exports.array(ComputerRowSchema2).nullable()
+  }).nullable()
+});
 
 // src/paigy/activity.ts
 function shortenPaths(s) {
@@ -33648,8 +34055,8 @@ function shortenPaths(s) {
   });
 }
 function workLine(event) {
-  const note = (event.note ?? "").split("\n").find((l) => l.trim()) ?? "";
-  const line = shortenPaths([event.tool.trim(), note.trim()].filter(Boolean).join(" \u2014 ").replace(/\s+/g, " "));
+  const note2 = (event.note ?? "").split("\n").find((l) => l.trim()) ?? "";
+  const line = shortenPaths([event.tool.trim(), note2.trim()].filter(Boolean).join(" \u2014 ").replace(/\s+/g, " "));
   return line.length > ACTIVITY_LINE_MAX2 ? `${line.slice(0, ACTIVITY_LINE_MAX2 - 1)}\u2026` : line;
 }
 function pushWork(lines2, line) {
@@ -33663,127 +34070,131 @@ function sameTail(a, b) {
 // src/paigy/bridge.ts
 init_dist();
 
-// src/paigy/conversation.ts
-import { randomUUID as randomUUID4 } from "crypto";
-var HARNESS_INSTRUCTION = "You are running as an unattended background harness agent connected to your user through Paigy. The user is NOT at the terminal and cannot see text printed here. To ask questions, request approvals, or make decisions, use Paigy tools or end your turn with a clear question for the bridge to relay. When complete, provide a concise summary of what was accomplished.";
-function endsWithQuestion(text) {
-  if (!text) return false;
-  const trimmed = text.trim();
-  if (!trimmed) return false;
-  if (trimmed.endsWith("?")) return true;
-  const lines2 = trimmed.split("\n").map((l) => l.trim()).filter(Boolean);
-  if (lines2.length === 0) return false;
-  let lastNonListIdx = lines2.length - 1;
-  while (lastNonListIdx >= 0) {
-    const line = lines2[lastNonListIdx];
-    if (line && /^[-*•\d.)]\s+/.test(line)) {
-      lastNonListIdx--;
-    } else {
-      break;
-    }
-  }
-  const promptLine = lastNonListIdx >= 0 ? lines2[lastNonListIdx] : lines2[lines2.length - 1];
-  if (promptLine?.endsWith("?")) return true;
-  const tail = lines2.slice(-3).join(" ").toLowerCase();
-  return [
-    /\b(let me know|which (one|would|do you)|do you want|should i|shall i)\b/,
-    /\b(want me to|prefer|your call|up to you|confirm whether)\b/,
-    /\b(how would you like|how should we|what would you like|what should we)\b/,
-    /\b(please choose|choose one|select one|how do you want)\b/
-  ].some((re) => re.test(tail));
+// src/paigy/limit.ts
+var LIMIT_PREFIXES = [
+  "You've hit your",
+  "You've reached your",
+  "You're out of usage credits",
+  "Your org is out of usage",
+  "Your seat type doesn't include usage",
+  "Your usage allocation has been disabled by your admin",
+  "Your group's usage limit is set to $0",
+  "requires usage credits",
+  "You're out of extra usage",
+  "Your seat type doesn't include extra usage"
+];
+var RETRY_MS2 = 15 * 6e4;
+var MARGIN_MS = 6e4;
+var FARTHEST_MS = 8 * 24 * 60 * 6e4;
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+function limitIn(text, now) {
+  const line = (text ?? "").split("\n").map((l) => l.trim()).reverse().find((l) => LIMIT_PREFIXES.some((p) => l.startsWith(p) || p === "requires usage credits" && l.includes(p)));
+  if (!line) return null;
+  const reset = resetOf(line, now);
+  if (reset !== null && reset > now && reset - now <= FARTHEST_MS) {
+    return { until: reset + MARGIN_MS, resets: /resets\s+(?:at\s+)?(.+?)\s*(?:\(|$)/i.exec(line)?.[1]?.trim() ?? clock3(reset) };
+  }
+  return { until: now + RETRY_MS2, resets: clock3(now + RETRY_MS2) };
 }
-var POLL_MS = 5e3;
-var wait = () => new Promise((r) => setTimeout(r, POLL_MS));
-var ended = (state) => state === "done" || state === "cancelled";
-function unheard(brief, state) {
-  const seen = state.seen ??= /* @__PURE__ */ new Set();
-  const words2 = [];
-  for (const e of brief.entries ?? []) {
-    if (seen.has(e.entryId) || !e.authorParticipant.startsWith("human:")) continue;
-    seen.add(e.entryId);
-    if (e.aboutId && seen.has(e.aboutId) && brief.answers?.some((a) => a.requestEntryId === e.aboutId)) continue;
-    const text = entryWords(e).trim();
-    if (text) words2.push(text);
-  }
-  return words2;
+function resetOf(line, now) {
+  const m = /resets\s+(?:at\s+)?(?:([a-z]{3})[a-z]*\s+(\d{1,2}),?\s+(?:at\s+)?)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b(?:\s*\(([^)]+)\))?/i.exec(line);
+  if (!m) return null;
+  const zone = zoneOr(m[6]);
+  let hour = Number(m[3]) % 12;
+  if (m[5].toLowerCase() === "pm") hour += 12;
+  const minute = Number(m[4] ?? 0);
+  const today = partsAt(now, zone);
+  if (m[1]) {
+    const month = MONTHS.indexOf(m[1].toLowerCase());
+    if (month < 0) return null;
+    const at2 = wallToEpoch(today.year, month, Number(m[2]), hour, minute, zone);
+    return at2 > now ? at2 : wallToEpoch(today.year + 1, month, Number(m[2]), hour, minute, zone);
+  }
+  const at = wallToEpoch(today.year, today.month, today.day, hour, minute, zone);
+  return at > now ? at : wallToEpoch(today.year, today.month, today.day + 1, hour, minute, zone);
 }
-async function step(session, state, rail, opts) {
-  if (!state.goal) {
-    if (!state.resting) return;
-    let brief2 = await rail.claim();
-    if (!brief2.goalId || brief2.revision === void 0) {
-      if (opts?.initialPrompt?.trim()) {
-        const prompt = opts.initialPrompt.trim();
-        opts.initialPrompt = void 0;
-        const admitted = await rail.create({ outcome: prompt, idempotencyKey: randomUUID4() });
-        brief2 = await rail.claim();
-        if (!brief2.goalId || brief2.revision === void 0) {
-          state.goal = { id: admitted.goalId, revision: admitted.revision };
-          if (checkCallOnDone(prompt)) state.callOnDone = true;
-          send2(session, state, [HARNESS_INSTRUCTION, prompt].join("\n\n"));
-          return;
-        }
-      } else {
-        return;
-      }
-    }
-    unheard(brief2, state);
-    if (ended(brief2.state)) await rail.update(brief2.goalId, { revision: brief2.revision, changes: { reviewed: true }, reason: "Typed into the session." });
-    else state.goal = { id: brief2.goalId, revision: brief2.revision };
-    const outcome = brief2.outcome?.trim() ?? "";
-    const said = (brief2.entries ?? []).map((e) => entryWords(e).trim()).filter((w) => w && w.toLowerCase() !== outcome.toLowerCase());
-    const fullText = [outcome, ...said].filter(Boolean).join("\n\n");
-    if (checkCallOnDone(fullText)) state.callOnDone = true;
-    send2(session, state, [HARNESS_INSTRUCTION, fullText].filter(Boolean).join("\n\n"));
-    return;
-  }
-  const brief = await rail.read(state.goal.id);
-  state.goal.revision = brief.revision ?? state.goal.revision;
-  for (const answer of brief.answers ?? []) {
-    const resolve3 = state.asks?.get(answer.requestEntryId);
-    if (!resolve3) continue;
-    state.asks.delete(answer.requestEntryId);
-    resolve3(answer.result);
-  }
-  if (ended(brief.state)) {
-    state.goal = void 0;
-    for (const resolve3 of state.asks?.values() ?? []) resolve3(null);
-    state.asks?.clear();
-    return;
-  }
-  if (state.asks?.size || !state.resting) return;
-  const words2 = unheard(brief, state);
-  if (words2.length) {
-    const text = words2.join("\n\n");
-    if (checkCallOnDone(text)) state.callOnDone = true;
-    send2(session, state, text);
+function zoneOr(zone) {
+  const local = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (!zone) return local;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: zone.trim() });
+    return zone.trim();
+  } catch {
+    return local;
   }
 }
-function send2(session, state, text) {
-  state.resting = false;
-  session.send(text);
+function partsAt(t, zone) {
+  const p = Object.fromEntries(
+    new Intl.DateTimeFormat("en-US", { timeZone: zone, hourCycle: "h23", year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric" }).formatToParts(new Date(t)).map((x) => [x.type, x.value])
+  );
+  return { year: Number(p.year), month: Number(p.month) - 1, day: Number(p.day), hour: Number(p.hour), minute: Number(p.minute), second: Number(p.second) };
 }
-async function pump(session, state, rail, opts) {
-  const promptRef = opts.initialPrompt ? { initialPrompt: opts.initialPrompt } : void 0;
-  for (; ; ) {
-    try {
-      await step(session, state, rail, promptRef);
-    } catch {
+function wallToEpoch(year, month, day, hour, minute, zone) {
+  const wall = Date.UTC(year, month, day, hour, minute);
+  const offset = (t) => {
+    const p = partsAt(t, zone);
+    return Date.UTC(p.year, p.month, p.day, p.hour, p.minute, p.second) - Math.floor(t / 1e3) * 1e3;
+  };
+  const first = wall - offset(wall);
+  return wall - offset(first);
+}
+function clock3(t) {
+  return new Date(t).toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit" }).replace(/\s?([AP])M$/i, (_, x) => `${x.toLowerCase()}m`);
+}
+var pausedLine = (limit) => `Paused by the usage limit until ${limit.resets}`;
+var CARRY_ON = "The usage limit that stopped your last turn has reset. Carry on where you stopped.";
+var OWED = "That turn was given this when the limit stopped it, and may not have got to it. Act on it now, unless you already have:";
+var names = (list) => list.length <= 1 ? list[0] ?? "" : `${list.slice(0, -1).join(", ")} and ${list[list.length - 1]}`;
+var GATHER_MS = 9e4;
+function episodes(opts = {}) {
+  const gather2 = opts.gatherMs ?? GATHER_MS;
+  const later = opts.timer ?? ((fn, ms) => void setTimeout(fn, ms).unref?.());
+  let open = null;
+  return {
+    paused(name, now) {
+      if (!open || open.called) open = { since: now, paused: [], running: [], called: false, scheduled: false };
+      if (!open.paused.includes(name)) open.paused.push(name);
+      open.running = open.running.filter((n) => n !== name);
+    },
+    running(name, call, log) {
+      const episode = open;
+      if (!episode || !episode.paused.includes(name)) return;
+      if (episode.called) {
+        log?.(`\u25B6 ${name} is running again after the limit (the call already went out)`);
+        return;
+      }
+      if (!episode.running.includes(name)) episode.running.push(name);
+      if (episode.scheduled) return;
+      episode.scheduled = true;
+      later(() => {
+        if (!episode.running.length) {
+          episode.scheduled = false;
+          return;
+        }
+        episode.called = true;
+        const rest = episode.paused.filter((n) => !episode.running.includes(n));
+        const text = [
+          `Claude's usage limit paused ${names(episode.paused)} from ${clock3(episode.since)}.`,
+          rest.length ? `It has reset: ${names(episode.running)} ${episode.running.length > 1 ? "are" : "is"} running again, and ${names(rest)} ${rest.length > 1 ? "haven't" : "hasn't"} started again yet.` : `It has reset, and ${episode.paused.length > 1 ? "they have all" : "it has"} carried on.`
+        ].join(" ");
+        log?.(`\u260E one call for ${episode.paused.length} paused agent${episode.paused.length === 1 ? "" : "s"}: ${names(episode.paused)}`);
+        void call(text).catch((error) => log?.(`\u26A0 could not place the limit call: ${error.message}`));
+      }, gather2);
     }
-    if (!await opts.onIdle()) return;
-    await (opts.pause ?? wait)();
-  }
+  };
 }
+var LIMITS = episodes();
 
 // src/paigy/bridge.ts
 function railFor(opts) {
   return {
-    claim: () => claimGoal(void 0, opts),
+    claim: (goalId) => claimGoal(goalId, opts),
     read: (goalId) => getGoal(goalId, opts),
     update: (goalId, input) => updateGoal(goalId, input, opts),
     // One read and back: the pump owns the waiting, so a Call must not hold a window here.
     contact: (input) => contact(input, { ...opts, waits: false }),
-    create: (input) => createGoal(input, opts)
+    create: (input) => createGoal(input, opts),
+    waiting: () => checkReplies(opts)
   };
 }
 function cancelAsks(state) {
@@ -33802,27 +34213,13 @@ function decisionFrom(result) {
   }
   return { allow: false, reason: "No approval given" };
 }
-function wordsOf(result) {
-  if (!result || !("kind" in result)) return null;
-  switch (result.kind) {
-    case "text":
-      return result.text.trim() || null;
-    case "confirm":
-      return result.approved ? "yes" : "no";
-    case "one":
-      return result.option.label;
-    case "many":
-    case "rank":
-      return result.options.map((o) => o.label).join(", ");
-  }
-}
 async function ask(state, rail, input) {
   if (!state.goal) return null;
   try {
     const sent = await rail.contact({
-      asks: [{ ask: input.ask, parentId: state.goal.id, ...input.options ? { options: input.options } : {} }],
+      asks: [{ ask: input.ask, parentId: state.goal.id, options: input.options }],
       waiting: "hard",
-      channel: input.call ? "call" : "notification"
+      channel: "call"
     });
     if ("recorded" in sent) return null;
     const entryId = sent.requestEntryIds[0];
@@ -33833,89 +34230,416 @@ async function ask(state, rail, input) {
     return null;
   }
 }
-function checkCallOnDone(text) {
-  if (!text) return false;
-  return /\b(call|ring|phone)\b.*\b(done|finish(ed)?|complete(d)?)\b/i.test(text) || /\b(when|if|once)\b.*\b(done|finish(ed)?|complete(d)?)\b.*\b(call|ring|phone)\b/i.test(text) || /\bcall\s+(me|us)\b/i.test(text);
-}
-function parseQuestionOptions(text) {
-  if (!text) return { question: "" };
-  const trimmed = text.trim();
-  const lines2 = trimmed.split("\n").map((l) => l.trim()).filter(Boolean);
-  const optionLines = [];
-  const questionLines = [];
-  for (const line of lines2) {
-    const bulletMatch = line.match(/^[-*•]\s+(.*)$/) ?? line.match(/^\d+[.)]\s+(.*)$/);
-    if (bulletMatch) {
-      optionLines.push(bulletMatch[1].trim());
-    } else {
-      questionLines.push(line);
-    }
-  }
-  if (optionLines.length >= 2 && optionLines.length <= 6) {
-    return {
-      question: questionLines.join("\n\n").trim() || trimmed,
-      options: optionLines.map((raw) => {
-        const colonSplit = raw.match(/^([^:—–-]+)\s*[:—–-]\s*(.+)$/);
-        const parenSplit = raw.match(/^([^(]+)\s*\(([^)]+)\)$/);
-        if (colonSplit && colonSplit[1] && colonSplit[2]) {
-          return { label: colonSplit[1].trim().slice(0, 100), hint: colonSplit[2].trim().slice(0, 250) };
-        }
-        if (parenSplit && parenSplit[1] && parenSplit[2]) {
-          return { label: parenSplit[1].trim().slice(0, 100), hint: parenSplit[2].trim().slice(0, 250) };
-        }
-        return { label: raw.slice(0, 1e3) };
-      })
-    };
-  }
-  return { question: trimmed };
-}
 async function askPermission(event, state, rail) {
   return decisionFrom(await ask(state, rail, {
     ask: [`The agent is blocked waiting to run: ${event.summary}`, ...event.reason ? [event.reason] : []].join("\n\n"),
     options: [
       { label: ALLOW, hint: "Permits the agent to run this command" },
       { label: "Deny", hint: "Blocks execution of this command" }
-    ],
-    call: true
-  }));
-}
-async function askQuestion(question, state, rail, opts) {
-  return wordsOf(await ask(state, rail, {
-    ask: question,
-    call: opts?.call ?? true,
-    options: opts?.options
+    ]
   }));
 }
 async function finish(result, state, rail, opts) {
   const goal = state.goal;
   if (!goal) return;
-  state.goal = void 0;
-  const report = result?.trim() || "Done.";
-  const channel = opts?.call || state.callOnDone ? "call" : "notification";
+  const progress = result?.trim().slice(0, 1e4) || void 0;
+  let revision = goal.revision;
+  try {
+    const held = await rail.claim(goal.id);
+    revision = held.revision ?? revision;
+    const owed = state.noted?.some((b) => b.goals.includes(goal.id));
+    if (!held.openDecisionNeedIds?.length && !owed) {
+      await rail.update(goal.id, { revision, changes: { state: "done", ...progress ? { progress } : {} }, reason: "The agent finished its turn." });
+      state.goal = void 0;
+      return;
+    }
+  } catch (error) {
+    opts?.log?.(`\u26A0 the Goal did not close, still holding it: ${error.message}`);
+  }
+  if (!progress) return;
   try {
-    await rail.contact({ asks: [{ ask: report, parentId: goal.id }], waiting: "none", channel });
-    const { revision } = await rail.read(goal.id);
-    await rail.update(goal.id, { revision: revision ?? goal.revision, changes: { state: "done", progress: report.slice(0, 1e4) }, reason: "The agent finished its turn without asking anything." });
+    await rail.update(goal.id, { revision, changes: { progress }, reason: "The agent's turn ended; its Goal is not closed yet." });
   } catch (error) {
-    opts?.log?.(`\u26A0 finish contact failed: ${error.message}`);
+    opts?.log?.(`\u26A0 could not keep the turn as progress: ${error.message}`);
+  }
+}
+async function cannotWork(report, state, rail, opts) {
+  state.resting = true;
+  try {
+    if (!state.goal) {
+      const claimed = await rail.claim();
+      if (!claimed.goalId || claimed.revision === void 0) return;
+      state.goal = { id: claimed.goalId, revision: claimed.revision };
+    }
+    await rail.contact({ asks: [{ ask: report, parentId: state.goal.id }], waiting: "none", channel: "notification" });
+  } catch (error) {
+    opts?.log?.(`\u26A0 could not say the agent cannot work: ${error.message}`);
   }
 }
 async function afterTurn(event, state, rail, opts) {
-  if (!event.failed && !endsWithQuestion(event.result)) {
-    await finish(event.result, state, rail, opts);
-    state.resting = true;
-    return null;
+  if (event.failed) {
+    const limit = limitIn(event.result, (opts?.now ?? Date.now)());
+    if (limit) {
+      state.paused = limit;
+      if (state.typed) state.owed = state.typed;
+      state.typed = void 0;
+      state.carriedOn = false;
+      state.resting = true;
+      opts?.log?.(`\u23F8 paused by the usage limit until ${limit.resets}: nothing is typed in until then, and it carries on by itself`);
+      return limit;
+    }
+    await cannotWork(`The agent stopped without finishing.
+
+${event.result?.trim() || "No result reported."}`, state, rail, opts);
+    return void 0;
   }
-  const rawText = event.failed ? `The agent stopped without finishing.
+  await finish(event.result, state, rail, opts);
+  state.typed = void 0;
+  state.resting = true;
+  return void 0;
+}
 
-${event.result?.trim() || "No result reported."}` : event.result ?? "";
-  const parsed = parseQuestionOptions(rawText);
-  const reply = await askQuestion(parsed.question, state, rail, {
-    call: true,
-    options: parsed.options
+// src/paigy/conversation.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var HARNESS_INSTRUCTION = "You are running as an unattended background harness agent; your user reaches you through Paigy and is not at this terminal. Nothing wakes you after your turn ends but the person, so wait on CI or a deploy inside the turn. The person never sees your turn's final message: it is kept as progress on this Goal. Anything the person needs \u2014 a question, a result, a blocker \u2014 you send through Paigy's contact tool, once; the harness sends nothing on your behalf. What the person says later arrives with the Goal it was said on named in front of it; answer them on that Goal (its id as the contact's parentId). " + DONE_MESSAGE;
+var SAFETY_MS = 6e4;
+var ASK_BEAT_MS = 5e3;
+function beat() {
+  let pending = null;
+  let wakeUp = null;
+  return {
+    nudge(cause) {
+      if (wakeUp) {
+        const w = wakeUp;
+        wakeUp = null;
+        w(cause);
+      } else pending ??= cause;
+    },
+    next(ms) {
+      if (pending) {
+        const cause = pending;
+        pending = null;
+        return Promise.resolve(cause);
+      }
+      return new Promise((resolve3) => {
+        const timer = setTimeout(() => {
+          wakeUp = null;
+          resolve3("safety");
+        }, ms);
+        wakeUp = (cause) => {
+          clearTimeout(timer);
+          resolve3(cause);
+        };
+      });
+    }
+  };
+}
+var BEAT_REPORT_MS = 10 * 6e4;
+var ended = (state) => state === "done" || state === "cancelled";
+function unheard(brief, state, since = null, after = -1) {
+  const seen = state.seen ??= /* @__PURE__ */ new Set();
+  const words2 = [];
+  for (const [i, e] of (brief.entries ?? []).entries()) {
+    if (seen.has(e.entryId) || !e.authorParticipant.startsWith("human:")) continue;
+    if (i <= after) {
+      seen.add(e.entryId);
+      continue;
+    }
+    if (since !== null && Date.parse(e.createdAt) <= Date.parse(since)) continue;
+    seen.add(e.entryId);
+    if (e.aboutId && seen.has(e.aboutId) && brief.answers?.some((a) => a.requestEntryId === e.aboutId)) continue;
+    const text = entryWords(e).trim();
+    if (text) words2.push(text);
+  }
+  return words2;
+}
+function sinceTheWork(brief) {
+  const entries = brief.entries ?? [];
+  let after = -1;
+  for (const [i, e] of entries.entries()) if (!e.authorParticipant.startsWith("human:")) after = i;
+  const last = entries[after];
+  const handed = last && brief.ownerParticipant && last.authorParticipant !== brief.ownerParticipant;
+  const note2 = handed ? entryWords(last).trim() : "";
+  return { after, ...note2 ? { note: note2 } : {} };
+}
+var baseline = (goal, subtree) => ({
+  goal,
+  goals: new Map((subtree ?? []).map((g) => [g.goalId, { since: g.updatedAt ?? null, at: g.updatedAt ?? null }]))
+});
+function movedBelow(held, state) {
+  const goals = state.below.goals;
+  return (held.subtree ?? []).flatMap((g) => {
+    const known = goals.get(g.goalId);
+    const stamp = g.updatedAt ?? null;
+    if (!known) return [{ goal: g, since: null }];
+    if (known.at === null) {
+      known.since = known.at = stamp;
+      return [];
+    }
+    return stamp !== null && stamp !== known.at ? [{ goal: g, since: known.since }] : [];
   });
-  if (!reply) state.resting = true;
-  return reply;
+}
+function named(goalId, title, brief) {
+  const line = (title ?? brief.outcome ?? "").trim().split("\n")[0].trim();
+  const name = line.length > 80 ? `${line.slice(0, 79)}\u2026` : line;
+  return name ? `On Goal "${name}" (${goalId}):` : `On Goal ${goalId}:`;
+}
+async function gather(state, rail, held) {
+  const looks = /* @__PURE__ */ new Map([[state.goal.id, { via: "held", brief: held }]]);
+  const look2 = (goalId, via, title, since) => {
+    if (!looks.has(goalId)) looks.set(goalId, { via, ...title ? { title } : {}, ...since !== void 0 ? { since } : {} });
+  };
+  const waiting = await rail.waiting().catch(() => null);
+  const listed = /* @__PURE__ */ new Set();
+  const announced = state.announced ??= /* @__PURE__ */ new Set();
+  if (waiting) {
+    for (const id of announced) if (!(waiting.assigned ?? []).some((g) => g.goalId === id)) announced.delete(id);
+  }
+  for (const g of waiting?.assigned ?? []) if (g.goalId !== state.goal.id && !announced.has(g.goalId)) look2(g.goalId, "assigned", g.title);
+  for (const g of waiting?.review ?? []) {
+    listed.add(g.goalId);
+    look2(g.goalId, "waiting work", g.title);
+  }
+  for (const d of waiting?.deliveries ?? []) for (const id of d.goalIds) {
+    listed.add(id);
+    look2(id, "waiting work");
+  }
+  const moved = movedBelow(held, state);
+  for (const { goal, since } of moved) look2(goal.goalId, "subtree", goal.title, since);
+  const heard = [];
+  const read = /* @__PURE__ */ new Set();
+  for (const [goalId, { since, ...found }] of looks) {
+    let brief = found.brief;
+    if (!brief) {
+      try {
+        brief = await rail.read(goalId);
+      } catch (error) {
+        if (error.status === 404) read.add(goalId);
+        continue;
+      }
+    }
+    read.add(goalId);
+    const fresh = found.via === "waiting work" || found.via === "assigned" ? sinceTheWork(brief) : { after: -1 };
+    if (found.via === "assigned") announced.add(goalId);
+    heard.push({ goalId, ...found, brief, words: unheard(brief, state, since ?? null, fresh.after), ...fresh.note ? { note: fresh.note } : {} });
+  }
+  for (const { goal, since } of moved) if (read.has(goal.goalId)) state.below.goals.set(goal.goalId, { since, at: goal.updatedAt ?? null });
+  return { heard, listed };
+}
+var GIVEN = "This Goal was given to you, and nobody has started it. Carry on with what you're doing unless it changes that; claim_goal with its id when you take it up.";
+var says = (h) => h.words.length > 0 || h.via === "assigned";
+function whatItIs(h) {
+  const outcome = h.brief.outcome?.trim() ?? "";
+  const name = (h.title ?? outcome).trim().split("\n")[0].trim();
+  return outcome && outcome !== name ? [outcome] : [];
+}
+var block = (h) => [
+  ...h.via === "assigned" ? [GIVEN] : [],
+  named(h.goalId, h.title, h.brief),
+  ...h.via === "assigned" ? whatItIs(h) : [],
+  ...h.note ? [`The last note on it, from the agent before you: ${h.note}`] : [],
+  ...h.words
+].join("\n\n");
+var short = (ids) => ids.map((id) => id.slice(0, 8)).join(", ");
+var given = (heard) => heard.filter((h) => h.via === "assigned").map((h) => h.goalId);
+async function hear(session, state, rail, held, opts) {
+  const log = opts?.log;
+  const { heard, listed } = await gather(state, rail, held);
+  const said = heard.filter(says);
+  if (said.length) {
+    send2(session, state, said.map(block).join("\n\n"));
+    const worded = said.filter((h) => h.words.length);
+    if (worded.length) log?.(`\u25B8 typed the person's words from ${worded.map((h) => `${h.goalId.slice(0, 8)} (via ${h.via})`).join(", ")}`);
+    const goals = given(said);
+    if (goals.length) {
+      log?.(`\u25B8 announced assigned ${short(goals)} (via rest)`);
+      if (opts?.tally) opts.tally.announced += goals.length;
+    }
+  }
+  for (const h of heard) if (listed.has(h.goalId)) await acknowledge(h.goalId, h.brief, state, rail, log);
+}
+var NOTED = "New from the person while you work. Carry on unless it changes what you're doing: it comes back to you as your next turn when this one ends.";
+var SEEN_MID_TURN = "While you worked, the person said this, and you saw it mid-task. Act on it now, unless you already have.";
+async function note(state, rail, held, inbox, how) {
+  const { heard } = await gather(state, rail, held);
+  const said = heard.filter(says);
+  if (!said.length) return 0;
+  const words2 = said.map(block).join("\n\n");
+  const goals = said.map((h) => h.goalId);
+  const assigned = given(said);
+  if (how.tally) how.tally.announced += assigned.length;
+  let name = "";
+  try {
+    name = inbox.put(`${NOTED}
+
+${words2}`);
+    how.log?.(`\u25B9 noted mid-turn: ${short(goals)}`);
+    if (assigned.length) how.log?.(`\u25B8 announced assigned ${short(assigned)} (via hook)`);
+  } catch (error) {
+    how.log?.(`\u26A0 could not note mid-turn (${error.message}): ${short(goals)} wait for the turn's end`);
+  }
+  (state.noted ??= []).push({ name, goals, words: words2, at: how.now(), cause: how.cause === "wake" ? "wake" : "read" });
+  return 1;
+}
+function receipts(state, inbox, log) {
+  let seen = 0;
+  for (const b of state.noted ?? []) {
+    if (b.seen !== void 0 || !b.name) continue;
+    const at = inbox.taken(b.name);
+    if (at === null) continue;
+    b.seen = at;
+    seen++;
+    log?.(`\u2713 seen mid-turn: ${short(b.goals)} ${Math.max(0, Math.round((at - b.at) / 1e3))}s after the ${b.cause}`);
+  }
+  return seen;
+}
+function settle(session, state, inbox, log) {
+  const batches = state.noted ?? [];
+  state.noted = [];
+  const seen = [];
+  const unseen = [];
+  for (const b of batches) (b.name && inbox?.settle(b.name) === "taken" ? seen : unseen).push(b);
+  send2(session, state, [...seen.length ? [SEEN_MID_TURN, ...seen.map((b) => b.words)] : [], ...unseen.map((b) => b.words)].join("\n\n"));
+  log?.(`\u25B8 typed the person's words from ${short([...new Set(batches.flatMap((b) => b.goals))])} (noted mid-turn: ${seen.length} seen by the hook, ${unseen.length} not)`);
+}
+async function acknowledge(goalId, brief, state, rail, log) {
+  const acked = state.acked ??= /* @__PURE__ */ new Map();
+  if (acked.has(goalId) && acked.get(goalId) === brief.revision) return;
+  acked.set(goalId, brief.revision);
+  try {
+    const claimed = await rail.claim(goalId);
+    const done = await rail.update(goalId, { revision: claimed.revision ?? brief.revision ?? 1, changes: { reviewed: true }, reason: "Read by the harness session; the person's words on it are typed in." });
+    acked.set(goalId, done.revision);
+    if (state.goal?.id === goalId && done.revision !== void 0) state.goal.revision = done.revision;
+  } catch (error) {
+    log?.(`\u26A0 could not acknowledge ${goalId.slice(0, 8)}: ${error.message} \u2014 its words are typed in; it stays listed until acknowledged`);
+  }
+}
+async function step(session, state, rail, opts) {
+  if (state.paused) {
+    if ((opts?.now ?? Date.now)() < state.paused.until) {
+      if (opts?.tally) opts.tally.paused = (opts.tally.paused ?? 0) + 1;
+      return;
+    }
+    opts?.log?.(`\u25B6 resumed after the limit (it reset at ${state.paused.resets}): told to carry on, with what arrived meanwhile`);
+    state.paused = void 0;
+    state.carryOn = true;
+  }
+  await look(session, state, rail, opts);
+  if (state.carryOn && state.resting && !state.asks?.size) send2(session, state, "");
+}
+async function look(session, state, rail, opts) {
+  if (opts?.inbox) {
+    const seen = receipts(state, opts.inbox, opts.log);
+    if (opts.tally) opts.tally.seen += seen;
+  }
+  if (state.resting && state.noted?.length && !state.asks?.size) return settle(session, state, opts?.inbox, opts?.log);
+  if (!state.goal) {
+    if (!state.resting) return;
+    let brief2 = await rail.claim();
+    if (!brief2.goalId || brief2.revision === void 0) {
+      if (opts?.initialPrompt?.trim()) {
+        const prompt = opts.initialPrompt.trim();
+        opts.initialPrompt = void 0;
+        const admitted = await rail.create({ outcome: prompt, idempotencyKey: randomUUID5() });
+        brief2 = await rail.claim();
+        if (!brief2.goalId || brief2.revision === void 0) {
+          state.goal = { id: admitted.goalId, revision: admitted.revision };
+          send2(session, state, [HARNESS_INSTRUCTION, prompt].join("\n\n"));
+          return;
+        }
+      } else {
+        return;
+      }
+    }
+    unheard(brief2, state);
+    if (ended(brief2.state)) await rail.update(brief2.goalId, { revision: brief2.revision, changes: { reviewed: true }, reason: "Typed into the session." });
+    else {
+      state.goal = { id: brief2.goalId, revision: brief2.revision };
+      state.below = baseline(brief2.goalId, brief2.subtree);
+    }
+    const outcome = brief2.outcome?.trim() ?? "";
+    const said = (brief2.entries ?? []).map((e) => entryWords(e).trim()).filter((w) => w && w.toLowerCase() !== outcome.toLowerCase());
+    const left = brief2.earlier ? brief2.earlier.omitted + brief2.earlier.shortened : 0;
+    const earlier = left ? `(${left} earlier entries on this Goal are left out or shortened; get_goal with history: true reads them in full.)` : "";
+    const fullText = [outcome, earlier, ...said].filter(Boolean).join("\n\n");
+    send2(session, state, [HARNESS_INSTRUCTION, fullText].filter(Boolean).join("\n\n"));
+    return;
+  }
+  const brief = await rail.read(state.goal.id);
+  state.goal.revision = brief.revision ?? state.goal.revision;
+  for (const answer of brief.answers ?? []) {
+    const resolve3 = state.asks?.get(answer.requestEntryId);
+    if (!resolve3) continue;
+    state.asks.delete(answer.requestEntryId);
+    resolve3(answer.result);
+  }
+  if (ended(brief.state)) {
+    state.goal = void 0;
+    for (const resolve3 of state.asks?.values() ?? []) resolve3(null);
+    state.asks?.clear();
+    return;
+  }
+  if (state.below?.goal !== state.goal.id) state.below = baseline(state.goal.id, brief.subtree);
+  if (state.asks?.size) return;
+  if (!state.resting) {
+    if (!opts?.inbox) return;
+    const noted = await note(state, rail, brief, opts.inbox, { cause: opts.cause ?? "safety", now: opts.now ?? Date.now, ...opts.log ? { log: opts.log } : {}, ...opts.tally ? { tally: opts.tally } : {} });
+    if (opts.tally) opts.tally.noted += noted;
+    return;
+  }
+  await hear(session, state, rail, brief, { ...opts?.log ? { log: opts.log } : {}, ...opts?.tally ? { tally: opts.tally } : {} });
+}
+function send2(session, state, text) {
+  state.resting = false;
+  let words2 = text;
+  if (state.carryOn) {
+    state.carryOn = false;
+    state.carriedOn = true;
+    const owed = state.owed;
+    state.owed = void 0;
+    words2 = [owed, text].filter(Boolean).join("\n\n");
+    text = [CARRY_ON, ...owed ? [OWED, owed] : [], text].filter(Boolean).join("\n\n");
+  }
+  state.typed = words2 || void 0;
+  session.send(text);
+}
+async function pump(session, state, rail, opts) {
+  const clock4 = opts.beat ?? beat();
+  const now = opts.now ?? Date.now;
+  const counts = { wake: 0, rest: 0, safety: 0, skipped: 0 };
+  const tally = { noted: 0, seen: 0, announced: 0 };
+  const stepOpts = {
+    ...opts.initialPrompt ? { initialPrompt: opts.initialPrompt } : {},
+    ...opts.log ? { log: opts.log } : {},
+    ...opts.inbox ? { inbox: opts.inbox } : {},
+    now,
+    tally
+  };
+  let since = now();
+  let cause = "start";
+  for (; ; ) {
+    if (cause === "wake" && !state.resting && !state.asks?.size && !opts.inbox) counts.skipped++;
+    else {
+      if (cause !== "start") counts[cause]++;
+      try {
+        stepOpts.cause = cause;
+        await step(session, state, rail, stepOpts);
+      } catch {
+      }
+    }
+    if (!await opts.onIdle()) return;
+    if (now() - since >= BEAT_REPORT_MS) {
+      const read = counts.wake + counts.rest + counts.safety;
+      if (read || counts.skipped || tally.noted || tally.seen || tally.announced) {
+        opts.log?.(`\u25B9 beats: ${read} read (${counts.wake} wake, ${counts.rest} rest, ${counts.safety} safety), ${counts.skipped} wake mid-turn skipped, ${tally.noted} noted mid-turn, ${tally.seen} seen by the hook, ${tally.announced} assigned announced${tally.paused ? `, ${tally.paused} held by the usage limit` : ""}`);
+      }
+      counts.wake = counts.rest = counts.safety = counts.skipped = tally.noted = tally.seen = tally.announced = tally.paused = 0;
+      since = now();
+    }
+    cause = await clock4.next(state.asks?.size ? ASK_BEAT_MS : state.paused ? Math.max(1e3, Math.min(SAFETY_MS, state.paused.until - now())) : SAFETY_MS);
+    if (!await opts.onIdle()) return;
+  }
 }
 
 // src/run.ts
@@ -33923,11 +34647,34 @@ function runHarness(opts) {
   let running = true;
   let tail = [];
   const state = { resting: true };
+  const clock4 = beat();
   let session = null;
-  const rail = railFor({ token: opts.token, ...opts.resume ? { reach: reachAs(opts.resume) } : {} });
+  const speaksAs = opts.resume ?? opts.session;
+  const rail = railFor({ token: opts.token, ...speaksAs ? { reach: reachAs(speaksAs) } : {} });
+  let inbox;
+  if (opts.harness === "claude") {
+    try {
+      inbox = inboxFor();
+    } catch (error) {
+      opts.log(`\u26A0 no inbox (${error.message}): what the person says mid-turn waits for the turn to end`);
+    }
+  }
+  const name = opts.name ?? "The agent";
+  function runningAgain() {
+    state.carriedOn = false;
+    opts.log("\u25B6 running again after the limit");
+    LIMITS.running(name, (text) => rail.contact({ asks: [{ ask: text, ...state.goal ? { parentId: state.goal.id } : {} }], waiting: "none", channel: "call" }), opts.log);
+  }
   async function handle(event) {
     if (event.kind === "error") {
       opts.log(`\u26A0 ${event.message}`);
+      if (event.fatal && running) {
+        opts.log(`\u2716 could not start: ${event.message}`);
+        await cannotWork(`The session could not start, so nothing is working on this yet.
+
+${event.message}`, state, rail, { log: opts.log });
+        stop2();
+      }
       return;
     }
     if (event.kind === "permission") {
@@ -33944,6 +34691,7 @@ function runHarness(opts) {
       return;
     }
     if (event.kind === "work") {
+      if (state.carriedOn) runningAgain();
       opts.log(`\u2699 ${event.tool}${event.note ? ` \u2014 ${event.note.split("\n")[0] ?? ""}` : ""}`);
       tail = pushWork(tail, workLine(event));
       return;
@@ -33951,20 +34699,10 @@ function runHarness(opts) {
     if (event.kind === "turn") opts.log(`${event.role}: ${event.text.split("\n")[0] ?? ""}`);
     if (event.kind === "idle") {
       tail = [];
-      if (endsWithQuestion(event.result)) {
-        const local = await opts.localAsk?.question?.(event.result ?? "") ?? null;
-        if (local?.trim() && session && running) {
-          opts.log(`you (here): ${local.split("\n")[0] ?? ""}`);
-          state.resting = false;
-          session.send(local);
-          return;
-        }
-      }
-      const reply = await afterTurn(event, state, rail, { log: opts.log });
-      if (reply && session && running) {
-        opts.log(`you: ${reply.split("\n")[0] ?? ""}`);
-        session.send(reply);
-      }
+      const carried = state.carriedOn && !event.failed;
+      if (await afterTurn(event, state, rail, { log: opts.log })) LIMITS.paused(name, Date.now());
+      else if (carried) runningAgain();
+      clock4.nudge("rest");
     }
   }
   session = startSession({
@@ -33973,44 +34711,54 @@ function runHarness(opts) {
     mode: opts.mode,
     ...opts.token ? { token: opts.token } : {},
     ...opts.resume ? { resume: opts.resume } : {},
+    ...opts.session ? { session: opts.session } : {},
     ...opts.bin ? { bin: opts.bin } : {},
-    ...opts.onExit ? { onExit: opts.onExit } : {},
+    ...inbox ? { inbox: inbox.dir } : {},
+    onExit: () => {
+      inbox?.close();
+      opts.onExit?.();
+    },
     onEvent: (event) => void handle(event).catch((err) => opts.log(`\u26A0 ${err.message}`))
   });
-  void pump(session, state, rail, { onIdle: () => running, initialPrompt: opts.prompt }).catch(
+  void pump(session, state, rail, { onIdle: () => running, beat: clock4, initialPrompt: opts.prompt, log: opts.log, ...inbox ? { inbox } : {} }).catch(
     (e) => opts.log(`\u26A0 conversation loop stopped: ${e.message}`)
   );
   opts.log(`\u25B6 started ${opts.harness} in ${opts.cwd} (${opts.mode} mode)`);
+  function stop2() {
+    running = false;
+    clock4.nudge("wake");
+    tail = [];
+    cancelAsks(state);
+    session?.stop();
+    session = null;
+    inbox?.close();
+    opts.log("\u25A0 stopped");
+  }
   return {
     send(text) {
       session?.send(text);
     },
     working: () => running && state.resting !== true,
-    tail: () => [...tail],
-    stop() {
-      running = false;
-      tail = [];
-      cancelAsks(state);
-      session?.stop();
-      session = null;
-      opts.log("\u25A0 stopped");
-    }
+    // Paused by a usage limit, the activity line says so: the quiet place the pause is shown.
+    tail: () => state.paused ? [pausedLine(state.paused)] : [...tail],
+    nudge: () => clock4.nudge("wake"),
+    stop: stop2
   };
 }
 
 // src/host.ts
 init_dist();
 init_catalog();
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9 } from "path";
 
 // src/workspaces.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
 function workspacesFile() {
-  return join4(homedir4(), ".paigy", "workspaces.json");
+  return join5(homedir5(), ".paigy", "workspaces.json");
 }
 function listWorkspaces(deps) {
   try {
@@ -34021,31 +34769,94 @@ function listWorkspaces(deps) {
   }
 }
 function addWorkspace(dir, deps) {
-  const next = resolve2(dir.replace(/^~(?=$|\/)/, homedir4()));
+  const next = resolve2(dir.replace(/^~(?=$|\/)/, homedir5()));
   const all = listWorkspaces(deps);
   if (!all.includes(next)) {
     all.push(next);
-    mkdirSync2(dirname2(deps.file), { recursive: true });
-    writeFileSync2(deps.file, JSON.stringify(all, null, 2));
+    mkdirSync3(dirname2(deps.file), { recursive: true });
+    writeFileSync3(deps.file, JSON.stringify(all, null, 2));
   }
   return all;
 }
 function allowed(cwd, deps) {
-  const target = resolve2(cwd.replace(/^~(?=$|\/)/, homedir4()));
+  const target = resolve2(cwd.replace(/^~(?=$|\/)/, homedir5()));
   return listWorkspaces(deps).some((w) => target === w || target.startsWith(`${w}/`));
 }
 function resolveWakeDir(pinned, deps) {
   if (pinned && allowed(pinned, deps)) {
-    const dir = resolve2(pinned.replace(/^~(?=$|\/)/, homedir4()));
+    const dir = resolve2(pinned.replace(/^~(?=$|\/)/, homedir5()));
     if ((deps.exists ?? existsSync4)(dir)) return dir;
   }
   return listWorkspaces(deps)[0];
 }
 
+// src/holder.ts
+init_dist();
+import { execFileSync as execFileSync3 } from "child_process";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function psStart(pid, zone) {
+  try {
+    const env = zone === "UTC" ? { ...process.env, TZ: "UTC", LC_ALL: "C" } : { ...process.env, LC_ALL: "C" };
+    return execFileSync3("ps", ["-o", "lstart=", "-p", String(pid)], { env, encoding: "utf8", timeout: 2e3 }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+var squash = (s) => s.trim().replace(/\s+/g, " ");
+function holds(pid, procStart, deps) {
+  if (!deps.alive(pid)) return false;
+  if (typeof procStart !== "string" || !procStart.trim()) return true;
+  const want = squash(procStart);
+  for (const zone of ["UTC", "local"]) {
+    const got = deps.started(pid, zone);
+    if (got === null) return true;
+    if (squash(got) === want) return true;
+  }
+  return false;
+}
+function localHolders(deps = {}) {
+  const dir = deps.dir ?? join6(process.env.CLAUDE_CONFIG_DIR?.trim() || join6(homedir6(), ".claude"), "sessions");
+  const list = deps.list ?? ((d) => readdirSync2(d));
+  const read = deps.read ?? ((f) => readFileSync4(f, "utf8"));
+  const check = { alive: deps.alive ?? isAlive, started: deps.started ?? psStart };
+  const held = /* @__PURE__ */ new Map();
+  let files;
+  try {
+    files = list(dir);
+  } catch {
+    return held;
+  }
+  for (const file of files) {
+    if (!/^\d+\.json$/.test(file)) continue;
+    let row;
+    try {
+      row = JSON.parse(read(join6(dir, file)));
+    } catch {
+      continue;
+    }
+    const pid = typeof row.pid === "number" ? row.pid : Number(file.slice(0, -5));
+    if (typeof row.sessionId !== "string" || !row.sessionId.trim() || !Number.isInteger(pid) || pid <= 0) continue;
+    const slot = sessionSlot(row.sessionId);
+    if (held.has(slot)) continue;
+    if (holds(pid, row.procStart, check)) held.set(slot, { pid });
+  }
+  return held;
+}
+
 // src/owner.ts
-import { closeSync as closeSync2, openSync as openSync2, readSync, readdirSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { closeSync as closeSync2, openSync as openSync2, readSync, readdirSync as readdirSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join7 } from "path";
 var HEAD_BYTES = 64e3;
 function readHead(file) {
   const fd = openSync2(file, "r");
@@ -34061,8 +34872,8 @@ function ownerSession(slot, deps = {}) {
   const m = /^session:([0-9a-f]{8})$/.exec(slot);
   if (!m) return null;
   const prefix = m[1];
-  const root = deps.projectsDir ?? join5(homedir5(), ".claude", "projects");
-  const list = deps.list ?? ((dir) => readdirSync(dir));
+  const root = deps.projectsDir ?? join7(homedir7(), ".claude", "projects");
+  const list = deps.list ?? ((dir) => readdirSync3(dir));
   const head = deps.head ?? readHead;
   let folders;
   try {
@@ -34073,7 +34884,7 @@ function ownerSession(slot, deps = {}) {
   for (const folder of folders) {
     let files;
     try {
-      files = list(join5(root, folder));
+      files = list(join7(root, folder));
     } catch {
       continue;
     }
@@ -34081,7 +34892,7 @@ function ownerSession(slot, deps = {}) {
     if (!file) continue;
     let text;
     try {
-      text = head(join5(root, folder, file));
+      text = head(join7(root, folder, file));
     } catch {
       continue;
     }
@@ -34101,7 +34912,7 @@ function ownerSession(slot, deps = {}) {
 // src/update.ts
 import { execFile } from "child_process";
 import { createRequire } from "module";
-import { dirname as dirname3, join as join6 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 import { promisify } from "util";
 var SERVICE_LABEL = "ai.paigy.harness";
 var VERSION = createRequire(import.meta.url)("../package.json").version;
@@ -34128,7 +34939,7 @@ async function latestVersion() {
 }
 async function install(version) {
   const bin = dirname3(process.execPath);
-  await promisify(execFile)(join6(bin, "npm"), ["install", "-g", `@paigy/harness@${version}`], {
+  await promisify(execFile)(join8(bin, "npm"), ["install", "-g", `@paigy/harness@${version}`], {
     env: { ...process.env, PATH: `${bin}:${process.env.PATH ?? ""}`, npm_config_update_notifier: "false" },
     timeout: 5 * 6e4
   });
@@ -34179,24 +34990,43 @@ function selfUpdater(deps) {
 }
 
 // src/host.ts
-var HOST_FILE = join7(homedir6(), ".paigy", "host.json");
+var HOST_FILE = join9(homedir8(), ".paigy", "host.json");
 var runKey = (slot) => `slot:${slot}`;
 var claimedRun = (sessionId2) => {
   const slot = sessionSlot(sessionId2);
   return { slot, key: runKey(slot) };
 };
-async function slotHasWaitingWork(token, session) {
-  return (await checkReplies({ token, ...session ? { reach: reachAs(session) } : {} })).deliveries.length > 0;
+var launchRun = (spec) => ({ session: spec.sessionId });
+async function waitingWork(token, session) {
+  let found;
+  try {
+    found = await checkReplies({ token, ...session ? { reach: reachAs(session) } : {} });
+  } catch (error) {
+    return { skip: `could not read what is waiting (${error.message})` };
+  }
+  const n = found.deliveries.length;
+  if (n) return { waiting: n === 1 ? "a message" : `${n} messages` };
+  const next = found.claimable;
+  return next ? { waiting: `Goal ${next.goalId.slice(0, 8)}${next.title ? ` "${next.title}"` : ""}` } : { skip: "has nothing waiting" };
+}
+function evict(runs, key, run) {
+  if (runs.get(key)?.run === run) runs.delete(key);
 }
 var PRESENCE_FRESH_MS = 3 * 6e4;
-function wakeAction(live, now, serverSeenAt) {
+function wakeAction(live, now, serverSeenAt, here = {}) {
   if (live) return { action: "skip", why: "run" };
-  if (serverSeenAt !== void 0 && now - serverSeenAt < PRESENCE_FRESH_MS) return { action: "skip", why: "presence" };
+  if (here.holder) return { action: "skip", why: "holder" };
+  if (serverSeenAt !== void 0 && now - serverSeenAt < PRESENCE_FRESH_MS) {
+    if (here.goneAt !== void 0 && serverSeenAt <= here.goneAt) return { action: "spawn", why: "gone" };
+    return { action: "skip", why: "presence" };
+  }
   return { action: "spawn", why: "nobody" };
 }
 function startHost(opts) {
   const runs = /* @__PURE__ */ new Map();
   const asHost = { token: opts.token };
+  const goneAt = /* @__PURE__ */ new Map();
+  const heldHere = /* @__PURE__ */ new Set();
   const refreshIdentities = async () => {
     for (const slot of listSlots()) {
       if (slot === "Desktop") continue;
@@ -34216,7 +35046,7 @@ function startHost(opts) {
     working: () => [...runs.values()].filter((r) => r.run.working()).length,
     log: opts.log
   });
-  const beat = () => {
+  const beat2 = () => {
     void refreshIdentities();
     void update().catch(() => {
     });
@@ -34243,11 +35073,13 @@ function startHost(opts) {
         mode: "bypass",
         prompt: "",
         token: spec.token,
-        resume: spec.sessionId,
+        ...launchRun(spec),
         onExit: () => {
-          runs.delete(key);
+          evict(runs, key, run);
+          goneAt.set(slot, Date.now());
           opts.log(`\u2716 ${label} ended`);
         },
+        name: label,
         log
       });
       runs.set(key, { run, label, token: spec.token });
@@ -34274,7 +35106,13 @@ function startHost(opts) {
     return presence;
   }
   let lastPresence = /* @__PURE__ */ new Map();
-  async function wakeSlot(slot, presence) {
+  async function evidence() {
+    const presence = await presenceMap();
+    lastHolders = localHolders();
+    return { presence, holders: lastHolders };
+  }
+  let lastHolders = /* @__PURE__ */ new Map();
+  async function wakeSlot(slot, { presence, holders }, cause = "sweep") {
     {
       const harness = SLOT_HARNESS[slot] ?? (slot === "Desktop" ? void 0 : "claude");
       const key = runKey(slot);
@@ -34282,19 +35120,42 @@ function startHost(opts) {
       const live = runs.get(key);
       const tokenId = slotIdentity(slot).tokenId;
       const seenByServer = tokenId ? presence.get(tokenId) : void 0;
-      const decided = wakeAction(!!live, Date.now(), seenByServer);
+      const holder = holders.get(slot);
+      if (holder) heldHere.add(slot);
+      else if (heldHere.delete(slot)) goneAt.set(slot, Date.now());
+      const decided = wakeAction(!!live, Date.now(), seenByServer, { holder, goneAt: goneAt.get(slot) });
       if (decided.action === "skip") {
-        opts.log(decided.why === "run" ? `\u25CC ${slotName(slot) ?? slot} is running here \u2014 its pump types the work in; not spawning` : `\u25CC ${slotName(slot) ?? slot} is working somewhere this host cannot see (heartbeat) \u2014 not spawning`);
+        if (decided.why === "run" && cause === "wake") live?.run.nudge();
+        const name = slotName(slot) ?? slot;
+        opts.log(decided.why === "run" ? `\u25CC ${name} is running here \u2014 ${cause === "wake" ? "woke its pump" : "its pump types the work in"}; not spawning` : decided.why === "holder" ? `\u25B8 ${name} already running (pid ${holder?.pid ?? "?"}) \u2014 not starting a second` : `\u25CC ${name} is working somewhere this host cannot see (heartbeat) \u2014 not spawning`);
         return;
       }
+      const label = slotName(slot) ?? slot;
+      const skip = (why) => opts.log(`\u25CC ${label} ${why} \u2014 not spawning`);
       const token = readToken(slot);
-      if (!token) return;
+      if (!token) {
+        skip("has no token on this machine");
+        return;
+      }
       const owner = ownerSession(slot);
-      if (owner && !allowed(owner.cwd, opts.wsDeps)) return;
+      if (owner && !allowed(owner.cwd, opts.wsDeps)) {
+        skip(`ran in ${owner.cwd}, outside the folders this machine granted`);
+        return;
+      }
       const workspace = owner?.cwd ?? resolveWakeDir(slotIdentity(slot).workspace, opts.wsDeps);
-      if (!workspace) return;
-      if (!await slotHasWaitingWork(token, owner?.sessionId).catch(() => false)) return;
-      const label = slotName(slot) ?? slot;
+      if (!workspace) {
+        skip("has no granted folder to wake in");
+        return;
+      }
+      const found = await waitingWork(token, owner?.sessionId);
+      if ("skip" in found) {
+        skip(found.skip);
+        return;
+      }
+      if (runs.has(key)) {
+        skip("was started by the wake that read it first");
+        return;
+      }
       const log = (line) => opts.log(`[${label}] ${line}`);
       const run = runHarness({
         harness,
@@ -34303,17 +35164,20 @@ function startHost(opts) {
         prompt: "",
         token,
         ...owner ? { resume: owner.sessionId } : {},
-        // A dead run must not squat the slot — evict so the next wake can respawn.
+        // A dead run must not squat the slot — evict so the next wake can respawn. Only ITS entry:
+        // a run that is no longer the slot's must not take the live one's place away with it.
         onExit: () => {
-          runs.delete(key);
+          evict(runs, key, run);
+          goneAt.set(slot, Date.now());
           opts.log(`\u2716 ${label} ended`);
         },
+        name: label,
         log
       });
       runs.set(key, { run, label, token });
       void heartbeat(void 0, { token }).catch(() => {
       });
-      opts.log(`\u25B6 ${owner ? "resumed" : "woke"} ${label} (${harness}) \u2014 work was waiting in ${workspace}`);
+      opts.log(`\u25B6 ${owner ? "resumed" : "woke"} ${label} (${harness}) \u2014 ${found.waiting} was waiting, in ${workspace}${decided.why === "gone" ? " (its process here ended; its last heartbeat was not waited out)" : ""}`);
     }
   }
   const listening = /* @__PURE__ */ new Map();
@@ -34333,7 +35197,7 @@ function startHost(opts) {
       joining.add(slot);
       try {
         const sub = await subscribeWake(
-          () => void presenceMap().then((presence) => wakeSlot(slot, presence)).catch(() => {
+          () => void evidence().then((seen) => wakeSlot(slot, seen, "wake")).catch(() => {
           }),
           { token }
         );
@@ -34347,8 +35211,8 @@ function startHost(opts) {
     }
   }
   async function sweepSlots() {
-    const presence = await presenceMap();
-    for (const slot of listSlots()) await wakeSlot(slot, presence);
+    const seen = await evidence();
+    for (const slot of listSlots()) await wakeSlot(slot, seen);
   }
   const ACTIVITY_MS = 2e3;
   const published = /* @__PURE__ */ new Map();
@@ -34373,12 +35237,12 @@ function startHost(opts) {
   };
   const publish = () => {
     try {
-      writeFileSync3(HOST_FILE, JSON.stringify({ pid: process.pid, at: Date.now(), roster: api.roster() }));
+      writeFileSync4(HOST_FILE, JSON.stringify({ pid: process.pid, at: Date.now(), roster: api.roster() }));
     } catch {
     }
   };
-  beat();
-  const pulse = setInterval(beat, 6e4);
+  beat2();
+  const pulse = setInterval(beat2, 6e4);
   const spawnPoll = setInterval(() => {
     void claimAndSpawn();
     publish();
@@ -34404,10 +35268,10 @@ function startHost(opts) {
     // them live, and a run mid-turn makes it working.
     roster: () => {
       const live = new Map([...runs.values()].map((r) => [r.label, r.run]));
-      const names = /* @__PURE__ */ new Map();
-      for (const key of listSlots()) if (key !== "Desktop") names.set(slotName(key) ?? key, key);
-      for (const label of live.keys()) if (!names.has(label)) names.set(label, null);
-      return [...names.entries()].map(([name, slot]) => {
+      const names2 = /* @__PURE__ */ new Map();
+      for (const key of listSlots()) if (key !== "Desktop") names2.set(slotName(key) ?? key, key);
+      for (const label of live.keys()) if (!names2.has(label)) names2.set(label, null);
+      return [...names2.entries()].map(([name, slot]) => {
         const id = slot ? slotIdentity(slot) : { voice: null, tokenId: null };
         return {
           name,
@@ -34424,7 +35288,7 @@ function startHost(opts) {
           // sessions we started ourselves. The server already knows: `last_seen_at` on the
           // agent's own token, the same evidence `wakeAction` stands back for. So: a run we
           // hold, OR a process the server heard from inside `PRESENCE_FRESH_MS`.
-          running: live.has(name) || !!id.tokenId && Date.now() - (lastPresence.get(id.tokenId) ?? 0) < PRESENCE_FRESH_MS,
+          running: live.has(name) || !!slot && lastHolders.has(slot) || !!id.tokenId && Date.now() - (lastPresence.get(id.tokenId) ?? 0) < PRESENCE_FRESH_MS,
           // `working` stays ours alone — it means a run WE hold is mid-turn, which is the only
           // thing a tail can tell us. A process we did not spawn has no tail here to read.
           working: live.get(name)?.working() ?? false
@@ -34440,7 +35304,7 @@ function startHost(opts) {
       streamActivity();
       clearInterval(activityTick);
       try {
-        writeFileSync3(HOST_FILE, JSON.stringify({ pid: process.pid, at: 0, roster: [] }));
+        writeFileSync4(HOST_FILE, JSON.stringify({ pid: process.pid, at: 0, roster: [] }));
       } catch {
       }
     }
@@ -34545,18 +35409,18 @@ async function pairThisMachine() {
   }
 }
 function forwardCodexThreadId() {
-  const cfg = join8(process.env.CODEX_HOME || join8(homedir8(), ".codex"), "config.toml");
+  const cfg = join10(process.env.CODEX_HOME || join10(homedir10(), ".codex"), "config.toml");
   if (!existsSync5(cfg)) return;
-  const text = readFileSync5(cfg, "utf8");
+  const text = readFileSync6(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 block2 = 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));
+  if (/^\s*env_vars\s*=/m.test(block2)) return;
+  writeFileSync5(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));
@@ -34647,7 +35511,7 @@ async function main() {
     const wsDeps = { file: workspacesFile() };
     for (const dir of parsed.grant) addWorkspace(dir, wsDeps);
     if (!listWorkspaces(wsDeps).length) {
-      const guess = join8(homedir8(), "projects");
+      const guess = join10(homedir10(), "projects");
       if (existsSync5(guess)) {
         addWorkspace(guess, wsDeps);
         console.log(`\u2713 workspace granted: ${guess} (change with --grant DIR)`);
@@ -34660,23 +35524,14 @@ async function main() {
         console.log("service install failed \u2014 run `paigy-harness host` to host in the foreground");
       }
     } 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" },
-      // 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;
+    for (const t of MCP_WIRES) {
+      if (!which(t.cli)) 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 (e) {
-        console.log(`\u26A0 could not wire ${t.cli} (${e.message.split("\n")[0]}) \u2014 the harness still works; wire it by hand later`);
+        console.log(`\u26A0 could not wire ${t.cli} (${e.message.split("\n")[0]}) \u2014 its agents cannot reach you until it is: ${t.wire}`);
       }
     }
     if (which("claude")) {
@@ -34688,12 +35543,12 @@ async function main() {
       }
     }
     try {
-      const settings = join8(homedir8(), ".claude", "settings.json");
+      const settings = join10(homedir10(), ".claude", "settings.json");
       if (which("claude") && existsSync5(settings)) {
-        const cfg = JSON.parse(readFileSync5(settings, "utf8"));
+        const cfg = JSON.parse(readFileSync6(settings, "utf8"));
         if (!cfg["statusLine"]) {
           cfg["statusLine"] = { type: "command", command: "npx -y -p @paigy/mcp@latest paigy-statusline" };
-          writeFileSync4(settings, JSON.stringify(cfg, null, 2));
+          writeFileSync5(settings, JSON.stringify(cfg, null, 2));
           console.log("\u2713 statusline wired");
         }
       }
@@ -34746,14 +35601,14 @@ async function main() {
   <key>SoftResourceLimits</key><dict>
     <key>NumberOfFiles</key><integer>65536</integer>
   </dict>
-  <key>StandardOutPath</key><string>${join8(homedir8(), ".paigy", "host.log")}</string>
-  <key>StandardErrorPath</key><string>${join8(homedir8(), ".paigy", "host.log")}</string>
+  <key>StandardOutPath</key><string>${join10(homedir10(), ".paigy", "host.log")}</string>
+  <key>StandardErrorPath</key><string>${join10(homedir10(), ".paigy", "host.log")}</string>
 </dict></plist>
 `;
-    const dir = join8(homedir8(), "Library", "LaunchAgents");
-    mkdirSync3(dir, { recursive: true });
-    const path = join8(dir, `${SERVICE_LABEL}.plist`);
-    writeFileSync4(path, plist);
+    const dir = join10(homedir10(), "Library", "LaunchAgents");
+    mkdirSync4(dir, { recursive: true });
+    const path = join10(dir, `${SERVICE_LABEL}.plist`);
+    writeFileSync5(path, plist);
     execSync(`launchctl unload ${path} 2>/dev/null; launchctl load ${path}`, { shell: "/bin/sh" });
     console.log(`\u2713 host installed as a login service (${path}) \u2014 logs at ~/.paigy/host.log`);
     console.log("  file limit raised to 65536 for the host and every session it spawns");
@@ -34775,7 +35630,7 @@ async function main() {
       process.exit(1);
     }
     const name = slotName(slot) ?? slot;
-    console.log(`\u2713 ${name} is handed off \u2014 wakes in ${cwd.replace(homedir8(), "~")}`);
+    console.log(`\u2713 ${name} is handed off \u2014 wakes in ${cwd.replace(homedir10(), "~")}`);
     if (!allowed(cwd, { file: workspacesFile() })) {
       console.log(`  \u26A0 that folder isn't on the allow-list, so wakes will land in the first granted`);
       console.log(`    workspace instead \u2014 add it in the desktop app, or: paigy-harness host --grant ${cwd}`);
@@ -34799,7 +35654,11 @@ async function main() {
   if (parsed.hatch) {
     overrideToken(readToken("Desktop") || null);
     const minted = await hatch(parsed.hatch, parsed.voice ?? null);
-    saveToken({ access_token: minted.token, name: minted.name, device: null }, parsed.slot ?? minted.name);
+    saveToken({ access_token: minted.token, name: minted.name ?? parsed.hatch, device: null }, parsed.slot ?? minted.name ?? parsed.hatch);
+    if (!minted.name) {
+      console.log(`\u2713 hatched, unnamed \u2014 you already have an agent called "${parsed.hatch}". Pick another name in the app's Agents screen.`);
+      return;
+    }
     console.log(`\u2713 hatched "${minted.name}" \u2014 it's on your phone's Agents screen now.`);
     console.log(`  speak as it:  PAIGY_AGENT="${minted.name}" <any paigy tool>`);
     console.log(`  run with it:  paigy-harness --identity "${minted.name}" --harness codex "\u2026"`);
@@ -34863,12 +35722,11 @@ async function main() {
         const said = await askTerminal(`\u23F8 blocked: ${summary} \u2014 allow? [y/n]`);
         if (!said) return null;
         return /^(y|yes|ok|allow|approve)/i.test(said) ? { allow: true } : { allow: false, reason: said };
-      },
-      question: (q) => askTerminal(`\u2753 ${q}`)
+      }
     },
     log: (line) => console.log(line)
   });
-  const beat = async () => {
+  const beat2 = async () => {
     try {
       await heartbeat();
       signedOut = false;
@@ -34881,8 +35739,8 @@ async function main() {
       console.log("    paigy-harness pair");
     }
   };
-  const pulse = setInterval(() => void beat(), 6e4);
-  void beat();
+  const pulse = setInterval(() => void beat2(), 6e4);
+  void beat2();
   pulse.unref?.();
   process.on("SIGINT", () => {
     run.stop();