@paigy/mcp 0.40.1 → 0.40.2

package/README.md

@@ -145,42 +145,48 @@ not a compatibility fallback for target MCP tools.
   no extra setup. Two edges: with `HTTP_PROXY` set, an `http://localhost` backend
   proxies too unless `NO_PROXY=localhost` (hostname entries work; CIDR ranges are
   ignored), and `paigy-listen`'s realtime wake channel is a websocket that doesn't
-  proxy — its REST sweeps do.
+  proxy — its REST reads do.
 
 ## Wake any harness (`paigy-listen`)
 
 `paigy-listen` is the self-hosted push daemon: it subscribes to this connection's
-wake channel and sweeps on every nudge. Keep it alive past the terminal with
-`paigy-listen --install` (launchd on macOS, systemd user unit on Linux; `--uninstall`
-removes it).
+wake channel and reads what is waiting on every nudge. Keep it alive past the terminal
+with `paigy-listen --install` (launchd on macOS, systemd user unit on Linux;
+`--uninstall` removes it).
+
+The read is `check_replies` — the open Deliveries addressed to this agent — and it
+**consumes nothing**: no lease, no acknowledgement, and the same read twice returns the
+same list. So the daemon hands the launcher what it found and stops there; claiming is
+the agent's own first act (`claim_goal`), because the daemon shares this machine's
+token with the agent it launches and a second claimer on one identity eats the first
+one's claim.
 
 To launch an agent — any agent, not just Claude — when work arrives, set
-`PAIGY_ON_WAKE` to a command before `--install`. The sweep has already claimed the
-work, so the launcher reads it from the environment rather than calling
-`check_replies` again:
+`PAIGY_ON_WAKE` to a command before `--install`:
 
 | Variable | What it holds |
 | --- | --- |
-| `PAIGY_WORK` | the whole swept payload as JSON (`replies`, `requests`, `owedCallbacks`, `stalled`, `threads`) |
-| `PAIGY_EVENT` | the wake that caused this run — `boot`, `wake:reply`, `cron:callback`… |
-| `PAIGY_THREAD_ID` | the thread to continue on |
-| `PAIGY_NOTIFICATION_ID` | the notification being answered or acted on (unset for an owed callback) |
-| `PAIGY_CONTEXT_THREAD_ID` | a past conversation the user seeded this with — `get_thread` it **first** |
-| `PAIGY_TEXT` | what the user said (or the callback note you owe them), in prose |
+| `PAIGY_WORK` | everything the wake found, as JSON (`deliveries`, `goal`) |
+| `PAIGY_EVENT` | the wake that caused this run — `boot`, `wake:reply`, `wake:request`… |
+| `PAIGY_PARENT_ID` | the thread to continue on (`PAIGY_THREAD_ID` is the same value, for existing scripts) |
+| `PAIGY_DELIVERY_ID` | the Delivery being acted on — `contact({deliveryId})` rereads it |
+| `PAIGY_GOAL_ID` | the Goal it belongs to — `claim_goal` it **first** |
+| `PAIGY_CONTEXT_THREAD_ID` | a past conversation this Goal names — `get_thread` it **first** |
+| `PAIGY_TEXT` | what the person said, in prose |
 
 Hand `$PAIGY_WORK` to a harness that can read JSON and decide for itself; use the
 scalars for a plain shell launcher that shouldn't need `jq`. They describe **one**
-item — the oldest thread without a turn already in flight — because the queue rail's
-contract is one thread at a time. An absent fact is unset rather than empty, so
-`${PAIGY_CONTEXT_THREAD_ID:-}` distinguishes "no seed" from "seeded with nothing".
+item — the oldest open Delivery — because the contract is one thread at a time. An
+absent fact is unset rather than empty, so `${PAIGY_CONTEXT_THREAD_ID:-}`
+distinguishes "no seed" from "seeded with nothing".
 
 ```sh
 # Claude Code — hand it everything and let it plan:
-PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — rehydrate threads you do not recognize via get_thread first."' \
+PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — claim_goal first, and rehydrate threads you do not recognize via get_thread."' \
   npx -y -p @paigy/mcp paigy-listen --install
 
 # Codex (or any CLI harness) — the scalars are enough for a one-liner:
-PAIGY_ON_WAKE='codex exec "Continue Paigy thread $PAIGY_THREAD_ID. The user said: $PAIGY_TEXT. Call get_thread on it first if you do not recognize it, then reply with contact."' \
+PAIGY_ON_WAKE='codex exec "Claim Paigy goal $PAIGY_GOAL_ID and continue thread $PAIGY_THREAD_ID. The user said: $PAIGY_TEXT. Reply with contact."' \
   npx -y -p @paigy/mcp paigy-listen --install
 ```
 
@@ -194,10 +200,7 @@ script and branch on `$PAIGY_EVENT` there:
 seed=""
 [ -n "${PAIGY_CONTEXT_THREAD_ID:-}" ] && seed="It continues thread $PAIGY_CONTEXT_THREAD_ID — get_thread that first."
 
-case "$PAIGY_EVENT" in
-  cron:callback*) codex exec "You owe the user a callback on thread $PAIGY_THREAD_ID: $PAIGY_TEXT. Deliver it with contact." ;;
-  *)              codex exec "Paigy thread $PAIGY_THREAD_ID. The user said: $PAIGY_TEXT. $seed Reply with contact when done." ;;
-esac
+codex exec "Paigy goal $PAIGY_GOAL_ID on thread $PAIGY_THREAD_ID. claim_goal it first. The user said: $PAIGY_TEXT. $seed Reply with contact when done."
 ```
 
 ## Statusline (Claude Code)

package/dist/{chunk-TLASZUJD.js → chunk-647HS22P.js}

@@ -2,10 +2,10 @@ import {
   AGENT_TOOLS,
   mcpInputSchema,
   serverInstructions
-} from "./chunk-3QUIB42M.js";
+} from "./chunk-FFI3AIZE.js";
 import {
   AGENT_NAME
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/toolset.ts
 var ONBOARD_DESCRIPTION = "Get this agent talking to Paigy \u2014 call it FIRST, before contact, and any time you're unsure who you are. One call, and it does whatever the situation needs: NOT SET UP \u2192 hatches an identity instantly if this machine holds a device credential (the user ran the Paigy desktop app or harness), otherwise starts the code ceremony; ALREADY SET UP \u2192 returns your current identity and offers the two things left to decide, renaming it or unpairing; TOKEN NO LONGER VALID \u2192 says so, then re-pairs. Pass { name, voice } to choose who you are when hatching, or to RENAME yourself when already set up (voices: rachel, george, jessica, brian, lily). Safe to call any time: idempotent, and it never writes settings \u2014 the tool-allowlist state it reports is read-only. If it returns a `user_code`, print it to the user immediately and call onboard again with the `device_code`. If it returns `enable_command`, PRINT that command for the user to run \u2014 you cannot apply it yourself (it writes your own permission allowlist, which hosts block as privilege escalation), so print it, don't wait for it, and carry on.";

package/dist/{chunk-CXABA27N.js → chunk-BUTCP2ED.js}

@@ -10,7 +10,7 @@ import {
   saveToken,
   sleep,
   startE2ee
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {

package/dist/{chunk-3QUIB42M.js → chunk-FFI3AIZE.js}

@@ -36,7 +36,22 @@ function mcpInputSchema(s) {
 }
 var StartContactSchema = z.object({
   goalIds: z.tuple([z.string().uuid()]),
-  ask: z.string().trim().min(1).max(1e4),
+  // THE ASK IS THE QUESTION, not a bulletin with a question at the end (2026-09-16).
+  //
+  // A DecisionNeed is settled only by an answer in the shape THIS ask declares. Bundle news,
+  // findings and a decision into one, and the person answers whichever part engaged them —
+  // which settles nothing, leaves the need open, and gets them asked again. On call 619c5a92
+  // one ask carried a briefing, a side question ("the ring should show the agent's name now —
+  // what did you actually see?") and a one-of-four about how far an erase reaches. The owner
+  // answered the side question. The need stayed open; the card asked again. Of the 45 call
+  // asks carrying a decision, 27 are over 600 characters.
+  //
+  // Sending them separately costs nothing, because a CALL contact joins the call already
+  // happening (`goal/store.ts`, JOIN BEFORE MINTING) — several contacts on one Goal arrive as
+  // one call, planned as its turns, and each keeps its own settleable need.
+  ask: z.string().trim().min(1).max(1e4).describe(
+    "The question, and only what is needed to answer it. News, progress and findings are their own contact \u2014 a call contact JOINS a call already happening, so several arrive as one call. Do not bundle: a DecisionNeed is settled only by an answer in the shape this ask declares, so someone who answers the part that interested them settles nothing and is asked again."
+  ),
   waiting: z.enum(["none", "hard"]).default("none"),
   channel: z.enum(["notification", "call"]).default("notification"),
   options: z.array(z.object({ label: z.string().trim().min(1).max(1e3), image: z.string().url().optional(), html: z.string().max(16384).optional() }).strict()).min(2).max(6).optional(),
@@ -48,12 +63,25 @@ var CONTACT_DESCRIPTION = "Contact the user about exactly one existing Goal: pas
 var CreateGoalSchema = z2.object({
   outcome: z2.string().trim().min(1).max(1e4),
   ownerParticipant: z2.string().trim().min(1).optional(),
-  idempotencyKey: z2.string().trim().min(1).max(200)
+  idempotencyKey: z2.string().trim().min(1).max(200),
+  /** A past conversation this Goal should be read against — History's "new session from this"
+   *  (owner, on the call of 2026-09-14: "let's do the reference with the threading"). A
+   *  reference only: the owner reads it through `get_thread`, which does its own scoping, and
+   *  the writer refuses a thread belonging to another account. */
+  contextThreadId: z2.string().uuid().optional(),
+  /** THE GOAL THIS ONE BELONGS UNDER (owner, 2026-09-15: "the ask I gave for the design doc
+   *  didn't get created as a child goal of the voice UI goal, which is how it should've
+   *  worked"). It could not have been: this door took no parent, so the only route was
+   *  create -> claim -> `update_goal`, three calls with a lease in the middle, and every agent
+   *  took the short one. The hierarchy has been modelled since Goals existed and had been used
+   *  ZERO times in 2,031 of them. Absent still means a root, which is what every caller meant
+   *  before this existed. The writer refuses a Goal belonging to another account. */
+  parentGoalId: z2.string().uuid().optional()
 });
 var CreateGoalToolSchema = CreateGoalSchema.extend({
   idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
 }).strict();
-var CREATE_GOAL_DESCRIPTION = "Create a durable root Goal for an outcome. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
+var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Pass parentGoalId to create it UNDER an existing Goal \u2014 do that whenever the work is part of something already being tracked, rather than minting a root and leaving the relationship unsaid; absent means a root. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
 var UpdateGoalSchema = z2.object({
   revision: z2.number().int().positive(),
   changes: z2.object({
@@ -99,6 +127,21 @@ var AGENT_TOOL_NAMES = AGENT_TOOLS.map((t) => t.name);
 function serverInstructions(_opts) {
   return "On startup and after a wake, call check_replies for the open Deliveries addressed to you, and claim_goal for your runnable or review-pending Goal and its durable Entries and accepted decisions. get_goal rereads the same evidence without consuming it. Contact only for an existing Goal. Notifications return immediately: keep working and collect answers through claim_goal/get_goal. On stdio, Calls hold one bounded window; on hosted MCP, Calls return after one read; continue with contact({deliveryId}) to reread that exact Delivery. Evidence can repeat: reads do not acknowledge or hide it. Use update_goal to report progress and explicitly acknowledge review. Never infer ringing from an open Call Delivery. Soft waiting, multipart contact, and re-presentation are unsupported. In an interactive session, ask the user directly; use Paigy when they asked for it or are away.";
 }
+function entryWords(entry) {
+  const content = entry.content;
+  if (content && "sealed" in content) return "";
+  const plain = content?.plain;
+  if (typeof plain === "string") return plain;
+  if (plain && typeof plain === "object") {
+    const text = plain.text;
+    if (typeof text === "string") return text;
+    const title = plain.title;
+    const description = plain.description;
+    const parts = [title, ...Array.isArray(description) ? description : []].filter((v) => typeof v === "string");
+    if (parts.length) return parts.join("\n\n");
+  }
+  return entry.sources.map((source) => source.text).join("\n");
+}
 var ContextSchema = z3.object({
   title: z3.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
   description: z3.array(z3.string().min(1)).describe(
@@ -332,13 +375,6 @@ var AgentStateSchema = z3.enum(["idle", "in_progress", "completed", "needs_input
 var SetTaskStateSchema = z3.object({
   state: z3.enum(["in_progress", "completed", "needs_input"])
 });
-var SetWorkStateSchema = z3.object({
-  workId: z3.string().uuid().optional(),
-  notificationId: z3.string().optional(),
-  state: SetTaskStateSchema.shape.state
-}).refine((value) => Number(Boolean(value.workId)) + Number(Boolean(value.notificationId)) === 1, {
-  message: "exactly one of workId or notificationId is required"
-});
 var TurnSchema = z3.object({
   prompt: z3.string(),
   reply: z3.string()
@@ -468,13 +504,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
   })
 ]);
 var CallbackTriggerSchema = z3.enum(["on_done", "on_blocked", "scheduled"]);
-var ScheduleCallbackSchema = z3.object({
-  parentId: z3.string().describe("The thread to call back on (from a prior contact / reply / request)."),
-  goalId: z3.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
-  trigger: CallbackTriggerSchema,
-  dueInSeconds: z3.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
-  note: z3.string().optional().describe("What to tell the user when you follow up.")
-});
 var PendingRepliesSchema = z3.object({
   replies: z3.array(
     z3.object({
@@ -797,7 +826,21 @@ var InboxItemSchema = z3.object({
   /** E2EE: the agent's device X25519 public key to seal the user's answer BACK to (the
    *  sender the phone replies to). Sourced server-side from this item's pairing credential.
    *  Present only alongside `envelope`; the phone seals via sealAnswer(answer, this, id). */
-  agentX25519: z3.string().optional()
+  agentX25519: z3.string().optional(),
+  /** THE TARGET FACTS A CARD RENDERS (#1796 point 5, 2026-09-11): the Delivery it is a view of,
+   *  that Delivery's kind, the request Entry, the Goals it answers for, the exact DecisionNeed (none
+   *  for a request that asks nothing), whether its content is sealed, and that Goal's state. The
+   *  answer writer (`POST /api/entries`) and the disposition (`close_delivery`) take their ids from
+   *  here. The server projects it (`apps/api/src/inbox/project.ts`); a client never builds it. */
+  communication: z3.object({
+    deliveryId: z3.string(),
+    kind: z3.enum(["notification", "call"]),
+    entryId: z3.string(),
+    goalIds: z3.array(z3.string()),
+    decisionNeedId: z3.string().optional(),
+    sealed: z3.boolean(),
+    goalState: z3.string().optional()
+  }).optional()
 });
 var SnoozeRequestSchema = z3.object({
   requestId: z3.string(),
@@ -1033,26 +1076,54 @@ var CreateRequestSchema = z3.object({
    *  the agent reads it via get_thread. Must belong to the requesting user. */
   contextParentId: z3.string().optional()
 });
-var HandoffSchema = z3.object({
-  /** Move this existing outcome to `target` without reminting it. Requires `target`. */
-  workId: z3.string().uuid().optional(),
-  /** Land the note on an existing thread; omitted mints a fresh one. */
-  parentId: z3.string().uuid().optional(),
-  /** One-line headline of the working context handed off. */
-  title: z3.string().min(1),
-  /** The brief — standalone notes the successor reads (what was done, what's left, links). */
-  notes: z3.array(z3.string().min(1)).min(1),
-  /** A sibling connection to dispatch directly to (token id or agent nickname). Same-account
-   *  only; omit to leave the thread for the user to hand off in the app. */
-  target: z3.string().optional(),
-  /** Write the note as a RECAP (kind:'recap', #617): a summary turn that supersedes the
-   *  thread's earlier turns for rehydration — get_thread returns the latest recap + only
-   *  the turns after it. Handoff-to-a-successor and handoff-to-yourself-later are the
-   *  same primitive; a recap is one whose audience includes you. */
-  recap: z3.boolean().optional()
-}).refine((value) => !value.workId || Boolean(value.target), {
-  message: "target is required when handing off Work",
-  path: ["target"]
+var QueueQuestionSchema = z3.object({
+  /** The decision need's id — what an answer is accepted against. */
+  id: z3.string(),
+  /** The words that were asked, from the request Entry that asked them. */
+  question: z3.string(),
+  /** Where it was asked — which is where the ruling goes (`POST /api/entries`). Null only
+   *  for a need whose request Entry is carried by no interactive Delivery, which nothing
+   *  can answer. */
+  deliveryId: z3.string().nullable().default(null),
+  /** The Entry the ruling is about. */
+  aboutId: z3.string().nullable().default(null),
+  /** Empty for a free-text question. */
+  options: z3.array(OptionSchema).default([]),
+  select: z3.enum(["one", "many", "rank", "confirm", "text"]).default("text"),
+  askedAt: z3.string(),
+  /** Null while the question is open — which is how the page tells the two apart. */
+  answeredAt: z3.string().nullable().default(null),
+  /** The ruling in the person's own words, from the contribution that replied — not the
+   *  option id, which is not something anyone reads back. Null while it is open, and null
+   *  for a settled question whose reply carried nothing readable. */
+  answer: z3.string().nullable().default(null)
+});
+var QueueItemSchema = z3.object({
+  id: z3.string(),
+  /** One-line headline — the first sentence of the outcome. */
+  title: z3.string(),
+  /** The outcome in full, verbatim: the person's own words are what an assignee sees. */
+  intent: z3.string(),
+  /** `ready` | `active` | `waiting` | `done` | `cancelled`, straight off the Goal. */
+  state: z3.string(),
+  /** Who holds it (a participant ref); null when nobody does yet. */
+  assignee: z3.string().nullable().default(null),
+  /** What the agent last said it was doing; null if it has said nothing. */
+  progress: z3.string().nullable().default(null),
+  reviewPending: z3.boolean().default(false),
+  dueAt: z3.string().nullable().default(null),
+  /** The Goal this one was opened under; null at the root. */
+  parentGoalId: z3.string().nullable().default(null),
+  /** Goals opened under this one — only those the same list holds. */
+  childGoalIds: z3.array(z3.string()).default([]),
+  /** Goals this one waits on (start or finish gates). */
+  dependencyGoalIds: z3.array(z3.string()).default([]),
+  /** True while any gate is on a Goal that is not done — the walk draws it dashed. */
+  blocked: z3.boolean().default(false),
+  /** Every decision need on it, open or settled — the page decides which to show. */
+  questions: z3.array(QueueQuestionSchema).default([]),
+  createdAt: z3.string(),
+  updatedAt: z3.string().nullable().default(null)
 });
 var NoteSourceSchema = z3.enum(["app", "call"]);
 var NoteStatusSchema = z3.enum(["open", "assigned", "in_progress", "done"]);
@@ -1181,8 +1252,6 @@ var AcceptTriageResultSchema = z3.object({
   failed: z3.array(z3.object({ noteId: z3.string(), reason: z3.string() }))
 });
 var DeliveryModeSchema = z3.enum(["poll", "self_hosted"]);
-var WAKE_EVENT = "wake";
-var wakeChannel = (tokenId) => `wake:${tokenId}`;
 var RegisterDeliverySchema = z3.object({ mode: DeliveryModeSchema });
 var OAuthStartSchema = z3.object({
   provider: z3.enum(["cma"]),
@@ -1191,8 +1260,9 @@ var OAuthStartSchema = z3.object({
 var DeliveryConfigSchema = z3.object({
   tokenId: z3.string(),
   mode: DeliveryModeSchema,
-  /** null when the server has no SUPABASE_ANON_KEY set — the listener then falls
-   *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
+  /** null when the deployment has no anon key configured. `self_hosted` is then REFUSED
+   *  (503 `self_hosted_unavailable`) rather than registered, so a self_hosted config always
+   *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z3.object({ url: z3.string(), anonKey: z3.string() }).nullable()
 });
 var StatusSchema = z3.object({
@@ -1383,6 +1453,5 @@ export {
   mcpInputSchema,
   AGENT_TOOLS,
   serverInstructions,
-  WAKE_EVENT,
-  wakeChannel
+  entryWords
 };

package/dist/{chunk-4UZAPBKK.js → chunk-YJEJZT56.js}

@@ -2,7 +2,7 @@
 import { createRequire as __sdkCreateRequire } from "module";
 import { createHash, randomUUID } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
-import { setTimeout as sleep3 } from "timers/promises";
+import { setTimeout as sleep2 } from "timers/promises";
 import { z as z3 } from "zod";
 import { z as z2 } from "zod";
 import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
@@ -14,6 +14,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statS
 import { homedir } from "os";
 import { join } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
+import { createClient } from "@supabase/supabase-js";
 var require2 = __sdkCreateRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3551,7 +3552,22 @@ function mcpInputSchema(s) {
 }
 var StartContactSchema = z.object({
   goalIds: z.tuple([z.string().uuid()]),
-  ask: z.string().trim().min(1).max(1e4),
+  // THE ASK IS THE QUESTION, not a bulletin with a question at the end (2026-09-16).
+  //
+  // A DecisionNeed is settled only by an answer in the shape THIS ask declares. Bundle news,
+  // findings and a decision into one, and the person answers whichever part engaged them —
+  // which settles nothing, leaves the need open, and gets them asked again. On call 619c5a92
+  // one ask carried a briefing, a side question ("the ring should show the agent's name now —
+  // what did you actually see?") and a one-of-four about how far an erase reaches. The owner
+  // answered the side question. The need stayed open; the card asked again. Of the 45 call
+  // asks carrying a decision, 27 are over 600 characters.
+  //
+  // Sending them separately costs nothing, because a CALL contact joins the call already
+  // happening (`goal/store.ts`, JOIN BEFORE MINTING) — several contacts on one Goal arrive as
+  // one call, planned as its turns, and each keeps its own settleable need.
+  ask: z.string().trim().min(1).max(1e4).describe(
+    "The question, and only what is needed to answer it. News, progress and findings are their own contact \u2014 a call contact JOINS a call already happening, so several arrive as one call. Do not bundle: a DecisionNeed is settled only by an answer in the shape this ask declares, so someone who answers the part that interested them settles nothing and is asked again."
+  ),
   waiting: z.enum(["none", "hard"]).default("none"),
   channel: z.enum(["notification", "call"]).default("notification"),
   options: z.array(z.object({ label: z.string().trim().min(1).max(1e3), image: z.string().url().optional(), html: z.string().max(16384).optional() }).strict()).min(2).max(6).optional(),
@@ -3563,12 +3579,25 @@ var CONTACT_DESCRIPTION = "Contact the user about exactly one existing Goal: pas
 var CreateGoalSchema = z2.object({
   outcome: z2.string().trim().min(1).max(1e4),
   ownerParticipant: z2.string().trim().min(1).optional(),
-  idempotencyKey: z2.string().trim().min(1).max(200)
+  idempotencyKey: z2.string().trim().min(1).max(200),
+  /** A past conversation this Goal should be read against — History's "new session from this"
+   *  (owner, on the call of 2026-09-14: "let's do the reference with the threading"). A
+   *  reference only: the owner reads it through `get_thread`, which does its own scoping, and
+   *  the writer refuses a thread belonging to another account. */
+  contextThreadId: z2.string().uuid().optional(),
+  /** THE GOAL THIS ONE BELONGS UNDER (owner, 2026-09-15: "the ask I gave for the design doc
+   *  didn't get created as a child goal of the voice UI goal, which is how it should've
+   *  worked"). It could not have been: this door took no parent, so the only route was
+   *  create -> claim -> `update_goal`, three calls with a lease in the middle, and every agent
+   *  took the short one. The hierarchy has been modelled since Goals existed and had been used
+   *  ZERO times in 2,031 of them. Absent still means a root, which is what every caller meant
+   *  before this existed. The writer refuses a Goal belonging to another account. */
+  parentGoalId: z2.string().uuid().optional()
 });
 var CreateGoalToolSchema = CreateGoalSchema.extend({
   idempotencyKey: CreateGoalSchema.shape.idempotencyKey.optional().describe("Optional. One is minted per call; pass your own only so a retry lands on the same Goal.")
 }).strict();
-var CREATE_GOAL_DESCRIPTION = "Create a durable root Goal for an outcome. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
+var CREATE_GOAL_DESCRIPTION = "Create a durable Goal for an outcome. Pass parentGoalId to create it UNDER an existing Goal \u2014 do that whenever the work is part of something already being tracked, rather than minting a root and leaving the relationship unsaid; absent means a root. Admission only: the owner must claim it before doing work, then update it as it advances. Returns an admission receipt with goalId, current state, revision, ownerParticipant, and the next step; no Goal content or execution lease.";
 var UpdateGoalSchema = z2.object({
   revision: z2.number().int().positive(),
   changes: z2.object({
@@ -3899,13 +3928,6 @@ var AgentStateSchema = z3.enum(["idle", "in_progress", "completed", "needs_input
 var SetTaskStateSchema = z3.object({
   state: z3.enum(["in_progress", "completed", "needs_input"])
 });
-var SetWorkStateSchema = z3.object({
-  workId: z3.string().uuid().optional(),
-  notificationId: z3.string().optional(),
-  state: SetTaskStateSchema.shape.state
-}).refine((value) => Number(Boolean(value.workId)) + Number(Boolean(value.notificationId)) === 1, {
-  message: "exactly one of workId or notificationId is required"
-});
 var TurnSchema = z3.object({
   prompt: z3.string(),
   reply: z3.string()
@@ -4035,13 +4057,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
   })
 ]);
 var CallbackTriggerSchema = z3.enum(["on_done", "on_blocked", "scheduled"]);
-var ScheduleCallbackSchema = z3.object({
-  parentId: z3.string().describe("The thread to call back on (from a prior contact / reply / request)."),
-  goalId: z3.string().uuid().optional().describe("The Goal this callback advances; preferred for Goal-owned work."),
-  trigger: CallbackTriggerSchema,
-  dueInSeconds: z3.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
-  note: z3.string().optional().describe("What to tell the user when you follow up.")
-});
 var PendingRepliesSchema = z3.object({
   replies: z3.array(
     z3.object({
@@ -4364,7 +4379,21 @@ var InboxItemSchema = z3.object({
   /** E2EE: the agent's device X25519 public key to seal the user's answer BACK to (the
    *  sender the phone replies to). Sourced server-side from this item's pairing credential.
    *  Present only alongside `envelope`; the phone seals via sealAnswer(answer, this, id). */
-  agentX25519: z3.string().optional()
+  agentX25519: z3.string().optional(),
+  /** THE TARGET FACTS A CARD RENDERS (#1796 point 5, 2026-09-11): the Delivery it is a view of,
+   *  that Delivery's kind, the request Entry, the Goals it answers for, the exact DecisionNeed (none
+   *  for a request that asks nothing), whether its content is sealed, and that Goal's state. The
+   *  answer writer (`POST /api/entries`) and the disposition (`close_delivery`) take their ids from
+   *  here. The server projects it (`apps/api/src/inbox/project.ts`); a client never builds it. */
+  communication: z3.object({
+    deliveryId: z3.string(),
+    kind: z3.enum(["notification", "call"]),
+    entryId: z3.string(),
+    goalIds: z3.array(z3.string()),
+    decisionNeedId: z3.string().optional(),
+    sealed: z3.boolean(),
+    goalState: z3.string().optional()
+  }).optional()
 });
 var SnoozeRequestSchema = z3.object({
   requestId: z3.string(),
@@ -4600,26 +4629,54 @@ var CreateRequestSchema = z3.object({
    *  the agent reads it via get_thread. Must belong to the requesting user. */
   contextParentId: z3.string().optional()
 });
-var HandoffSchema = z3.object({
-  /** Move this existing outcome to `target` without reminting it. Requires `target`. */
-  workId: z3.string().uuid().optional(),
-  /** Land the note on an existing thread; omitted mints a fresh one. */
-  parentId: z3.string().uuid().optional(),
-  /** One-line headline of the working context handed off. */
-  title: z3.string().min(1),
-  /** The brief — standalone notes the successor reads (what was done, what's left, links). */
-  notes: z3.array(z3.string().min(1)).min(1),
-  /** A sibling connection to dispatch directly to (token id or agent nickname). Same-account
-   *  only; omit to leave the thread for the user to hand off in the app. */
-  target: z3.string().optional(),
-  /** Write the note as a RECAP (kind:'recap', #617): a summary turn that supersedes the
-   *  thread's earlier turns for rehydration — get_thread returns the latest recap + only
-   *  the turns after it. Handoff-to-a-successor and handoff-to-yourself-later are the
-   *  same primitive; a recap is one whose audience includes you. */
-  recap: z3.boolean().optional()
-}).refine((value) => !value.workId || Boolean(value.target), {
-  message: "target is required when handing off Work",
-  path: ["target"]
+var QueueQuestionSchema = z3.object({
+  /** The decision need's id — what an answer is accepted against. */
+  id: z3.string(),
+  /** The words that were asked, from the request Entry that asked them. */
+  question: z3.string(),
+  /** Where it was asked — which is where the ruling goes (`POST /api/entries`). Null only
+   *  for a need whose request Entry is carried by no interactive Delivery, which nothing
+   *  can answer. */
+  deliveryId: z3.string().nullable().default(null),
+  /** The Entry the ruling is about. */
+  aboutId: z3.string().nullable().default(null),
+  /** Empty for a free-text question. */
+  options: z3.array(OptionSchema).default([]),
+  select: z3.enum(["one", "many", "rank", "confirm", "text"]).default("text"),
+  askedAt: z3.string(),
+  /** Null while the question is open — which is how the page tells the two apart. */
+  answeredAt: z3.string().nullable().default(null),
+  /** The ruling in the person's own words, from the contribution that replied — not the
+   *  option id, which is not something anyone reads back. Null while it is open, and null
+   *  for a settled question whose reply carried nothing readable. */
+  answer: z3.string().nullable().default(null)
+});
+var QueueItemSchema = z3.object({
+  id: z3.string(),
+  /** One-line headline — the first sentence of the outcome. */
+  title: z3.string(),
+  /** The outcome in full, verbatim: the person's own words are what an assignee sees. */
+  intent: z3.string(),
+  /** `ready` | `active` | `waiting` | `done` | `cancelled`, straight off the Goal. */
+  state: z3.string(),
+  /** Who holds it (a participant ref); null when nobody does yet. */
+  assignee: z3.string().nullable().default(null),
+  /** What the agent last said it was doing; null if it has said nothing. */
+  progress: z3.string().nullable().default(null),
+  reviewPending: z3.boolean().default(false),
+  dueAt: z3.string().nullable().default(null),
+  /** The Goal this one was opened under; null at the root. */
+  parentGoalId: z3.string().nullable().default(null),
+  /** Goals opened under this one — only those the same list holds. */
+  childGoalIds: z3.array(z3.string()).default([]),
+  /** Goals this one waits on (start or finish gates). */
+  dependencyGoalIds: z3.array(z3.string()).default([]),
+  /** True while any gate is on a Goal that is not done — the walk draws it dashed. */
+  blocked: z3.boolean().default(false),
+  /** Every decision need on it, open or settled — the page decides which to show. */
+  questions: z3.array(QueueQuestionSchema).default([]),
+  createdAt: z3.string(),
+  updatedAt: z3.string().nullable().default(null)
 });
 var NoteSourceSchema = z3.enum(["app", "call"]);
 var NoteStatusSchema = z3.enum(["open", "assigned", "in_progress", "done"]);
@@ -4748,6 +4805,8 @@ var AcceptTriageResultSchema = z3.object({
   failed: z3.array(z3.object({ noteId: z3.string(), reason: z3.string() }))
 });
 var DeliveryModeSchema = z3.enum(["poll", "self_hosted"]);
+var WAKE_EVENT = "wake";
+var wakeChannel = (tokenId) => `wake:${tokenId}`;
 var RegisterDeliverySchema = z3.object({ mode: DeliveryModeSchema });
 var OAuthStartSchema = z3.object({
   provider: z3.enum(["cma"]),
@@ -4756,8 +4815,9 @@ var OAuthStartSchema = z3.object({
 var DeliveryConfigSchema = z3.object({
   tokenId: z3.string(),
   mode: DeliveryModeSchema,
-  /** null when the server has no SUPABASE_ANON_KEY set — the listener then falls
-   *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
+  /** null when the deployment has no anon key configured. `self_hosted` is then REFUSED
+   *  (503 `self_hosted_unavailable`) rather than registered, so a self_hosted config always
+   *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z3.object({ url: z3.string(), anonKey: z3.string() }).nullable()
 });
 var StatusSchema = z3.object({
@@ -4966,21 +5026,6 @@ function utf8ToBytes(s) {
   }
   return Uint8Array.from(out);
 }
-function bytesToUtf8(b) {
-  let out = "";
-  for (let i = 0; i < b.length; ) {
-    const c = b[i++];
-    if (c < 128) out += String.fromCharCode(c);
-    else if (c < 224) out += String.fromCharCode((c & 31) << 6 | b[i++] & 63);
-    else if (c < 240) out += String.fromCharCode((c & 15) << 12 | (b[i++] & 63) << 6 | b[i++] & 63);
-    else {
-      const cp = (c & 7) << 18 | (b[i++] & 63) << 12 | (b[i++] & 63) << 6 | b[i++] & 63;
-      const u = cp - 65536;
-      out += String.fromCharCode(55296 + (u >> 10), 56320 + (u & 1023));
-    }
-  }
-  return out;
-}
 var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 function toB64(bytes) {
   let out = "";
@@ -5026,15 +5071,9 @@ function concat(parts) {
   }
   return out;
 }
-function u16be(n) {
-  return Uint8Array.of(n >>> 8 & 255, n & 255);
-}
 function u32be(n) {
   return Uint8Array.of(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
 }
-function readU32be(b, o) {
-  return (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
-}
 function lp(b) {
   return concat([u32be(b.length), b]);
 }
@@ -5076,9 +5115,6 @@ function sharedSecret(peerX25519PubB64, mySecretB64) {
   if (raw.every((b) => b === 0)) throw new Error("low-order X25519 point \u2014 shared secret rejected");
   return toB64(raw);
 }
-function keyId(publicKeyB64) {
-  return toB64(import_tweetnacl2.default.hash(fromB64(publicKeyB64)).slice(0, 8));
-}
 function credentialBody(c) {
   return concat([
     lp(utf8ToBytes("paigy-device-credential-v1")),
@@ -5096,43 +5132,6 @@ function verifyDeviceCredential(cred, uikPublicB64) {
     return false;
   }
 }
-var ENVELOPE_VERSION = 1;
-var ENVELOPE_ALG = "x25519-xsalsa20poly1305";
-function canonicalHeader(msgId, hdr) {
-  const parts = [
-    u16be(ENVELOPE_VERSION),
-    lp(utf8ToBytes(ENVELOPE_ALG)),
-    lp(msgId),
-    lp(utf8ToBytes(hdr.field)),
-    lp(utf8ToBytes(hdr.kind)),
-    lp(utf8ToBytes(hdr.senderRole)),
-    u32be(hdr.seq),
-    u32be(hdr.recipientKeyIds.length),
-    ...hdr.recipientKeyIds.map((k) => lp(utf8ToBytes(k)))
-  ];
-  return concat(parts);
-}
-function open(envelope, myKeyId, mySecretKeyB64) {
-  if (envelope.v !== ENVELOPE_VERSION) throw new Error(`unsupported envelope version ${String(envelope.v)}`);
-  if (envelope.alg !== ENVELOPE_ALG) throw new Error(`unsupported alg ${String(envelope.alg)}`);
-  const rec = envelope.recipients.find((r) => r.keyId === myKeyId);
-  if (!rec) throw new Error("not a recipient of this envelope");
-  const cek = import_tweetnacl3.default.box.open(fromB64(rec.wrap), fromB64(rec.wnonce), fromB64(rec.epk), fromB64(mySecretKeyB64));
-  if (!cek) throw new Error("CEK unwrap failed (wrong key or tampered)");
-  const padded = import_tweetnacl3.default.secretbox.open(fromB64(envelope.ct), fromB64(envelope.nonce), cek);
-  if (!padded) throw new Error("body authentication failed (tampered ciphertext)");
-  if (padded.length < 8) throw new Error("malformed sealed plaintext");
-  const canonLen = readU32be(padded, 0);
-  if (canonLen < 0 || 8 + canonLen > padded.length) throw new Error("malformed sealed plaintext");
-  const sealedCanon = padded.slice(4, 4 + canonLen);
-  const bodyLen = readU32be(padded, 4 + canonLen);
-  const bodyStart = 8 + canonLen;
-  if (bodyStart + bodyLen > padded.length) throw new Error("malformed sealed plaintext");
-  const body = padded.slice(bodyStart, bodyStart + bodyLen);
-  const expected = canonicalHeader(fromB64(envelope.msgId), envelope.hdr);
-  if (!eqCt(sealedCanon, expected)) throw new Error("header mismatch (tampered metadata)");
-  return { header: envelope.hdr, body };
-}
 var SAS_DOMAIN = "paigy-sas-v2";
 function deriveSAS(input, bits = 24) {
   const bundle = concat([
@@ -5360,21 +5359,6 @@ async function pairStep(deviceCode, keyFile) {
     return { kind: "e2ee_aborted", warning: e.message };
   }
 }
-function openSealedAnswer(sealed, keypair) {
-  const myKeyId = keyId(keypair.x25519.publicKey);
-  const { header, body } = open(sealed.envelope, myKeyId, keypair.x25519.secretKey);
-  if (header.field !== "answer" || header.senderRole !== "user") {
-    throw new Error("sealed answer has the wrong envelope field/role \u2014 refusing (possible replay/misattribution)");
-  }
-  const parsed = UserAnswerSchema.safeParse(JSON.parse(bytesToUtf8(body)));
-  if (!parsed.success) throw new Error("sealed answer body is not a valid UserAnswer");
-  const answer = parsed.data;
-  const bodyIsIgnored = answer.kind === "ignored";
-  if (sealed.ignored !== bodyIsIgnored) {
-    throw new Error("sealed answer tamper: `ignored` hint disagrees with the decrypted body");
-  }
-  return answer;
-}
 var UnpairedError = class extends Error {
   constructor() {
     super("Not paired with Paigy \u2014 no valid token (the API answered 401). Run the pairing flow, then retry.");
@@ -5435,6 +5419,7 @@ async function updateGoal(goalId, input, opts = {}) {
   if (!res.ok) await fail("update_goal", res);
   return await res.json();
 }
+var AWAIT_WINDOW_MS = 45e3;
 async function getThread(parentId, opts = {}) {
   const res = ensureAuthed(await (opts.reach ?? reach)(`${BACKEND_URL}/api/thread/${encodeURIComponent(parentId)}`, {
     headers: { authorization: `Bearer ${authToken(opts.token) ?? ""}`, "x-paigy-model": "goal-entry-v1" }
@@ -5449,17 +5434,6 @@ async function searchThreads(q, opts = {}) {
   if (!res.ok) await fail("search_threads", res);
   return await res.json();
 }
-async function sweepLeased(opts = {}) {
-  const token = authToken(opts.token);
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
-    headers: {
-      authorization: `Bearer ${token}`,
-      "x-paigy-await-ack": "1"
-    }
-  }));
-  if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
 var tokenOverride = null;
 function overrideToken(secret) {
   tokenOverride = secret;
@@ -5505,10 +5479,10 @@ async function heartbeat(runtime, opts = {}) {
   }));
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status}`);
 }
-async function registerDelivery(mode) {
+async function registerDelivery(mode, opts = {}) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
     method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${authToken()}` },
+    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
     body: JSON.stringify({ mode })
   }));
   if (!res.ok) throw new Error(`register_delivery failed: ${res.status} ${await res.text()}`);
@@ -5544,7 +5518,7 @@ Inbox delivery is asynchronous; use claim_goal/get_goal to collect durable answe
   };
   const settled = (d) => d.kind === "notification" || d.state === "closed" || d.answers.length > 0 || d.entries.some((e) => e.kind === "contribution");
   if (opts.waits === false) return read(opts.signal);
-  const window = AbortSignal.timeout(45e3);
+  const window = AbortSignal.timeout(AWAIT_WINDOW_MS);
   const signal = opts.signal ? AbortSignal.any([opts.signal, window]) : window;
   let latest;
   try {
@@ -5552,7 +5526,7 @@ Inbox delivery is asynchronous; use claim_goal/get_goal to collect durable answe
       signal.throwIfAborted();
       latest = await read(signal);
       if (settled(latest)) return latest;
-      await sleep3(5e3, void 0, { signal });
+      await sleep2(5e3, void 0, { signal });
     }
   } catch (error) {
     opts.signal?.throwIfAborted();
@@ -5604,106 +5578,23 @@ async function runTool(name, args, opts) {
       throw new Error(`Unknown tool: ${name}`);
   }
 }
-var sleep4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var ReplyLeaseExpiredError = class extends Error {
-  constructor() {
-    super(
-      "The Paigy reply lease expired before acknowledgement. The answer remains durable; wait on it again (contact with only { wait: notificationId }) to reclaim it before acting."
-    );
-    this.name = "ReplyLeaseExpiredError";
-  }
-};
-var ReplyAckError = class extends Error {
-  constructor(message, retryable) {
-    super(message);
-    this.retryable = retryable;
-    this.name = "ReplyAckError";
-  }
-  retryable;
-};
-function decryptAnswer(reply, deps = {}) {
-  if (!reply.sealed) return reply.answer;
-  const keyFile = (deps.readKeyFile ?? readKeyFile)();
-  if (!keyFile?.keypair) {
-    throw new Error(
-      "received a sealed answer but this agent has no device key to open it \u2014 re-pair."
-    );
-  }
-  return openSealedAnswer(reply.sealed, keyFile.keypair);
-}
-function decodeReply(item, deps = {}) {
-  const { delivery: _delivery, ...withoutDelivery } = item;
-  const enriched = { ...withoutDelivery };
-  if (!enriched.sealed) return enriched;
-  const answer = decryptAnswer(enriched, deps);
-  const { sealed: _sealed, ...plaintext } = enriched;
-  return { ...plaintext, answer };
-}
-function deliveryOf(item) {
-  if (item.type !== "reply" || !("delivery" in item) || item.delivery === void 0) {
-    return null;
-  }
-  const delivery = item.delivery;
-  if (!delivery || typeof delivery.leaseId !== "string" || !delivery.leaseId || typeof delivery.expiresAt !== "string" || !delivery.expiresAt) {
-    throw new Error(
-      "Paigy returned invalid reply-delivery metadata; the answer was not acknowledged and remains recoverable."
-    );
-  }
-  return delivery;
-}
-async function responseDetail(res) {
-  try {
-    return (await res.text()).slice(0, 300);
-  } catch {
-    return "";
-  }
-}
-async function acknowledge(token, leaseId, opts = {}) {
-  const attempts = Math.max(1, Math.min(opts.attempts ?? 3, 5));
-  const backoffMs = Math.max(0, opts.backoffMs ?? 100);
-  const doSleep = opts.doSleep ?? sleep4;
-  let lastError;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    try {
-      const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await/ack`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${token}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({ leaseId })
-      }));
-      if (res.ok) return;
-      const detail2 = await responseDetail(res);
-      if (res.status === 409) throw new ReplyLeaseExpiredError();
-      const retryable = res.status === 408 || res.status === 425 || res.status === 429 || res.status >= 500;
-      throw new ReplyAckError(
-        `Paigy reply acknowledgement failed: ${res.status}${detail2 ? ` ${detail2}` : ""}`,
-        retryable
-      );
-    } catch (error) {
-      if (error instanceof UnpairedError || error instanceof ReplyLeaseExpiredError || error instanceof ReplyAckError && !error.retryable) {
-        throw error;
-      }
-      lastError = error;
-      if (attempt + 1 < attempts) {
-        await doSleep(backoffMs * 2 ** attempt);
-      }
+async function subscribeWake(onNudge, opts = {}) {
+  const cfg = await registerDelivery("self_hosted", opts);
+  const { url, anonKey } = cfg.realtime;
+  const channel = wakeChannel(cfg.tokenId);
+  const sb = createClient(url, anonKey, { auth: { persistSession: false } });
+  const ch = sb.channel(channel).on("broadcast", { event: WAKE_EVENT }, (msg) => onNudge(msg.payload ?? {}));
+  ch.subscribe();
+  return {
+    tokenId: cfg.tokenId,
+    channel,
+    close: async () => {
+      await sb.removeChannel(ch).catch(() => {
+      });
+      await registerDelivery("poll", opts).catch(() => {
+      });
     }
-  }
-  const detail = lastError instanceof Error ? lastError.message : String(lastError);
-  throw new Error(
-    `Could not acknowledge the Paigy reply after ${attempts} attempts (${detail}). The answer was not returned to the agent and remains recoverable after the lease expires.`
-  );
-}
-async function ackReply(item, token, opts = {}) {
-  const delivery = deliveryOf(item);
-  if (!delivery) throw new Error("Paigy returned a reply without a delivery lease; nothing to acknowledge.");
-  await acknowledge(token, delivery.leaseId, {
-    attempts: opts.ackAttempts,
-    backoffMs: opts.ackBackoffMs,
-    doSleep: opts.ackSleep
-  });
+  };
 }
 
 export {
@@ -5729,15 +5620,13 @@ export {
   fetchCredential,
   pairStep,
   UnpairedError,
-  sweepLeased,
+  getGoal,
   overrideToken,
-  authToken,
   hatch,
   whoAmI,
   setIdentity,
   heartbeat,
-  registerDelivery,
+  checkReplies,
   runTool,
-  decodeReply,
-  ackReply
+  subscribeWake
 };

package/dist/enable.js

@@ -2,9 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
-import "./chunk-4UZAPBKK.js";
+} from "./chunk-647HS22P.js";
+import "./chunk-FFI3AIZE.js";
+import "./chunk-YJEJZT56.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-CXABA27N.js";
+} from "./chunk-BUTCP2ED.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -16,8 +16,8 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
+} from "./chunk-647HS22P.js";
+import "./chunk-FFI3AIZE.js";
 import {
   clearSurface,
   writeSurface
@@ -38,7 +38,7 @@ import {
   setIdentity,
   slotName,
   whoAmI
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";

package/dist/listen.js

@@ -1,18 +1,14 @@
 #!/usr/bin/env node
 import {
-  WAKE_EVENT,
-  wakeChannel
-} from "./chunk-3QUIB42M.js";
+  entryWords
+} from "./chunk-FFI3AIZE.js";
 import {
-  ackReply,
-  authToken,
-  decodeReply,
-  registerDelivery,
-  sweepLeased
-} from "./chunk-4UZAPBKK.js";
+  checkReplies,
+  getGoal,
+  subscribeWake
+} from "./chunk-YJEJZT56.js";
 
 // src/listen.ts
