@paigy/mcp 0.8.4 → 0.9.0

package/README.md

@@ -92,16 +92,37 @@ Then pair: `npx -p @paigy/mcp@latest paigy-mcp-onboard`.
 
 ## Tools
 
-- **`notify_user`** — notify the user (context: title + description chunks, plus optional options — each an answerable choice that can carry a sandboxed `html` or `image` preview for visual "pick one" decisions — visuals, `urgency`, and `parentId` for a clarification). Returns a request id + thread id. If a reply comes back as `{kind:'clarify', chunks:[...]}`, respond via notify_user with the SAME threadId and an expanded description.
-- **`await_reply`** — wait for the user's reply to a specific notification (pass its id). Scoped: will not return replies meant for other notifications. Returns `reply` / `remind` / `idle`.
+- **`notify_user`** — notify the user (context: title + description chunks; a required `select` answer shape — `one`/`many`/`rank` take `options`, `confirm`/`text` don't; plus `visuals`, `urgency`, and `parentId` for a clarification). Options carry no ids — the backend assigns them by position ("1", "2", …) and answers reference those; each option can carry a sandboxed `html` or `image` preview for visual "pick one" decisions. Returns `{ notificationId, threadId }`. If a reply comes back as `{kind:'clarify', chunks:[...]}`, respond via notify_user with the SAME threadId and an expanded description.
+- **`await_reply`** — wait for the user's reply to a specific notification (pass its notificationId). Scoped: will not return replies meant for other notifications. Returns `reply` / `remind` / `idle`.
 - **`check_replies`** — catch-up sweep: returns replies you haven't consumed yet (now marked seen) plus still-pending notifications.
-- **`poll_answer`** — fetch the answer to a specific request by id.
+- **`poll_answer`** — fetch the answer to a specific notification by notificationId.
 - **`set_task_state`** — report progress on a request: `in_progress` / `completed` / `needs_input`.
 
 ## Configuration
 
 - `PAIGY_BACKEND_URL` — the Paigy API base (defaults to the hosted backend).
 
+## Statusline (Claude Code)
+
+`paigy-statusline` prints a one-line connection status — the account's session
+mode and whether a phone is paired — for Claude Code's status bar:
+
+```
+paigy: all calls · phone ✓
+```
+
+Enable it in `~/.claude/settings.json`:
+
+```json
+"statusLine": { "type": "command", "command": "npx -y @paigy/mcp@latest paigy-statusline" }
+```
+
+It reads `GET /api/status` with the pairing token and caches the result in
+`~/.paigy/status.json` for 60 seconds, so the bar's constant refreshes never
+hammer the API; when offline it shows the last known state. `paigy: unpaired`
+means there's no token (or the pairing was revoked) — run `/paigy-onboard` to
+pair; `paigy: …` means the status isn't known yet (first run while offline).
+
 ## Publishing (maintainers)
 
 Tool input schemas are generated from zod in `src/schema.ts` as draft-2020-12 JSON

package/dist/{chunk-SLK7NHHQ.js → chunk-L6IEPZCY.js}

@@ -25,32 +25,38 @@ var VisualSchema = z.object({
   url: z.string().url(),
   label: z.string().optional()
 });
-var AgentSchema = z.object({
-  name: z.string()
-});
 var NotifyLevelSchema = z.enum(["inbox", "push", "banner", "call"]);
 var NotifyRequestSchema = z.object({
   context: ContextSchema,
-  options: z.array(OptionSchema).optional(),
-  visuals: z.array(VisualSchema).optional(),
-  agent: AgentSchema,
-  /** Git repo the agent is working in ("owner/name"), when applicable. */
+  options: z.array(OptionSchema.omit({ id: true })).min(1).optional().describe(
+    "The choices, in order \u2014 required when select is 'one'/'many'/'rank', omitted otherwise. Ids are assigned automatically by position ('1', '2', \u2026); the user's answer references them as optionId(s)."
+  ),
+  visuals: z.array(VisualSchema).optional().describe(
+    "Images attached to the message itself \u2014 context for the whole question (a screenshot, a chart). For a preview on one selectable choice, use that option's `html`/`image` instead."
+  ),
+  /** Git repo the agent is working in ("owner/name"). Local MCP fills this from the checkout — omit unless overriding. */
   repo: z.string().optional(),
-  /** Git branch the agent is on, when applicable. */
+  /** Git branch the agent is on. Local MCP fills this from the checkout — omit unless overriding. */
   branch: z.string().optional(),
   /** Continue an existing conversation; omitted = start a new thread. */
   threadId: z.string().uuid().optional(),
-  createdAt: z.string().datetime(),
   urgency: NotifyLevelSchema.default("inbox").describe(
     "The level you're requesting \u2014 the user's account permissions + session mode can lower it. 'inbox' (default) = sits silently in the inbox for the user to get to. 'push' = a quiet passive push (lands in Notification Center, no sound) \u2014 a gentle heads-up. 'banner' = a time-sensitive banner/lock-screen push with sound (a 'paige') they tap to open \u2014 use when you need them soon-ish but it's not worth ringing them. 'call' = rings the user's phone now (a CallKit voice call) \u2014 use only when you genuinely need them in the moment (blocked and waiting, time-sensitive). context.title is what they see on the banner/ring, so make it specific."
   ),
   /** The request this one was spawned from, for a clarification. */
   parentId: z.string().optional(),
-  /** How the user answers the options: pick one (default), pick several, pick & order, or yes/no confirm. */
-  select: z.enum(["one", "many", "rank", "confirm"]).default("one"),
+  select: z.enum(["one", "many", "rank", "confirm", "text"]).describe(
+    "How the user answers \u2014 required, 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."
+  ),
   confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
     "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
   )
+}).superRefine((r, ctx) => {
+  const needsOptions = r.select === "one" || r.select === "many" || r.select === "rank";
+  if (needsOptions && !r.options?.length)
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' requires options` });
+  if (!needsOptions && r.options?.length)
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' takes no options` });
 });
 var NotifyStatusSchema = z.enum(["pending", "answered", "ignored"]);
 var AgentStateSchema = z.enum(["idle", "in_progress", "completed", "needs_input"]);
