@paigy/mcp 0.40.7 → 0.40.9

package/dist/{chunk-RJV6U6U4.js → chunk-LYPZ5QO2.js}

@@ -1,16 +1,10 @@
 import {
-  deleteKeyFile,
-  fetchCredential,
-  finalizeE2ee,
   isNetworkError,
-  pairStep,
-  readKeyFile,
+  pollToken,
   requestCode,
-  saveKeyFile,
   saveToken,
-  sleep,
-  startE2ee
-} from "./chunk-UZPBDJ37.js";
+  sleep
+} from "./chunk-5OY6ED2Q.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {
@@ -34,12 +28,14 @@ function suggestedAgentName(clientName) {
 
 // src/pairing.ts
 async function resolvePairing(deviceCode, capMs, pollMs = 2e3) {
-  let kf = readKeyFile();
   const start = Date.now();
   while (Date.now() - start < capMs) {
-    let step;
     try {
-      step = await pairStep(deviceCode, kf);
+      const token = await pollToken(deviceCode);
+      if (token) {
+        saveToken(token);
+        return { kind: "paired", token };
+      }
     } catch (e) {
       if (isNetworkError(e)) {
         await sleep(pollMs);
@@ -47,34 +43,6 @@ async function resolvePairing(deviceCode, capMs, pollMs = 2e3) {
       }
       return { kind: "error", message: e.message };
     }
-    if (step.kind === "e2ee_aborted") {
-      deleteKeyFile();
-      kf = null;
-      await sleep(pollMs);
-      continue;
-    }
-    if (step.kind === "awaiting_confirm") {
-      return { kind: "awaiting_confirm", sas: step.sas };
-    }
-    if (step.kind === "paired") {
-      saveToken(step.token);
-      if (!step.sas || !kf) {
-        deleteKeyFile();
-        return { kind: "paired", token: step.token };
-      }
-      const finalDeadline = Math.min(Date.now() + 1e4, start + capMs);
-      let e2ee = false;
-      while (Date.now() < finalDeadline) {
-        const cred = kf.userCode ? await fetchCredential(kf.userCode) : null;
-        if (cred && step.uikPub) {
-          e2ee = finalizeE2ee(kf, cred, step.uikPub);
-          break;
-        }
-        await sleep(pollMs);
-      }
-      if (!e2ee) deleteKeyFile();
-      return { kind: "paired", token: step.token, sas: step.sas, e2ee };
-    }
     await sleep(pollMs);
   }
   return { kind: "pending" };
@@ -83,15 +51,13 @@ var bg = null;
 var started = null;
 async function startPairing(agent) {
   if (started) return started;
-  const { keyFile, offer } = startE2ee();
-  const code = await requestCode(agent, offer);
+  const code = await requestCode(agent);
   started = {
     verificationUri: code.verification_uri_complete,
     userCode: code.user_code,
     deviceCode: code.device_code,
     expiresIn: code.expires_in
   };
-  saveKeyFile({ ...keyFile, userCode: code.user_code });
   startBackgroundPair(code.device_code, code.expires_in * 1e3);
   return started;
 }

package/dist/{chunk-4XG3YLGY.js → chunk-UFOR2QEP.js}

@@ -34,41 +34,39 @@ function mcpInputSchema(s) {
   delete schema.$schema;
   return draft2020(schema);
 }
-var StartContactSchema = z.object({
-  goalIds: z.tuple([z.string().uuid()]),
-  // 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.
+var AskInputSchema = z.object({
+  id: z.string().optional().describe("Optional idempotency key or client-side ID for this specific ask."),
+  parentId: z.string().uuid().optional().describe("Optional explicit parent Goal ID. If omitted, the platform's semantic router will auto-cluster it."),
+  repo: z.string().optional().describe("Optional repository context."),
   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."
   ),
+  options: z.array(z.object({
+    label: z.string().trim().min(1).max(1e3),
+    hint: z.string().trim().max(500).describe("Optional short projection of consequence or action if this option is chosen.").optional(),
+    image: z.string().url().optional(),
+    html: z.string().max(16384).describe("Optional sandboxed HTML/CSS preview. No JavaScript or network; inline CSS and data: URIs only. It renders edge-to-edge in a responsive card 200pt tall (about 320pt wide on a phone, with the next option peeking beside it), so fit the HTML to that viewport.").optional()
+  }).strict()).min(2).max(6).optional()
+}).strict();
+var StartContactSchema = z.object({
+  asks: z.array(AskInputSchema).min(1).describe("The list of asks/questions to pose. They will be semantically clustered by the API."),
   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(),
-  threadId: z.string().uuid().optional().describe("Continue an existing Thread: the threadId a prior Delivery returned. Omit to start a new Thread.")
+  channel: z.enum(["notification", "call"]).default("notification")
 }).strict();
 var ContactSchema = z.union([StartContactSchema, z.object({ deliveryId: z.string().uuid() }).strict()]);
 var CONTACT_SCHEMA = { type: "object", ...mcpInputSchema(ContactSchema) };
-var CONTACT_DESCRIPTION = "Contact the user about exactly one existing Goal: pass goalIds:[goalId], ask, channel:'notification'|'call', and waiting:'none'|'hard'. Options supply choices. Notification returns immediately; collect durable answers with claim_goal/get_goal. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. Continuation sends nothing and rereads the same durable evidence, including previously read answers. Entries retain authorship and provenance; accepted decisions are separate from quoted speech. Call state open does not mean ringing. Unsupported: soft waiting, multiple Goals/questions, outcome admission, and re-presentation of an existing request. Create a Goal explicitly first; never resend a pending ask to continue waiting.";
+var CONTACT_DESCRIPTION = "Contact the user with one or more asks/questions. Pass an array of asks (each with 'ask', optional 'options', 'id', 'parentId', 'repo'), plus channel:'notification'|'call', and waiting:'none'|'hard'. The platform will semantically cluster your asks under the correct Goals automatically. Notification returns immediately; collect durable answers with check_replies. On stdio, a Call holds one cancellable ~45s window; continue with ONLY {deliveryId}. Never bundle multiple questions into a single 'ask' string; pass them as separate objects in the 'asks' array.";
 var CreateGoalSchema = z2.object({
   outcome: z2.string().trim().min(1).max(1e4),
+  /** The work's NAME (#2115) — one to five words, how a person refers to it out loud ("the night
+   *  rings"). Omit it and the brain writes one at admission from the outcome. */
+  title: z2.string().trim().min(1).max(80).optional(),
   ownerParticipant: z2.string().trim().min(1).optional(),
   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
@@ -76,16 +74,22 @@ var CreateGoalSchema = z2.object({
    *  took the short one. The hierarchy has been modelled since Goals existed and had been used
    *  ZERO times in 2,031 of them. Absent, the server judges it against the caller's open Goals
    *  (`apps/api/src/goal/intake.ts`). The writer refuses a Goal belonging to another account. */
-  parentGoalId: z2.string().uuid().optional()
+  parentGoalId: z2.string().uuid().optional(),
+  /** The repository or project identifier this Goal belongs to (#2280) — e.g. "owner/repo" or
+   *  repo name. Delegated work inherits this from its parent Goal when omitted. */
+  repo: z2.string().trim().min(1).max(200).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 Goal for an outcome. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. 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. Without parentGoalId it is placed against your open Goals: if one already IS this work, that Goal comes back (existing: true) and nothing new is created \u2014 continue it; if the work belongs under one, it is created there (parentGoalId in the receipt); otherwise it is a root. Pass parentGoalId yourself to put it under a specific Goal. Pass repo to anchor the work to a specific repository ("owner/repo" or repo name); delegated children inherit it. Pass title to name it in one to five words, as a person would refer to it out loud ("the night rings") \u2014 it heads every list and is spoken on a call; without one the brain writes it. 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({
     outcome: z2.string().trim().min(1).max(1e4).optional(),
+    /** The work's NAME (#2115) — one to five words, how a person refers to it out loud. The
+     *  brain writes one at admission; this is the owner saying it better. Null clears it. */
+    title: z2.string().trim().min(1).max(80).nullable().optional(),
     ownerParticipant: z2.string().trim().min(1).optional(),
     parentGoalId: z2.string().uuid().nullable().optional(),
     dependencies: z2.array(z2.object({ goalId: z2.string().uuid(), gate: z2.enum(["start", "finish"]) }).strict()).optional(),
@@ -102,7 +106,7 @@ var UpdateGoalToolSchema = UpdateGoalSchema.omit({ operationId: true }).extend({
 var ClaimGoalSchema = z2.object({ goalId: z2.string().uuid().optional() }).strict();
 var GetGoalSchema = z2.object({ goalId: z2.string().uuid() }).strict();
 var 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.";
-var UPDATE_GOAL_DESCRIPTION = "Update an owned Goal at an exact revision. State, ownership, dependencies, children, progress, and review acknowledgement are explicit; stale revisions are rejected. 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. Returns the Goal as get_goal reads it, at its new revision.";
+var 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. Returns the Goal as get_goal reads it, at its new revision.";
 var CLAIM_GOAL_DESCRIPTION = "Claim the oldest runnable or review-pending Goal you own, or pass goalId to claim that Goal. Returns the Goal as get_goal reads it, and creates or renews the execution lease.";
 var CHECK_REPLIES_DESCRIPTION = "Your open Deliveries: every Notification or Call currently addressed to you \u2014 a request the user started toward you, an answer relayed to something you asked, a handoff \u2014 one row each: its Goals, how many decisions are still open, and the newest words in brief. 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 it in full with contact({deliveryId}). Once you have acted on what arrived, update_goal with reviewed: true closes the Deliveries addressed to you on that Goal. Your runnable and review-pending Goals come from claim_goal, not from here.";
 var CheckRepliesSchema = z2.object({}).strict();
@@ -126,7 +130,13 @@ var AGENT_TOOLS = [
 ];
 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 the conversation on it. get_goal rereads it without claiming. Every read ends in `next`, the one step to take. 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.";
+  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 the conversation on it. get_goal rereads it without claiming. Every read ends in \`next\`, the one step to take. 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. Your user is remote. Always interact with the user through Paigy. For decisions, approvals, or questions, contact them with structured options. Never assume anyone is reading the terminal stdout.
+
+CRITICAL PAIGY WORKFLOW PHILOSOPHY:
+1. Atomicity: Never dump a 5-part question into a single \`ask\`. Emit 5 separate objects in the \`asks\` array during a single \`contact\` call so the user can answer them independently.
+2. Tree Structure: Always pass \`parentId\` to deliberately nest sub-decisions under the overarching Goal, ensuring the user workspace remains a clean tree rather than a flat mess.
+3. Urgency: Use \`waiting: hard\` strictly for immediate, blocking decisions, and \`waiting: none\` for async, long-running progress updates or non-blocking questions.
+4. Asynchrony: Never hold the process open with while-loops. Let the current process finish or explicitly schedule wakeups, and rely on \`check_replies\` or \`claim_goal\` on the next wake to process asynchronous answers.`;
 }
 function entryWords(entry) {
   const content = entry.content;
@@ -143,6 +153,7 @@ function entryWords(entry) {
   }
   return entry.sources.map((source) => source.text).join("\n");
 }
+var LIVE_MS = 3 * 6e4;
 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(
@@ -172,10 +183,11 @@ var TransformSchema = z3.enum([
 var OptionSchema = z3.object({
   id: z3.string(),
   label: z3.string(),
+  hint: z3.string().max(500).describe("Optional short projection of consequence or action if this option is chosen (e.g. 'Reruns test suite', 'Merges to main').").optional(),
   // .describe() flows into the MCP contact JSON schema (zodToJsonSchema), so
   // the constraints below are what an agent reads when deciding to use these.
   html: z3.string().max(16384).describe(
-    "Optional sandboxed HTML/CSS preview for a visual 'pick one' (shown in the option card). Untrusted-sandboxed: NO JavaScript, NO external network or images \u2014 inline CSS and data: URIs only; <=16KB. Use for layout/CSS mockups, tables, diffs. For a hosted image use `image` instead."
+    "Optional sandboxed HTML/CSS preview for a visual 'pick one' (shown in the option card). Untrusted-sandboxed: NO JavaScript, NO external network or images \u2014 inline CSS and data: URIs only; <=16KB. Rendered edge-to-edge in a responsive card that is 200pt tall (about 320pt wide on a phone, with the next option peeking beside it); make your HTML fit that viewport. Use for layout/CSS mockups, tables, diffs. For a hosted image use `image` instead."
   ).optional(),
   image: z3.string().url().describe(
     "Optional image URL rendered as the option's preview (plain image, not sandboxed). For agent-generated HTML/CSS mockups, use `html` instead."
@@ -266,23 +278,6 @@ var NotifyRequestFields = z3.object({
    *  when `parentId` became the conversation handle: `parentId` says WHERE, this
    *  says HOW. */
   clarifies: z3.string().optional(),
-  /** E2EE (text lane): when the pairing is E2EE, the sealed replacements for the
-   *  plaintext content fields, keyed by field name. FINALIZED wire shape (was
-   *  provisional in the storage PR): a per-field map `{ context?, options?,
-   *  visuals? }` of opaque Envelopes — one seal per present content field, so a
-   *  message with no options/visuals seals only `context`. It COEXISTS with the
-   *  plaintext fields by mutual exclusion: the superRefine below requires that
-   *  when `envelope` is present the plaintext `context`/`options`/`visuals` are
-   *  ABSENT (and vice-versa), so a row is either fully plaintext or fully sealed —
-   *  never a readable half. The server persists this OPAQUELY into
-   *  notifications.envelope and relays it blindly; it never decrypts. Absent =
-   *  today's plaintext path (context/options/visuals carry the cleartext).
-   *  z.lazy because EnvelopeSchema is declared further down (E2EE section). */
-  envelope: z3.object({
-    context: z3.lazy(() => EnvelopeSchema).optional(),
-    options: z3.lazy(() => EnvelopeSchema).optional(),
-    visuals: z3.lazy(() => EnvelopeSchema).optional()
-  }).optional(),
   select: SelectShapeSchema.optional().describe(
     "How the user answers \u2014 required on the fully-shaped form, pick the shape that fits the question: 'one' = pick one option, 'many' = pick several, 'rank' = pick & order (each needs `options`); 'confirm' = yes/no or approve/deny; 'text' = free-form reply only (status updates, open questions). 'confirm' and 'text' take no options. Omit only when sending the simplified `ask` form \u2014 the broker picks the shape."
   ),
@@ -336,22 +331,6 @@ var NotifyRequestFields = z3.object({
 });
 var NotifyRequestSchema = NotifyRequestFields.superRefine((r, ctx) => {
   if (r.workId && r.goalId) ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["goalId"], message: "pass goalId or workId, not both" });
-  const sealed = !!r.envelope;
-  if (sealed) {
-    if (!r.envelope?.context)
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["envelope", "context"], message: "sealed request must include envelope.context" });
-    for (const f of ["context", "options", "visuals"]) {
-      if (r[f] !== void 0)
-        ctx.addIssue({ code: z3.ZodIssueCode.custom, path: [f], message: `E2EE request must not carry plaintext ${f} \u2014 it's sealed in envelope.${f}` });
-    }
-    if (r.points !== void 0)
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["points"], message: "E2EE request must not carry plaintext points" });
-    if (r.ask !== void 0)
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["ask"], message: "E2EE request must not carry a plaintext ask \u2014 derive the shape agent-side and seal it" });
-    if (r.needs !== void 0)
-      ctx.addIssue({ code: z3.ZodIssueCode.custom, path: ["needs"], message: "E2EE request must not carry plaintext needs" });
-    return;
-  }
   if (r.ask !== void 0) {
     for (const f of ["context", "select", "points"]) {
       if (r[f] !== void 0)
@@ -426,13 +405,6 @@ var AwaitItemSchema = z3.discriminatedUnion("type", [
     workId: z3.string().uuid().optional(),
     decisionId: z3.string().uuid().optional(),
     answer: UserAnswerSchema,
-    /** E2EE: present when the answer is sealed. The server relays the opaque answer
-     *  envelope + the plaintext `ignored` status hint; the receiving agent OPENS it
-     *  with its device key and re-derives the real UserAnswer, treating a mismatch
-     *  against `ignored` as tampering. Absent = today's plaintext answer (in `answer`).
-     *  On a sealed reply the plaintext `answer` is a placeholder (kind reflects only
-     *  the `ignored` bit) — never the real content, which stays sealed. */
-    sealed: z3.lazy(() => SealedAnswerSchema).optional(),
     /** WHAT THE AGENT CANNOT KNOW FROM THE FIELDS BESIDE IT (owner, 2026-09-04, issue
      *  #1537). One line, built from the record: the ask and the caller's reply VERBATIM,
      *  the notification they belong to, and the `contact` call that reaches the person
@@ -654,21 +626,6 @@ var InboxItemSchema = z3.object({
   blocking: z3.boolean().default(false),
   /** The user's locked-in answer; present only for replied items (GET /api/replied/:id). */
   answer: UserAnswerSchema.optional(),
-  /** E2EE (text lane): the sealed content this item carries when the pairing is E2EE, in
-   *  place of the plaintext `context`/`options`/`visuals` (which the operator would
-   *  otherwise read). A per-field map of opaque Envelopes — the SAME shape as
-   *  NotifyRequest.envelope. The native app decrypts it locally via openNotification;
-   *  web / an un-enrolled device can't and renders a locked placeholder. Absent = today's
-   *  plaintext item (context carries the cleartext), so plaintext items are unchanged. */
-  envelope: z3.object({
-    context: z3.lazy(() => EnvelopeSchema).optional(),
-    options: z3.lazy(() => EnvelopeSchema).optional(),
-    visuals: z3.lazy(() => EnvelopeSchema).optional()
-  }).optional(),
-  /** 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(),
   /** 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
@@ -766,13 +723,6 @@ var UserSettingsSchema = z3.object({
    *  setting. Absent = a spoken time can't be landed, so the reminder rides the next
    *  call — honest about what we know. */
   timezone: z3.string().min(1).max(64).optional(),
-  /** Account E2EE state (text lane): 'off' (default) = today's plaintext; 'on' =
-   *  content is sealed end-to-end between the local agent and the phone. Like
-   *  voiceMode, OPTIONAL and NOT defaulted so a stale client PATCHing the full
-   *  settings object without it can't silently flip the account's E2EE state.
-   *  Absent = leave unchanged on write, 'off' on read (see store.ts). The demo
-   *  account is plaintext by construction and refuses any non-'off' value. */
-  e2eeMode: z3.enum(["off", "on"]).optional(),
   /** Rung-2 broker tuning (#381). Optional and NOT defaulted, same stale-client
    *  clobber guard as voiceMode: absent = leave unchanged on write. */
   broker: BrokerTuningSchema.optional()
@@ -924,7 +874,19 @@ var QueueQuestionSchema = z3.object({
   /** 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)
+  answer: z3.string().nullable().default(null),
+  /** The Goal this question belongs to — a step knows its Goal on its own, not only through
+   *  an `InboxItem`'s `communication.goalIds[0]` (walk/design.md §12 item 3).
+   *  READ BY `apps/client/src/walk/order.ts`, which stamps it onto every `WalkStep`: the walk's
+   *  order, its route, home's trees and the list of steps all take a step's Goal from here, so
+   *  this is the field they agree through rather than each re-deriving it from the row it
+   *  arrived under. Required because the API projects it on every need it sends. */
+  goalId: z3.string(),
+  /** True only while an unmet START gate holds the Goal — a Goal that merely waits to
+   *  *finish* does not stop a person from answering (owner, 2026-09-16: "per need gate from
+   *  the API"; §4's dashed node). Not the same fact as `QueueItem.blocked`, which counts any
+   *  gate at all. */
+  blocked: z3.boolean().default(false)
 });
 var QueueItemSchema = z3.object({
   id: z3.string(),
@@ -950,6 +912,8 @@ var QueueItemSchema = z3.object({
   blocked: z3.boolean().default(false),
   /** Every decision need on it, open or settled — the page decides which to show. */
   questions: z3.array(QueueQuestionSchema).default([]),
+  /** The repository or project identifier this Goal belongs to (#2280), null if untracked. */
+  repo: z3.string().nullable().optional(),
   createdAt: z3.string(),
   updatedAt: z3.string().nullable().default(null)
 });
@@ -1061,54 +1025,12 @@ var DeliveryConfigSchema = z3.object({
    *  carries credentials; only a `poll` registration can come back with null here. */
   realtime: z3.object({ url: z3.string(), anonKey: z3.string() }).nullable()
 });
-var EnvelopeRecipientSchema = z3.object({
-  keyId: z3.string(),
-  epk: z3.string(),
-  wnonce: z3.string(),
-  wrap: z3.string()
-});
-var EnvelopeHeaderSchema = z3.object({
-  field: z3.enum(["context", "options", "visuals", "answer"]),
-  kind: z3.string(),
-  senderRole: z3.enum(["agent", "user"]),
-  recipientKeyIds: z3.array(z3.string()),
-  seq: z3.number().int().nonnegative()
-});
-var EnvelopeSchema = z3.object({
-  v: z3.literal(1),
-  alg: z3.literal("x25519-xsalsa20poly1305"),
-  msgId: z3.string(),
-  hdr: EnvelopeHeaderSchema,
-  recipients: z3.array(EnvelopeRecipientSchema).min(1),
-  nonce: z3.string(),
-  ct: z3.string()
-});
-var SealedAnswerSchema = z3.object({
-  ignored: z3.boolean(),
-  envelope: EnvelopeSchema
-});
-var DeviceCredentialSchema = z3.object({
-  deviceId: z3.string(),
-  kind: z3.enum(["phone", "web", "agent"]),
-  x25519Pub: z3.string(),
-  ed25519Pub: z3.string(),
-  sig: z3.string()
-});
-var DeviceRosterSchema = z3.object({
-  uikPub: z3.string(),
-  devices: z3.array(DeviceCredentialSchema)
-});
 var WakeNudgeSchema = z3.object({
   kind: z3.enum(["reply", "request", "callback"]),
   notificationId: z3.string().optional(),
   parentId: z3.string()
 });
 var PairingStatusSchema = z3.enum(["pending", "approved", "denied", "expired"]);
-var PairingRevealSchema = z3.object({
-  x25519: z3.string(),
-  ed25519: z3.string(),
-  nonce: z3.string()
-});
 var DeviceCodeSchema = z3.object({
   device_code: z3.string(),
   user_code: z3.string(),
@@ -1128,19 +1050,7 @@ var DeviceInfoSchema = z3.object({
    *  (seen live: PAIGY-5T, 2026-07-21). Remove once a newer binary is the floor. */
   agent: z3.string().optional(),
   device: z3.string().nullable(),
-  status: PairingStatusSchema,
-  proto: z3.string().nullable().optional(),
-  agent_commitment: z3.string().nullable().optional(),
-  // Ca
-  agent_reveal: PairingRevealSchema.nullable().optional(),
-  // present once the agent reveals
-  agent_credential: DeviceCredentialSchema.nullable().optional(),
-  // the phone's UIK-signed cred over the agent's keys — the agent fetches it here to finalizeE2ee
-  // The phone's reveal + identity key, exposed here so a GATED agent (e2ee_mode='on', token
-  // withheld until e2ee=true) can compute the SAS WITHOUT a token. Public keys — same safety
-  // class as agent_reveal above. Present only once the phone reveals; null otherwise.
-  phone_reveal: PairingRevealSchema.nullable().optional(),
-  uik_pub: z3.string().nullable().optional()
+  status: PairingStatusSchema
 });
 var DeviceTokenSchema = z3.object({
   access_token: z3.string(),
@@ -1159,8 +1069,6 @@ var DeviceTokenSchema = z3.object({
    *  landed in the FIRST granted workspace and the agent rediscovered its own repo from
    *  the thread each time (host.ts, live catch 2026-08-06 — prompt-papered until now). */
   workspace: z3.string().nullable().optional(),
-  phone_reveal: PairingRevealSchema.nullable().optional(),
-  // present once the phone reveals
   uik_pub: z3.string().nullable().optional()
 });
 var SupportRequestSchema = z3.object({
@@ -1182,13 +1090,6 @@ var NotificationFeedbackKindSchema = z3.enum([
   "other"
   // anything else — the note carries it.
 ]);
-var FeedbackResolutionSchema = z3.enum(["broker_fixed", "sent_to_agent"]);
-var FeedbackOutcomeSchema = z3.object({
-  resolution: FeedbackResolutionSchema,
-  transform: TransformSchema,
-  message: z3.string(),
-  childIds: z3.array(z3.string()).optional()
-});
 
 export {
   mcpInputSchema,

package/dist/{chunk-CAKRIAGP.js → chunk-UOROFXDI.js}

@@ -2,10 +2,10 @@ import {
   AGENT_TOOLS,
   mcpInputSchema,
   serverInstructions
-} from "./chunk-4XG3YLGY.js";
+} from "./chunk-UFOR2QEP.js";
 import {
   AGENT_NAME
-} from "./chunk-UZPBDJ37.js";
+} from "./chunk-5OY6ED2Q.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/enable.js

@@ -2,9 +2,9 @@
 import {
   PAIGY_TOOL_IDS,
   enablePaigyTools
-} from "./chunk-CAKRIAGP.js";
-import "./chunk-4XG3YLGY.js";
-import "./chunk-UZPBDJ37.js";
+} from "./chunk-UOROFXDI.js";
+import "./chunk-UFOR2QEP.js";
+import "./chunk-5OY6ED2Q.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-RJV6U6U4.js";
+} from "./chunk-LYPZ5QO2.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -13,11 +13,9 @@ import {
   PairSchema,
   SERVER_INSTRUCTIONS,
   TOOLS,
-  autoConfigureClients,
-  claudeInstallHint,
   paigyToolsAllowlisted
-} from "./chunk-CAKRIAGP.js";
-import "./chunk-4XG3YLGY.js";
+} from "./chunk-UOROFXDI.js";
+import "./chunk-UFOR2QEP.js";
 import {
   clearSurface,
   writeSurface
@@ -25,7 +23,6 @@ import {
 import {
   AGENT_NAME,
   UnpairedError,
-  deleteKeyFile,
   deleteToken,
   hatch,
   heartbeat,
@@ -38,7 +35,7 @@ import {
   setIdentity,
   slotName,
   whoAmI
-} from "./chunk-UZPBDJ37.js";
+} from "./chunk-5OY6ED2Q.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -49,7 +46,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import qrcode from "qrcode-generator";
 var JOIN_CAP_MS = 45e3;
-function pairedResult(token, sas, note, e2ee) {
+function pairedResult(token, sas, note) {
   clearSurface();
   const base = {
     status: "paired",
@@ -57,21 +54,10 @@ function pairedResult(token, sas, note, e2ee) {
     device: token.device
   };
   if (sas) {
-    base.e2ee = !!e2ee;
     base.sas = sas;
-    base.verify_message = `This pairing is end-to-end encrypted. Ask the user to verify this code matches the one on their phone: ${sas}` + (e2ee ? "" : " (identity key not yet confirmed on the phone).");
+    base.verify_message = `This pairing is end-to-end encrypted. Ask the user to verify this code matches the one on their phone: ${sas}`;
   }
   if (note) base.note = note;
-  try {
-    const registered = autoConfigureClients();
-    if (registered.length) {
-      base.auto_registered = registered;
-      base.auto_register_message = `Also registered the Paigy MCP server in: ${registered.join("; ")}. Tell the user \u2014 those tools pick it up on their next restart/reload.`;
-    }
-    const hint = claudeInstallHint();
-    if (hint) base.claude_hint = hint;
-  } catch {
-  }
   base.enable_tool_ids = PAIGY_TOOL_IDS;
   base.enable_command = ENABLE_COMMAND;
   base.enable_prompt = "REQUIRED \u2014 before you do anything else, print `enable_command` to the user and say: \"Run this to let Paigy's tools work without an approval prompt each time \u2014 it only allowlists the notify/await tools; pair and unpair still ask.\" Print it every time you pair; don't skip it.";
@@ -88,7 +74,6 @@ Check it matches the code on the phone, then type it there to confirm.` },
         type: "text",
         text: JSON.stringify({
           status: "awaiting_confirmation",
-          e2ee: true,
           sas,
           device_code,
           user_message: `# ${sas}`,
@@ -107,7 +92,6 @@ function renderPairOutcome(outcome, device_code) {
     case "awaiting_confirm":
       return awaitingConfirmResult(outcome.sas, device_code);
     case "paired":
-      return pairedResult(outcome.token, outcome.sas, void 0, outcome.e2ee);
     case "pending":
       return {
         content: [{
@@ -307,7 +291,6 @@ async function handleTool(request, signal) {
         }
       }
       const removed = deleteToken();
-      deleteKeyFile();
       clearPairing();
       return {
         content: [{

package/dist/listen.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   entryWords
-} from "./chunk-4XG3YLGY.js";
+} from "./chunk-UFOR2QEP.js";
 import {
   checkReplies,
   contact,
   getGoal,
   subscribeWake
-} from "./chunk-UZPBDJ37.js";
+} from "./chunk-5OY6ED2Q.js";
 
 // src/listen.ts
 import { spawn } from "child_process";
@@ -124,11 +124,8 @@ function launchEnv(waiting, reason, goalId) {
   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) || ("about" in lead ? lead.about : ""));
   return env;
 }
@@ -140,7 +137,7 @@ async function sweep(reason, goalId) {
     const full = lead ? await contact({ deliveryId: lead.deliveryId }, { waits: false }).catch(() => null) : null;
     const deliveries = rows.map((d) => d === lead && full ? full : d);
     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 goal = leadGoalId ? await getGoal(leadGoalId).then((g) => ({ goalId: leadGoalId, progress: g.progress })).catch(() => null) : null;
     const waiting = { deliveries, goal };
     emit({ type: "sweep", reason, ...goalId ? { about: goalId } : {}, ...waiting });
     if (cmd && deliveries.length) {

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-RJV6U6U4.js";
+} from "./chunk-LYPZ5QO2.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-CAKRIAGP.js";
-import "./chunk-4XG3YLGY.js";
+} from "./chunk-UOROFXDI.js";
+import "./chunk-UFOR2QEP.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-UZPBDJ37.js";
+} from "./chunk-5OY6ED2Q.js";
 
 // src/onboard.ts
 function reportRegistered() {
@@ -123,9 +123,6 @@ Paired! Token saved to ${TOKEN_PATH} (mode 0600).`);
     console.log("Treat this token like a password \u2014 it grants account access. Never log, echo, or commit it.");
     console.log(`  Name   : ${outcome.token.name}`);
     console.log(`  Device : ${outcome.token.device ?? "(none)"}`);
-    if (outcome.sas) {
-      console.log(`  E2EE   : ${outcome.e2ee ? "verified and pinned" : "offered, identity key not yet confirmed on the phone"} (code ${outcome.sas})`);
-    }
     console.log();
     reportRegistered();
     return;

package/dist/slot.js

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