-import { createClient } from "@supabase/supabase-js";
 import { spawn } from "child_process";
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
@@ -24,7 +20,7 @@ import { homedir } from "os";
 import { join } from "path";
 var LABEL = "ai.paigy.listen";
 function frozenEnv() {
-  const keys = ["PAIGY_BACKEND_URL", "PAIGY_ON_WAKE", "PAIGY_SUPABASE_URL", "PAIGY_SUPABASE_ANON_KEY"];
+  const keys = ["PAIGY_BACKEND_URL", "PAIGY_ON_WAKE"];
   return Object.fromEntries(keys.flatMap((k) => process.env[k] ? [[k, process.env[k]]] : []));
 }
 function renderLaunchd(nodePath, scriptPath, env) {
@@ -114,114 +110,49 @@ function uninstallService() {
   return unit;
 }
 
-// src/message.ts
-function answerText(answer) {
-  switch (answer.kind) {
-    case "text":
-      return answer.text;
-    case "option":
-      return answer.label ?? answer.optionId;
-    case "multi":
-    case "ranked":
-      return (answer.labels ?? answer.optionIds).join(", ");
-    case "confirm":
-      return answer.approved ? "approved" : "declined";
-    case "clarify":
-      return answer.chunks.join(" ");
-    case "turns":
-      return answer.turns.map((turn) => turn.reply).join(" ");
-    case "precedent":
-      return answer.answer;
-    case "ignored":
-      return "";
-  }
-}
-
 // src/listen.ts
 var emit = (obj) => void process.stdout.write(JSON.stringify(obj) + "\n");
-function launchEnv(work, reason) {
-  const env = { PAIGY_WORK: JSON.stringify(work), PAIGY_EVENT: reason };
+function saidIn(delivery) {
+  return delivery.entries.filter((entry) => entry.kind === "contribution").map((entry) => entryWords(entry)).filter(Boolean).join("\n");
+}
+function launchEnv(waiting, reason, goalId) {
+  const env = { PAIGY_WORK: JSON.stringify(waiting), PAIGY_EVENT: reason };
   const put = (key, value) => {
     if (value) env[key] = value;
   };
-  const lead = work.threads?.find((t) => !t.busy)?.items[0]?.notificationId;
-  const reply = lead ? work.replies.find((r) => r.notificationId === lead) : work.replies[0];
-  const request = lead ? work.requests.find((r) => r.notificationId === lead) : work.requests[0];
-  if (reply) {
-    put("PAIGY_THREAD_ID", reply.parentId);
-    put("PAIGY_PARENT_ID", reply.parentId);
-    put("PAIGY_NOTIFICATION_ID", reply.notificationId);
-    put("PAIGY_TEXT", answerText(reply.answer));
-    return env;
-  }
-  if (request) {
-    put("PAIGY_THREAD_ID", request.parentId);
-    put("PAIGY_PARENT_ID", request.parentId);
-    put("PAIGY_NOTIFICATION_ID", request.notificationId);
-    put("PAIGY_CONTEXT_THREAD_ID", request.contextParentId);
-    put("PAIGY_TEXT", request.text);
-    return env;
-  }
-  const callback = work.owedCallbacks[0];
-  if (callback) {
-    put("PAIGY_THREAD_ID", callback.parentId);
-    put("PAIGY_PARENT_ID", callback.parentId);
-    put("PAIGY_TEXT", callback.note);
-  }
+  const named = goalId ? waiting.deliveries.find((d) => d.goalIds.includes(goalId)) : void 0;
+  const lead = named ?? waiting.deliveries[0];
+  if (!lead) return env;
+  put("PAIGY_THREAD_ID", lead.threadId);
+  put("PAIGY_PARENT_ID", lead.threadId);
+  put("PAIGY_DELIVERY_ID", lead.deliveryId);
+  put("PAIGY_GOAL_ID", waiting.goal?.goalId ?? lead.goalIds[0]);
+  put("PAIGY_CONTEXT_THREAD_ID", waiting.goal?.contextThreadId);
+  put("PAIGY_TEXT", saidIn(lead) || lead.message);
   return env;
 }
-var SWEEP_PASSES = 10;
-async function sweep(reason) {
+async function sweep(reason, goalId) {
   try {
     const cmd = process.env.PAIGY_ON_WAKE;
-    const token = authToken() ?? "";
-    for (let pass = 0; pass < SWEEP_PASSES; pass += 1) {
-      const raw = await sweepLeased();
-      const leased = raw.replies;
-      const work = {
-        ...raw,
-        work: raw.work ?? [],
-        replies: leased.map((r) => {
-          const { type: _type, ...reply } = decodeReply({ ...r, type: "reply" });
-          return reply;
-        })
-      };
-      emit({ type: "sweep", reason, ...work });
-      const inbound = work.replies.length > 0 || work.requests.length > 0;
-      const reengage = work.owedCallbacks.length > 0 && (reason === "boot" || reason.includes("callback"));
-      if (cmd && (inbound || reengage)) {
-        spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, ...launchEnv(work, reason) } });
-      }
-      if (cmd) for (const r of leased) await ackReply({ ...r, type: "reply" }, token);
-      if (leased.length === 0) return;
+    const { deliveries } = await checkReplies();
+    const lead = (goalId ? deliveries.find((d) => d.goalIds.includes(goalId)) : void 0) ?? deliveries[0];
+    const leadGoalId = lead?.goalIds[0];
+    const goal = leadGoalId ? await getGoal(leadGoalId).then((g) => ({ goalId: leadGoalId, contextThreadId: g.contextThreadId, progress: g.progress })).catch(() => null) : null;
+    const waiting = { deliveries, goal };
+    emit({ type: "sweep", reason, ...goalId ? { about: goalId } : {}, ...waiting });
+    if (cmd && deliveries.length) {
+      spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, ...launchEnv(waiting, reason, goalId) } });
     }
   } catch (e) {
     emit({ type: "error", reason, message: e.message });
   }
 }
 async function main() {
-  const cfg = await registerDelivery("self_hosted");
-  const url = cfg.realtime?.url ?? process.env.PAIGY_SUPABASE_URL;
-  const anonKey = cfg.realtime?.anonKey ?? process.env.PAIGY_SUPABASE_ANON_KEY;
-  if (!url || !anonKey) {
-    throw new Error(
-      "No Realtime credentials \u2014 set SUPABASE_ANON_KEY on the server, or PAIGY_SUPABASE_URL + PAIGY_SUPABASE_ANON_KEY locally."
-    );
-  }
-  const channel = wakeChannel(cfg.tokenId);
-  emit({ type: "listening", channel });
+  const sub = await subscribeWake((nudge) => void sweep(`wake:${nudge.kind ?? "?"}`, nudge.parentId));
+  emit({ type: "listening", channel: sub.channel });
   await sweep("boot");
-  const sb = createClient(url, anonKey, { auth: { persistSession: false } });
-  sb.channel(channel).on(
-    "broadcast",
-    { event: WAKE_EVENT },
-    (msg) => void sweep(`wake:${msg.payload?.kind ?? "?"}`)
-  ).subscribe();
   const shutdown = async () => {
-    try {
-      await registerDelivery("poll");
-    } catch {
-    }
+    await sub.close();
     process.exit(0);
   };
   process.on("SIGINT", () => void shutdown());
@@ -251,5 +182,6 @@ if (isEntry()) {
 }
 export {
   launchEnv,
+  saidIn,
   sweep
 };

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-CXABA27N.js";
+} from "./chunk-BUTCP2ED.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-TLASZUJD.js";
-import "./chunk-3QUIB42M.js";
+} from "./chunk-647HS22P.js";
+import "./chunk-FFI3AIZE.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   AGENT_NAME
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/slot.ts
 process.stdout.write(AGENT_NAME);

package/dist/statusline.js

@@ -9,7 +9,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-4UZAPBKK.js";
+} from "./chunk-YJEJZT56.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.40.1",
+  "version": "0.40.2",
   "description": "Paigy MCP server — the AI agent harness that calls you. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",
@@ -39,8 +39,8 @@
     "typescript": "^5.7.2",
     "vitest": "^2.1.8",
     "@paigy/crypto": "0.0.0",
-    "@paigy/schema": "0.0.0",
-    "@paigy/sdk": "0.2.1"
+    "@paigy/sdk": "0.2.1",
+    "@paigy/schema": "0.0.0"
   },
   "scripts": {
     "build": "tsup",