@paigy/mcp 0.16.0 → 0.17.0

package/README.md

@@ -112,6 +112,30 @@ Then pair: `npx -p @paigy/mcp@latest paigy-mcp-onboard`.
   ignored), and `paigy-listen`'s realtime wake channel is a websocket that doesn't
   proxy — its REST sweeps 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).
+
+To launch an agent — any agent, not just Claude — when work arrives, set
+`PAIGY_ON_WAKE` to a command before `--install`. The daemon runs it with the swept
+work in `$PAIGY_WORK` (JSON: `replies`, `requests`, `owedCallbacks`); the sweep has
+already claimed the work, so read `$PAIGY_WORK` rather than calling `check_replies`
+again. A request carrying a `contextThreadId` (or an unfamiliar `threadId`) means
+the user is resuming/seeding a past conversation — rehydrate with `get_thread` first.
+
+```sh
+# Claude Code:
+PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — rehydrate threads you do not recognize via get_thread first."' \
+  npx -y -p @paigy/mcp paigy-listen --install
+
+# Codex (or any CLI harness) works the same way:
+PAIGY_ON_WAKE='codex exec "Handle the Paigy work in $PAIGY_WORK ..."' \
+  npx -y -p @paigy/mcp paigy-listen --install
+```
+
 ## Statusline (Claude Code)
 
 `paigy-statusline` prints a one-line connection status — the account's session
@@ -124,7 +148,7 @@ paigy: all calls · phone ✓
 Enable it in `~/.claude/settings.json`:
 
 ```json
-"statusLine": { "type": "command", "command": "npx -y @paigy/mcp@latest paigy-statusline" }
+"statusLine": { "type": "command", "command": "npx -y -p @paigy/mcp@latest paigy-statusline" }
 ```
 
 It reads `GET /api/status` with the pairing token and caches the result in

package/dist/{chunk-R3YGSGPX.js → chunk-4LQAS5ZB.js}

@@ -2504,7 +2504,15 @@ var PendingRepliesSchema = z.object({
    *  notify_user on the same threadId. Keeps reappearing until you call
    *  set_task_state on its notificationId. */
   requests: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), text: z.string(), createdAt: z.string() })
+    z.object({
+      threadId: z.string(),
+      notificationId: z.string(),
+      text: z.string(),
+      createdAt: z.string(),
+      /** The user seeded this request with a past conversation — call get_thread on it
+       *  FIRST and treat the transcript as prior context (#57/#251). */
+      contextThreadId: z.string().optional()
+    })
   ),
   /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
    *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
@@ -2540,8 +2548,13 @@ var UserResponseSchema = z.object({
   /** Coverage report (#396): which of the ask's declared `points` were addressed. */
   covered: z.array(z.string()).optional()
 });
+var VoiceKeySchema = z.enum(["rachel", "george", "jessica", "brian", "lily"]);
 var InboxItemSchema = z.object({
   id: z.string(),
+  /** The conversation thread + connection this item lives on. Present on the replied
+   *  detail — they power History's "Continue" / "New session from this" (#57/#251). */
+  threadId: z.string().optional(),
+  tokenId: z.string().optional(),
   status: NotifyStatusSchema,
   context: ContextSchema,
   options: z.array(OptionSchema).optional(),
@@ -2556,6 +2569,8 @@ var InboxItemSchema = z.object({
   visuals: z.array(VisualSchema).optional(),
   agent: z.string(),
   nickname: z.string(),
+  /** The pairing's assigned voice (#462); absent = the default voice. */
+  voice: VoiceKeySchema.optional(),
   repo: z.string().optional(),
   branch: z.string().optional(),
   createdAt: z.string().datetime(),
@@ -2675,6 +2690,8 @@ var ConnectionSummarySchema = z.object({
   agent: z.string(),
   device: z.string().nullable(),
   nickname: z.string(),
+  /** The pairing's assigned voice (#462); null = the default voice. */
+  voice: VoiceKeySchema.nullable(),
   createdAt: z.string().datetime(),
   /** Most recent notification on this connection, either direction. Null = no contact yet.
    *  Drives the agents-page recency grouping (Today / This week / …). */
@@ -2687,7 +2704,14 @@ var CreateRequestSchema = z.object({
   /** The connection (token id) to send to, from GET /api/tokens. */
   tokenId: z.string(),
   /** The user's message to the agent. */
-  text: z.string().min(1)
+  text: z.string().min(1),
+  /** Land the request on an existing conversation thread (History → "Continue")
+   *  instead of minting a fresh one. Must belong to the requesting user. */
+  threadId: z.string().optional(),
+  /** Point the agent at a past conversation (possibly with a different agent) as
+   *  starting context (History → "New session from this"). A reference, not a copy —
+   *  the agent reads it via get_thread. Must belong to the requesting user. */
+  contextThreadId: z.string().optional()
 });
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var RegisterDeliverySchema = z.object({ mode: DeliveryModeSchema });
@@ -3426,6 +3450,13 @@ function landIntents(intents) {
     return due !== null ? { ...i, dueInSeconds: due } : i;
   });
 }
+async function getThread(threadId) {
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/thread/${encodeURIComponent(threadId)}`, {
+    headers: { authorization: `Bearer ${readToken()}` }
+  }));
+  if (!res.ok) throw new Error(`get_thread failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
 async function checkReplies() {
   const token = readToken();
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
@@ -3539,6 +3570,7 @@ export {
   UnpairedError,
   submitNotification,
   awaitReply,
+  getThread,
   checkReplies,
   setTaskState,
   registerDelivery,

package/dist/{chunk-U3WODCOE.js → chunk-ZIOTFQPK.js}

@@ -1,6 +1,6 @@
 import {
   AGENT_NAME
-} from "./chunk-R3YGSGPX.js";
+} from "./chunk-4LQAS5ZB.js";
 
 // src/clients.ts
 import { execFile } from "child_process";

package/dist/index.js

@@ -2,7 +2,7 @@
 import {
   autoConfigureClients,
   claudeInstallHint
-} from "./chunk-U3WODCOE.js";
+} from "./chunk-ZIOTFQPK.js";
 import {
   clearSurface,
   writeSurface
@@ -18,6 +18,7 @@ import {
   deleteToken,
   fetchCredential,
   finalizeE2ee,
+  getThread,
   lintNotify,
   pairStep,
   readKeyFile,
@@ -31,7 +32,7 @@ import {
   sleep,
   startE2ee,
   submitNotification
-} from "./chunk-R3YGSGPX.js";
+} from "./chunk-4LQAS5ZB.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -70,13 +71,16 @@ function json(s) {
 }
 
 // src/index.ts
-var ONBOARD_MSG = "Not paired with Paigy yet \u2014 call the `pair` tool to connect this agent (it returns an approval link to show the user), then retry. Manual fallback: `npx -y @paigy/mcp paigy-mcp-onboard`.";
+var ONBOARD_MSG = "Not paired with Paigy yet \u2014 call the `pair` tool to connect this agent (it returns an approval link to show the user), then retry. Manual fallback: `npx -y -p @paigy/mcp paigy-mcp-onboard`.";
 var AwaitReplySchema = z.object({
   notificationId: z.string().describe("The notificationId returned by notify_user \u2014 waits for the user's reply to THIS notification only.")
 });
 var PairSchema = z.object({
   device_code: z.string().optional().describe("Omit to start pairing (returns an approval link to show the user). Pass the device_code from that first call to finish, once the user has approved.")
 });
+var GetThreadSchema = z.object({
+  threadId: z.string().describe("The thread to read \u2014 from a reply, request, or past notification.")
+});
 var SetTaskStateToolSchema = z.object({
   notificationId: z.string(),
   state: SetTaskStateSchema.shape.state
@@ -121,6 +125,7 @@ function pairedResult(token, sas, note, e2ee) {
     if (hint) base.claude_hint = hint;
   } catch {
   }
+  base.permissions_hint = "Offer the user ONCE: allowlist Paigy's tools so they run without prompting (in Claude Code, add mcp__paigy__notify_user, mcp__paigy__await_reply, mcp__paigy__check_replies, mcp__paigy__set_task_state, mcp__paigy__schedule_callback, mcp__paigy__get_thread to permissions.allow in ~/.claude/settings.json \u2014 or the project's .claude/settings.json if they prefer; other tools have their own allowlist). Merge into the existing file, never clobber it. Leave pair/unpair human-approved. If they decline, drop it.";
   return { content: [{ type: "text", text: JSON.stringify(base) }] };
 }
 function awaitingConfirmResult(sas, device_code) {
@@ -148,7 +153,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 notificationId \u2014 it's scoped to that one notification, so it never returns replies meant for other notifications. 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). On a { kind: 'clarify' } reply, see notify_user's own description for how to respond. 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 reach 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. NEVER go quietly idle while something might still be pending for you: whenever you end a turn with any Paigy notification unanswered (or any chance the user replied through the app while you worked), schedule your own ~2-minute wake-up (harness ScheduleWakeup or equivalent) and call check_replies when it fires; if still nothing, re-schedule and keep looping until resolved or the user says stop. For legibility, always use this exact wording \u2014 reason: 'Paigy idle check \u2014 waiting on <thing>', wake-up prompt: 'Paigy idle check: call check_replies and engage with anything unacknowledged; if idle, re-schedule (~2min).' \u2014 so the user can recognize every idle check at a glance. This self-polling in your own live session (full context intact) is the PRIMARY mechanism; the plugin's Stop hooks are only the dead-session safety net."
+    instructions: "On startup, call check_replies once to pick up any replies or pending work you missed while away. A check_replies request whose threadId you don't recognize, or one carrying a contextThreadId, means the user is resuming or seeding a past conversation \u2014 call get_thread on it FIRST and treat the transcript as prior conversation, not new input. To wait for the answer to something you just asked, call await_reply with that notificationId \u2014 it's scoped to that one notification, so it never returns replies meant for other notifications. 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). On a { kind: 'clarify' } reply, see notify_user's own description for how to respond. 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 reach 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. NEVER go quietly idle while something might still be pending for you: whenever you end a turn with any Paigy notification unanswered (or any chance the user replied through the app while you worked), schedule your own ~2-minute wake-up (harness ScheduleWakeup or equivalent) and call check_replies when it fires; if still nothing, re-schedule and keep looping until resolved or the user says stop. For legibility, always use this exact wording \u2014 reason: 'Paigy idle check \u2014 waiting on <thing>', wake-up prompt: 'Paigy idle check: call check_replies and engage with anything unacknowledged; if idle, re-schedule (~2min).' \u2014 so the user can recognize every idle check at a glance. This self-polling in your own live session (full context intact) is the PRIMARY mechanism; the plugin's Stop hooks are only the dead-session safety net."
   }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -178,6 +183,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
       description: "The catch-up sweep for everything outstanding \u2014 a PURE read, takes no arguments, safe to call as often as you like: nothing here is consumed by reading it. Returns `replies` (answers to notifications you sent), your still-pending notifications, and `requests` \u2014 requests the user started toward you (each { notificationId, threadId, text }). Each keeps reappearing on every call until you actually engage with it: call set_task_state on its notificationId, which is what claims/acknowledges it \u2014 a human-initiated reply or request must never be silently dropped just because you read the list without acting. Use check_replies when booting up / starting a session, or when you've been waiting a long time on something else. To wait on an answer to a notify_user call you just made, use await_reply instead. Also returns owedCallbacks: callbacks now due that you promised \u2014 fulfill each with notify_user on its threadId. Also returns `stalled`: work (either direction) you reported in_progress via set_task_state a while ago and never reported completed \u2014 likely left half-done by this session or a prior one that crashed or went idle. For each, either continue the work and report a real state, or investigate why it stalled. Replies may carry `intents`/`transcript`/`covered` (call-mapped answers) \u2014 handle intents exactly as await_reply's description says (defer \u2192 schedule_callback now; delegate \u2192 decide and say so; channel \u2192 honor next contact), and treat a `covered` list missing one of your declared points as that part still unanswered.",
       inputSchema: json(z.object({}))
     },
+    {
+      name: "get_thread",
+      description: "The chronological transcript of one Paigy conversation thread \u2014 every past ask, answer, and user request on it. Call this to REHYDRATE when you're resuming or being seeded: a check_replies request whose threadId you don't recognize means the user is continuing an old conversation with you, and one carrying a contextThreadId means they want a past conversation (possibly with a DIFFERENT agent) as your starting context \u2014 in both cases call get_thread FIRST and read the turns as prior conversation you were part of, not as new input. Turns: { role:'agent', title, description[], answer } and { role:'user', text }, oldest first, capped at the most recent 30.",
+      inputSchema: json(GetThreadSchema)
+    },
     {
       name: "set_task_state",
       description: "Report progress on the follow-up work behind ANY notification you own \u2014 a user-initiated request (from check_replies), or your OWN notify_user question once await_reply/check_replies returns its answer and you start acting on it. Pass that notificationId. THIS is what actually claims/acknowledges a reply or request \u2014 check_replies is a pure read that never consumes anything on its own, so call this as soon as you start engaging with something it returned; otherwise that same item just keeps reappearing forever. States: in_progress (you started working), completed (done), or needs_input (you need more from the user \u2014 usually paired with a notify_user carrying parentId = the same notificationId you're reporting on). Calling this reliably is also what lets a future session's check_replies surface `stalled` work you (or a crashed/idle prior session) left at in_progress without ever reporting completed.",
@@ -335,6 +345,10 @@ Enter it in the Paigy app (Inbox \u2192 Add a new agent).`,
       const result = await checkReplies();
       return { content: [{ type: "text", text: JSON.stringify(result) }] };
     }
+    case "get_thread": {
+      const { threadId } = GetThreadSchema.parse(request.params.arguments);
+      return { content: [{ type: "text", text: JSON.stringify(await getThread(threadId)) }] };
+    }
     case "set_task_state": {
       const { notificationId, state } = SetTaskStateToolSchema.parse(request.params.arguments);
       const result = await setTaskState(notificationId, state);

package/dist/listen.js

@@ -2,7 +2,7 @@
 import {
   checkReplies,
   registerDelivery
-} from "./chunk-R3YGSGPX.js";
+} from "./chunk-4LQAS5ZB.js";
 
 // src/listen.ts
 import { createClient } from "@supabase/supabase-js";
@@ -227,7 +227,15 @@ var PendingRepliesSchema = z.object({
    *  notify_user on the same threadId. Keeps reappearing until you call
    *  set_task_state on its notificationId. */
   requests: z.array(
-    z.object({ threadId: z.string(), notificationId: z.string(), text: z.string(), createdAt: z.string() })
+    z.object({
+      threadId: z.string(),
+      notificationId: z.string(),
+      text: z.string(),
+      createdAt: z.string(),
+      /** The user seeded this request with a past conversation — call get_thread on it
+       *  FIRST and treat the transcript as prior context (#57/#251). */
+      contextThreadId: z.string().optional()
+    })
   ),
   /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
    *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
@@ -263,8 +271,13 @@ var UserResponseSchema = z.object({
   /** Coverage report (#396): which of the ask's declared `points` were addressed. */
   covered: z.array(z.string()).optional()
 });
+var VoiceKeySchema = z.enum(["rachel", "george", "jessica", "brian", "lily"]);
 var InboxItemSchema = z.object({
   id: z.string(),
+  /** The conversation thread + connection this item lives on. Present on the replied
+   *  detail — they power History's "Continue" / "New session from this" (#57/#251). */
+  threadId: z.string().optional(),
+  tokenId: z.string().optional(),
   status: NotifyStatusSchema,
   context: ContextSchema,
   options: z.array(OptionSchema).optional(),
@@ -279,6 +292,8 @@ var InboxItemSchema = z.object({
   visuals: z.array(VisualSchema).optional(),
   agent: z.string(),
   nickname: z.string(),
+  /** The pairing's assigned voice (#462); absent = the default voice. */
+  voice: VoiceKeySchema.optional(),
   repo: z.string().optional(),
   branch: z.string().optional(),
   createdAt: z.string().datetime(),
@@ -398,6 +413,8 @@ var ConnectionSummarySchema = z.object({
   agent: z.string(),
   device: z.string().nullable(),
   nickname: z.string(),
+  /** The pairing's assigned voice (#462); null = the default voice. */
+  voice: VoiceKeySchema.nullable(),
   createdAt: z.string().datetime(),
   /** Most recent notification on this connection, either direction. Null = no contact yet.
    *  Drives the agents-page recency grouping (Today / This week / …). */
@@ -410,7 +427,14 @@ var CreateRequestSchema = z.object({
   /** The connection (token id) to send to, from GET /api/tokens. */
   tokenId: z.string(),
   /** The user's message to the agent. */
-  text: z.string().min(1)
+  text: z.string().min(1),
+  /** Land the request on an existing conversation thread (History → "Continue")
+   *  instead of minting a fresh one. Must belong to the requesting user. */
+  threadId: z.string().optional(),
+  /** Point the agent at a past conversation (possibly with a different agent) as
+   *  starting context (History → "New session from this"). A reference, not a copy —
+   *  the agent reads it via get_thread. Must belong to the requesting user. */
+  contextThreadId: z.string().optional()
 });
 var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
 var WAKE_EVENT = "wake";
@@ -552,6 +576,103 @@ var SupportRequestSchema = z.object({
   name: z.string().trim().max(120).optional()
 });
 
+// src/service.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, unlinkSync, writeFileSync } from "fs";
+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"];
+  return Object.fromEntries(keys.flatMap((k) => process.env[k] ? [[k, process.env[k]]] : []));
+}
+function renderLaunchd(nodePath, scriptPath, env) {
+  const envXml = Object.entries(env).map(([k, v]) => `    <key>${k}</key><string>${v}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${join(homedir(), ".paigy", "listen.log")}</string>
+  <key>StandardErrorPath</key><string>${join(homedir(), ".paigy", "listen.log")}</string>
+${envXml ? `  <key>EnvironmentVariables</key>
+  <dict>
+${envXml}
+  </dict>
+` : ""}</dict>
+</plist>
+`;
+}
+function renderSystemd(nodePath, scriptPath, env) {
+  const envLines = Object.entries(env).map(([k, v]) => `Environment=${k}=${v}`).join("\n");
+  return `[Unit]
+Description=Paigy listen \u2014 self-hosted push daemon
+
+[Service]
+ExecStart=${nodePath} ${scriptPath}
+Restart=always
+RestartSec=30
+${envLines}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function paths() {
+  const darwin = process.platform === "darwin";
+  return {
+    darwin,
+    unit: darwin ? join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`) : join(homedir(), ".config", "systemd", "user", "paigy-listen.service")
+  };
+}
+function installService(nodePath, scriptPath) {
+  const { unit, darwin } = paths();
+  mkdirSync(join(unit, ".."), { recursive: true });
+  mkdirSync(join(homedir(), ".paigy"), { recursive: true });
+  writeFileSync(
+    unit,
+    darwin ? renderLaunchd(nodePath, scriptPath, frozenEnv()) : renderSystemd(nodePath, scriptPath, frozenEnv())
+  );
+  if (darwin) {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}`, unit], { stdio: "ignore" });
+    } catch {
+    }
+    execFileSync("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, unit], { stdio: "ignore" });
+  } else {
+    execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+    execFileSync("systemctl", ["--user", "enable", "--now", "paigy-listen"], { stdio: "ignore" });
+  }
+  return unit;
+}
+function uninstallService() {
+  const { unit, darwin } = paths();
+  if (darwin) {
+    try {
+      execFileSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}`, unit], { stdio: "ignore" });
+    } catch {
+    }
+  } else {
+    try {
+      execFileSync("systemctl", ["--user", "disable", "--now", "paigy-listen"], { stdio: "ignore" });
+    } catch {
+    }
+  }
+  try {
+    unlinkSync(unit);
+  } catch {
+  }
+  return unit;
+}
+
 // src/listen.ts
 var emit = (obj) => void process.stdout.write(JSON.stringify(obj) + "\n");
 async function sweep(reason) {
@@ -560,7 +681,7 @@ async function sweep(reason) {
     emit({ type: "sweep", reason, ...work });
     const cmd = process.env.PAIGY_ON_WAKE;
     if (cmd && (work.replies.length > 0 || work.requests.length > 0 || work.owedCallbacks.length > 0)) {
-      spawn(cmd, { shell: true, stdio: "inherit" });
+      spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, PAIGY_WORK: JSON.stringify(work) } });
     }
   } catch (e) {
     emit({ type: "error", reason, message: e.message });
@@ -604,10 +725,17 @@ function isEntry() {
   }
 }
 if (isEntry()) {
-  main().catch((e) => {
-    emit({ type: "fatal", message: e.message });
-    process.exit(1);
-  });
+  if (process.argv.includes("--install")) {
+    const unit = installService(process.execPath, realpathSync(process.argv[1]));
+    emit({ type: "installed", unit });
+  } else if (process.argv.includes("--uninstall")) {
+    emit({ type: "uninstalled", unit: uninstallService() });
+  } else {
+    main().catch((e) => {
+      emit({ type: "fatal", message: e.message });
+      process.exit(1);
+    });
+  }
 }
 export {
   sweep

package/dist/onboard.js

@@ -3,7 +3,7 @@ import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-U3WODCOE.js";
+} from "./chunk-ZIOTFQPK.js";
 import {
   AGENT_NAME,
   TOKEN_PATH,
@@ -11,7 +11,7 @@ import {
   requestCode,
   saveToken,
   sleep
-} from "./chunk-R3YGSGPX.js";
+} from "./chunk-4LQAS5ZB.js";
 
 // src/onboard.ts
 async function main() {

package/dist/statusline.js

@@ -6,7 +6,7 @@ import {
   BACKEND_URL,
   reach,
   readToken
-} from "./chunk-R3YGSGPX.js";
+} from "./chunk-4LQAS5ZB.js";
 
 // src/statusline.ts
 import { mkdirSync, readFileSync, realpathSync, writeFileSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.16.0",
+  "version": "0.17.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",
@@ -22,6 +22,13 @@
     "url": "git+https://github.com/mauurda/paigy.git",
     "directory": "apps/mcp"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm --filter @paigy/schema build && pnpm --filter @paigy/crypto build && pnpm --filter @paigy/sdk build && pnpm build"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
     "@supabase/supabase-js": "^2.47.10",
@@ -31,19 +38,13 @@
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@paigy/crypto": "workspace:*",
+    "@paigy/schema": "workspace:*",
+    "@paigy/sdk": "workspace:*",
     "@types/node": "^22.0.0",
     "@types/qrcode-generator": "^1.0.6",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8",
-    "@paigy/schema": "0.0.0",
-    "@paigy/crypto": "0.0.0",
-    "@paigy/sdk": "0.1.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "vitest": "^2.1.8"
   }
 }