@@ -115,7 +121,7 @@ var PendingRepliesSchema = z.object({
   )
 });
 var NotifyResponseSchema = z.object({
-  id: z.string(),
+  notificationId: z.string(),
   status: NotifyStatusSchema,
   createdAt: z.string().datetime(),
   answer: UserAnswerSchema.optional(),
@@ -148,7 +154,7 @@ var InboxItemSchema = z.object({
    *  client may still flag a stall by age. Drives the inbox error badge + Retry. */
   error: z.string().optional(),
   parentId: z.string().optional(),
-  select: z.enum(["one", "many", "rank", "confirm"]).default("one"),
+  select: z.enum(["one", "many", "rank", "confirm", "text"]).default("one"),
   confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
     "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
   ),
@@ -186,7 +192,14 @@ var UserSettingsSchema = z.object({
   autoCallback: z.boolean(),
   /** Opt-in (default false) to using your content to improve Paigy and train models. */
   improveConsent: z.boolean(),
-  missedCall: MissedCallSchema.default("backoff_standard")
+  missedCall: MissedCallSchema.default("backoff_standard"),
+  /** Where voice audio is processed. 'hosted' (default) = Paigy's voice services
+   *  (ElevenLabs TTS, faster-whisper STT, the call bot); 'on_device' = the phone
+   *  synthesizes and transcribes locally — no audio or spoken text leaves it.
+   *  Optional, NOT defaulted: a stale client PATCHing the full settings object
+   *  must not silently reset this privacy choice. Absent = leave unchanged on
+   *  write, 'hosted' on read (see store.ts). */
+  voiceMode: z.enum(["hosted", "on_device"]).optional()
 });
 var HistoryItemSchema = z.object({
   id: z.string(),
@@ -237,6 +250,13 @@ var DeliveryConfigSchema = z.object({
    *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
   realtime: z.object({ url: z.string(), anonKey: z.string() }).nullable()
 });
+var StatusSchema = z.object({
+  agent: z.string(),
+  nickname: z.string(),
+  sessionMode: z.enum(["default", "all_calls", "silent"]),
+  /** A phone is registered for push/ring (any push token on the account). */
+  phone: z.boolean()
+});
 var WakeNudgeSchema = z.object({
   kind: z.enum(["reply", "request", "callback"]),
   notificationId: z.string().optional(),
@@ -336,8 +356,8 @@ async function checkReplies() {
   if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
-async function setTaskState(id, state) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${id}/state`, {
+async function setTaskState(notificationId, state) {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${notificationId}/state`, {
     method: "PATCH",
     headers: { "content-type": "application/json", authorization: `Bearer ${loadToken()}` },
     body: JSON.stringify({ state })
@@ -364,9 +384,9 @@ async function scheduleCallback(req) {
   if (!res.ok) throw new Error(`schedule_callback failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
-async function pollAnswer(id) {
+async function pollAnswer(notificationId) {
   const token = loadToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/poll/${id}`, {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/poll/${notificationId}`, {
     headers: { authorization: `Bearer ${token}` }
   }));
   if (!res.ok) throw new Error(`poll failed: ${res.status} ${await res.text()}`);

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   scheduleCallback,
   setTaskState,
   submitNotification
-} from "./chunk-SLK7NHHQ.js";
+} from "./chunk-L6IEPZCY.js";
 import {
   deleteToken,
   openBrowser,
@@ -61,10 +61,10 @@ function json(s) {
 
 // src/index.ts
 var PollAnswerSchema = z.object({
-  id: z.string().describe("Request id returned by notify_user.")
+  notificationId: z.string().describe("The notificationId returned by notify_user.")
 });
 var AwaitReplySchema = z.object({
-  notificationId: z.string().describe("The id returned by notify_user \u2014 waits for the user's reply to THIS notification only.")
+  notificationId: z.string().describe("The notificationId returned by notify_user \u2014 waits for the user's reply to THIS notification only.")
 });
 var CheckRepliesSchema = z.object({});
 var PairSchema = z.object({
@@ -99,7 +99,7 @@ var server = new Server(
   { name: "paigy", version: "0.0.0" },
   {
     capabilities: { tools: {} },
-    instructions: "On startup, call check_replies once to pick up any replies or pending work you missed while away. To wait for the answer to something you just asked, call await_reply with that notification's id \u2014 it's scoped to that one request, so it never returns replies meant for other requests. Use check_replies again only when re-booting or after waiting a long time on something else. Never end a turn that still needs the user without notify_user + await_reply. When you need a decision or input, MATCH the answer shape to the question \u2014 don't default everything to free text, and don't reflexively make everything yes/no. Pick the best tool for the job: yes/no \u2192 select:'confirm'; approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve'; pick one of several \u2192 options + select:'one'; pick several / a subset \u2192 options + select:'many'; rank or prioritize \u2192 options + select:'rank'. Reserve open-ended free text only for answers that genuinely can't be structured (the user can always add free text on top of any shape). If a reply comes back as { kind: 'clarify', chunks: [...] }, the user wants more detail on those chunks \u2014 respond by calling notify_user again with the SAME threadId and an expanded description covering them. When urgency is 'call', remember the title + description are spoken aloud \u2014 write them short and conversational, and name things instead of using IDs (e.g. 'the pull request about the agents page', not 'PR #235'). When the user asks you to follow up later \u2014 when you're done, if you're blocked, or at a set time \u2014 record it with schedule_callback so you don't drop it if you go idle. If you're about to start a genuinely long-running or blocking piece of work \u2014 one where the user would otherwise sit and wait \u2014 mention ONCE, in passing, that you can text or call them when it's done or if you hit a blocker, instead of them needing to babysit the terminal. Don't offer this for quick tasks, and don't repeat the offer if they've already said yes or no earlier in the conversation. Escalate silence, don't just wait on it: if you notified at a lower urgency (inbox/push/banner) for something that's genuinely blocking real progress, call await_reply up to twice (~5 min each, ~10 min total) \u2014 if it's still idle after that AND the item is genuinely blocking, send a fresh notify_user on the SAME threadId at urgency:'call'. Skip this for anything that isn't truly blocking; a normal question can just sit in the inbox."
+    instructions: "On startup, call check_replies once to pick up any replies or pending work you missed while away. To wait for the answer to something you just asked, call await_reply with that notificationId \u2014 it's scoped to that one request, so it never returns replies meant for other requests. Use check_replies again only when re-booting or after waiting a long time on something else. Never end a turn that still needs the user without notify_user + await_reply. When you need a decision or input, MATCH the answer shape to the question \u2014 don't default everything to free text, and don't reflexively make everything yes/no. Pick the best tool for the job: yes/no \u2192 select:'confirm'; approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve'; pick one of several \u2192 options + select:'one'; pick several / a subset \u2192 options + select:'many'; rank or prioritize \u2192 options + select:'rank'. Reserve select:'text' (free-form reply only) for plain updates and answers that genuinely can't be structured (the user can always add free text on top of any shape). If a reply comes back as { kind: 'clarify', chunks: [...] }, the user wants more detail on those chunks \u2014 respond by calling notify_user again with the SAME threadId and an expanded description covering them. When urgency is 'call', remember the title + description are spoken aloud \u2014 write them short and conversational, and name things instead of using IDs (e.g. 'the pull request about the agents page', not 'PR #235'). When the user asks you to follow up later \u2014 when you're done, if you're blocked, or at a set time \u2014 record it with schedule_callback so you don't drop it if you go idle. If you're about to start a genuinely long-running or blocking piece of work \u2014 one where the user would otherwise sit and wait \u2014 mention ONCE, in passing, that you can text or call them when it's done or if you hit a blocker, instead of them needing to babysit the terminal. Don't offer this for quick tasks, and don't repeat the offer if they've already said yes or no earlier in the conversation. Escalate silence, don't just wait on it: if you notified at a lower urgency (inbox/push/banner) for something that's genuinely blocking real progress, call await_reply up to twice (~5 min each, ~10 min total) \u2014 if it's still idle after that AND the item is genuinely blocking, send a fresh notify_user on the SAME threadId at urgency:'call'. Skip this for anything that isn't truly blocking; a normal question can just sit in the inbox."
   }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -116,17 +116,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: "notify_user",
-      description: "Notify the user via Paigy and get a request id to poll for their answer. Provide context.title (a specific, non-empty one-line headline \u2014 this is what the user sees first, and what shows on the ring for a call) and context.description (an array of standalone, non-empty detail chunks the user can selectively ask you to expand). Set `urgency`: 'inbox' (default) drops it silently in their inbox; 'push' is a quiet passive notification (no sound); 'banner' sends a time-sensitive banner/lock-screen push (a 'paige') they tap to open \u2014 for when you need them soon-ish but not enough to ring them; 'call' rings their phone now as a voice call \u2014 only when you genuinely need them in the moment (blocked/waiting, time-sensitive). ON A CALL, your title + description are READ ALOUD by a voice \u2014 write them to be HEARD, not read: keep it short and conversational, front-load the ask, and refer to things BY NAME, not by ID or code (say 'the pull request about the agents page', not 'PR #235'; 'the login-bug ticket', not 'ABC-1234'). Spell out only what's natural to say out loud. MATCH the answer shape to the question \u2014 pick the best tool for the job, not always yes/no. The user can ALWAYS add free text on top of any shape, so structuring loses nothing. Choose `select`: yes/no \u2192 select:'confirm' \u2192 {kind:'confirm', approved:boolean}. Approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve' \u2192 {kind:'confirm', approved:boolean}. Both are answerable right from the banner. Pick one of several \u2192 options + select:'one' \u2192 {kind:'option', optionId}. Pick several / a subset \u2192 options + select:'many' \u2192 {kind:'multi', optionIds:[...]}. Rank or prioritize \u2192 options + select:'rank', user taps in preferred order \u2192 {kind:'ranked', optionIds:[...]}. For visual choices give each option a sandboxed `html` or an `image` preview (e.g. layout/UI alternatives). Only leave options off (pure free text / voice) when the answer genuinely can't be structured. Plus optional visuals. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail on those chunks \u2014 respond via notify_user with the SAME threadId and an expanded description. Pass `threadId` from a prior notify_user result or an await_reply reply to continue that conversation thread; omit it to start a new one. To follow up on a call (e.g. the user asked you to 'call me back when it's done'), reuse the threadId from that call's reply so it threads as the same conversation.",
+      description: "Notify the user via Paigy. Returns { notificationId, threadId } \u2014 pass notificationId to await_reply/poll_answer for the answer, threadId to notify_user to continue the conversation. Provide context.title (a specific, non-empty one-line headline \u2014 this is what the user sees first, and what shows on the ring for a call) and context.description (an array of standalone, non-empty detail chunks the user can selectively ask you to expand). Set `urgency`: 'inbox' (default) drops it silently in their inbox; 'push' is a quiet passive notification (no sound); 'banner' sends a time-sensitive banner/lock-screen push (a 'paige') they tap to open \u2014 for when you need them soon-ish but not enough to ring them; 'call' rings their phone now as a voice call \u2014 only when you genuinely need them in the moment (blocked/waiting, time-sensitive). ON A CALL, your title + description are READ ALOUD by a voice \u2014 write them to be HEARD, not read: keep it short and conversational, front-load the ask, and refer to things BY NAME, not by ID or code (say 'the pull request about the agents page', not 'PR #235'; 'the login-bug ticket', not 'ABC-1234'). Spell out only what's natural to say out loud. MATCH the answer shape to the question \u2014 `select` is required; pick the best tool for the job, not always yes/no. The user can ALWAYS add free text on top of any shape, so structuring loses nothing. Choose `select`: yes/no \u2192 select:'confirm' \u2192 {kind:'confirm', approved:boolean}. Approve/deny an action \u2192 select:'confirm' + confirmStyle:'approve' \u2192 {kind:'confirm', approved:boolean}. Both are answerable right from the banner. Pick one of several \u2192 options + select:'one' \u2192 {kind:'option', optionId}. Pick several / a subset \u2192 options + select:'many' \u2192 {kind:'multi', optionIds:[...]}. Rank or prioritize \u2192 options + select:'rank', user taps in preferred order \u2192 {kind:'ranked', optionIds:[...]}. Options carry no ids \u2014 they're assigned by position ('1', '2', \u2026), and the answer's optionId(s) are those positions. For visual choices give each option a sandboxed `html` or an `image` preview (e.g. layout/UI alternatives); use `visuals` for images that set context for the whole question. select:'text' = free-form reply only (plain updates, or answers that genuinely can't be structured). If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail on those chunks \u2014 respond via notify_user with the SAME threadId and an expanded description. Pass `threadId` from a prior notify_user result or an await_reply reply to continue that conversation thread; omit it to start a new one. To follow up on a call (e.g. the user asked you to 'call me back when it's done'), reuse the threadId from that call's reply so it threads as the same conversation.",
       inputSchema: json(NotifyRequestSchema)
     },
     {
       name: "poll_answer",
-      description: "Fetch the user's answer to a previous notify_user request. Returns status pending | answered | ignored, with the answer once present. Errors if the id is unknown or expired.",
+      description: "Fetch the user's answer to a previous notify_user request (pass its notificationId). Returns status pending | answered | ignored, with the answer once present. Errors if the notificationId is unknown or expired.",
       inputSchema: json(PollAnswerSchema)
     },
     {
       name: "await_reply",
-      description: "Wait for the user's reply to THE specific notification you sent for the current request (pass its id from notify_user). This is how you wait for your answer in-context. Polls ~5 min; returns { type:'reply', answer } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' }. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications/requests, so concurrent requests don't cross. A CALL answer can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction and any later turns as their follow-up (e.g. the end-of-call 'call me back when it's done / I have a blocking question' reply). If they asked for a callback, re-engage in the SAME thread (notify_user with the reply's threadId) when the task is done or you hit a blocker \u2014 urgency:'call' for a blocker, 'banner'/'push'/'inbox' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing).",
+      description: "Wait for the user's reply to THE specific notification you sent for the current request (pass the notificationId from notify_user). This is how you wait for your answer in-context. Polls ~5 min; returns { type:'reply', answer } when they respond, { type:'remind', remindInSeconds } on snooze (ScheduleWakeup then await_reply again), or { type:'idle' }. Scoped to that one notification \u2014 it NEVER returns replies meant for other notifications/requests, so concurrent requests don't cross. A CALL answer can come back as {kind:'turns', turns:[{prompt,reply}]} \u2014 the ordered log of that call. Read turns[0].reply as the user's main instruction and any later turns as their follow-up (e.g. the end-of-call 'call me back when it's done / I have a blocking question' reply). If they asked for a callback, re-engage in the SAME thread (notify_user with the reply's threadId) when the task is done or you hit a blocker \u2014 urgency:'call' for a blocker, 'banner'/'push'/'inbox' for done. Paigy has no scheduler; the callback is yours to send (use ScheduleWakeup/cron for timing).",
       inputSchema: json(AwaitReplySchema)
     },
     {
@@ -233,8 +233,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
     }
     case "poll_answer": {
-      const { id } = PollAnswerSchema.parse(request.params.arguments);
-      const result = await pollAnswer(id);
+      const { notificationId } = PollAnswerSchema.parse(request.params.arguments);
+      const result = await pollAnswer(notificationId);
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
     }
     case "await_reply": {

package/dist/listen.js

@@ -4,7 +4,7 @@ import {
   checkReplies,
   registerDelivery,
   wakeChannel
-} from "./chunk-SLK7NHHQ.js";
+} from "./chunk-L6IEPZCY.js";
 import "./chunk-GU7C5H6L.js";
 
 // src/listen.ts

package/dist/statusline.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import {
+  readToken
+} from "./chunk-AILC3H3U.js";
+import {
+  BACKEND_URL
+} from "./chunk-GU7C5H6L.js";
+
+// src/statusline.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DIR = join(homedir(), ".paigy");
+var CACHE = join(DIR, "status.json");
+var TTL_MS = 6e4;
+var MODE_LABEL = {
+  default: "default",
+  all_calls: "all calls",
+  silent: "silent"
+};
+function render(status) {
+  if (!status) return "paigy: unpaired";
+  return `paigy: ${MODE_LABEL[status.sessionMode]} \xB7 ${status.phone ? "phone \u2713" : "no phone"}`;
+}
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(CACHE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function fetchStatus(token) {
+  const res = await fetch(`${BACKEND_URL}/api/status`, {
+    headers: { authorization: `Bearer ${token}` },
+    signal: AbortSignal.timeout(2e3)
+    // a statusline must render fast or not at all
+  });
+  if (res.status === 401) return null;
+  if (res.status === 404) {
+    if ((await res.text()).includes("not_found")) return null;
+    throw new Error("status 404");
+  }
+  if (!res.ok) throw new Error(`status ${res.status}`);
+  return await res.json();
+}
+async function main() {
+  const token = readToken();
+  if (!token) return render(null);
+  const cached = readCache();
+  if (cached && Date.now() - cached.at < TTL_MS) return render(cached.status);
+  try {
+    const status = await fetchStatus(token);
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(CACHE, JSON.stringify({ at: Date.now(), status }));
+    return render(status);
+  } catch {
+    return cached ? render(cached.status) : "paigy: \u2026";
+  }
+}
+if (process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/^file:\/\//, ""))) {
+  void main().then((line) => console.log(line));
+}
+export {
+  main,
+  render
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "Paigy MCP server — a voice inbox for your AI agents. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",
@@ -8,7 +8,8 @@
     "mcp": "./dist/index.js",
     "paigy-mcp": "./dist/index.js",
     "paigy-mcp-onboard": "./dist/onboard.js",
-    "paigy-listen": "./dist/listen.js"
+    "paigy-listen": "./dist/listen.js",
+    "paigy-statusline": "./dist/statusline.js"
   },
   "files": [
     "dist"
@@ -35,8 +36,8 @@
     "@paigy/schema": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/onboard.ts src/listen.ts --format esm --clean",
-    "dev": "tsup src/index.ts src/onboard.ts src/listen.ts --format esm --watch",
+    "build": "tsup src/index.ts src/onboard.ts src/listen.ts src/statusline.ts --format esm --clean",
+    "dev": "tsup src/index.ts src/onboard.ts src/listen.ts src/statusline.ts --format esm --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }