@paigy/mcp 0.40.23 → 0.40.25

package/dist/chunk-RK5LT7NH.js

@@ -0,0 +1,110 @@
+// src/wake.ts
+import { execFile, spawn } from "child_process";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function wakeTarget(env) {
+  if (env.PAIGY_HARNESS) return { kind: "harness" };
+  if (env.PAIGY_ON_WAKE) return { kind: "command", command: env.PAIGY_ON_WAKE };
+  if (env.CODEX_THREAD_ID) return { kind: "codex", thread: env.CODEX_THREAD_ID };
+  return { kind: "output" };
+}
+function readWakeStatus(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var WakeBridge = class {
+  constructor(env, path) {
+    this.env = env;
+    this.path = path;
+    const target = wakeTarget(env);
+    const saved = readWakeStatus(path);
+    this.state = { ...JSON.stringify(saved?.target) === JSON.stringify(target) ? saved : {}, target, ready: false };
+  }
+  env;
+  path;
+  state;
+  checked = false;
+  status() {
+    return { ...this.state };
+  }
+  save() {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const temp = `${this.path}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(this.state), { mode: 384 });
+    renameSync(temp, this.path);
+  }
+  run(command, args, extra = {}) {
+    return new Promise((resolve, reject) => {
+      execFile(command, args, { env: { ...this.env, ...extra }, timeout: 15e3, maxBuffer: 64 * 1024 }, (error, stdout, stderr) => {
+        if (error) reject(new Error(`${error.message}${stderr ? `: ${stderr.trim()}` : ""}`));
+        else resolve(stdout);
+      });
+    });
+  }
+  launch(command, extra) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("/bin/sh", ["-c", command], { stdio: "inherit", env: { ...this.env, ...extra } });
+      child.once("spawn", resolve);
+      child.once("error", reject);
+      child.once("exit", (code, signal) => {
+        if (code === 0) return;
+        this.state.ready = false;
+        this.state.lastError = `PAIGY_ON_WAKE exited ${signal ?? code}`;
+        this.save();
+        process.stderr.write(`Paigy wake error: ${this.state.lastError}
+`);
+      });
+    });
+  }
+  async prepare() {
+    if (this.checked) return;
+    try {
+      if (this.state.target.kind === "codex") {
+        const help = await this.run("codex", ["queue", "--help"]);
+        if (!help.includes("--thread") || !help.includes("--message")) throw new Error("Installed Codex does not support queue --thread --message; update Codex or configure PAIGY_ON_WAKE.");
+      }
+      this.checked = true;
+      this.state.ready = this.state.target.kind === "codex" || this.state.target.kind === "command" || this.state.target.kind === "harness";
+      delete this.state.lastError;
+      this.save();
+    } catch (error) {
+      this.state.ready = false;
+      this.state.lastError = error.message;
+      this.save();
+      throw error;
+    }
+  }
+  async deliver(fingerprint, message, extra) {
+    await this.prepare();
+    const target = this.state.target;
+    if (target.kind === "output" || target.kind === "harness") return;
+    const fingerprints = fingerprint === void 0 ? void 0 : typeof fingerprint === "string" ? [fingerprint] : fingerprint;
+    if (target.kind === "codex" && fingerprints?.every((item) => this.state.fingerprints?.includes(item))) {
+      this.state.fingerprints = fingerprints;
+      this.save();
+      return;
+    }
+    try {
+      if (target.kind === "codex") await this.run("codex", ["queue", "--thread", target.thread, "--message", message]);
+      else await this.launch(target.command, extra);
+      this.state.fingerprints = fingerprints;
+      if (target.kind === "codex") this.state.lastQueuedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.state.ready = true;
+      delete this.state.lastError;
+      this.save();
+    } catch (error) {
+      this.state.ready = false;
+      this.state.lastError = error.message;
+      this.save();
+      throw error;
+    }
+  }
+};
+
+export {
+  readWakeStatus,
+  WakeBridge
+};

package/dist/{chunk-HKODQKUV.js → chunk-UAVXYNLV.js}

@@ -4,11 +4,12 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-JLRBZZNT.js";
+} from "./chunk-GHSB2VP6.js";
 import {
   CODEX_ENV,
-  agentName
-} from "./chunk-PR7ROBN4.js";
+  agentName,
+  withCodexEnv
+} from "./chunk-EJYXBEWN.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.";
@@ -49,12 +50,8 @@ var IDENTITY_TOOLS = [
     inputSchema: mcpInputSchema(z.object({}))
   },
   {
-    // A session asked to "start listening" can, in one call (#2265). Nothing can push an
-    // answer into a session started in a terminal — an answer waits for its next check_replies —
-    // and the only thing that reaches a running session mid-turn is a watched background task.
-    // So this tool decides and hands over: it never subscribes, spawns or writes settings.
     name: "listen",
-    description: "Am I listening for answers, and if not, how do I start? Call it when the user asks you to start listening (or to stay reachable), and whenever you are unsure whether you are. Takes no arguments. Returns `status`: `listening` \u2014 nothing to do (a session started by the Paigy harness is ALWAYS listening: its pump types each answer in as it lands; or your own paigy-listen is already running, with its pid); `unpaired` \u2014 call onboard first; `start` \u2014 a `command` you MUST run NOW, in this same turn, as a watched BACKGROUND task (your harness's background-task/monitor tool), and leave running for the session. Each line that task prints is a Delivery waiting for you: claim_goal the Goal it names, read it, answer with contact. Start it once. This tool never subscribes or starts anything itself \u2014 the listener has to be YOUR watched task, or its lines reach no one.",
+    description: "Am I listening for answers, and can Paigy resume this session? Takes no arguments. Returns status `listening` for harness delivery or a running listener with a ready wake adapter; `receiving` means a process is running but automatic resume is not confirmed (read its wake error or watch its output); `unpaired` means call onboard; `start` gives the exact command to run NOW as a watched background task for this session. Start it once. Codex queues into CODEX_THREAD_ID automatically when its CLI supports queue; PAIGY_ON_WAKE overrides it. A successful queue is not evidence the agent handled the answer: receive with contact({ wait: false }) and read the relevant Goal, then respond with contact. This tool never subscribes or starts anything itself.",
     inputSchema: mcpInputSchema(z.object({}))
   }
 ];
@@ -89,7 +86,10 @@ function withPaigyMcpJson(existing, agent) {
   return JSON.stringify(config, null, 2);
 }
 function withPaigyMcpToml(existing, agent) {
-  if (existing.includes("[mcp_servers.paigy]")) return null;
+  if (existing.includes("[mcp_servers.paigy]")) {
+    const updated = withCodexEnv(existing);
+    return updated === existing ? null : updated;
+  }
   const entry = [
     "",
     "[mcp_servers.paigy]",

package/dist/{dist-B7AOS5TG.js → dist-NMHU2UNG.js}

@@ -14,14 +14,13 @@ import {
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
+  acknowledge,
   agentName,
   authToken,
-  checkReplies,
   claimGoal,
   claimSessionEnds,
   claimSessions,
   contact,
-  createGoal,
   currentRepo,
   deleteToken,
   dismissTriage,
@@ -34,13 +33,17 @@ import {
   listConnections,
   listNotes,
   listSlots,
+  manageGoals,
   overrideToken,
   parseDue,
+  pendingEvents,
   pollToken,
   reach,
   reachAs,
   readSlot,
   readToken,
+  receive,
+  receiveContact,
   recordDecision,
   registerDelivery,
   repoFromRemote,
@@ -48,8 +51,10 @@ import {
   revokeToken,
   runTool,
   saveToken,
+  searchRecords,
   sessionId,
   sessionSlot,
+  setClient,
   setIdentity,
   sleep,
   slotIdentity,
@@ -59,8 +64,9 @@ import {
   updateGoal,
   updateSlot,
   whoAmI,
-  whoIsWorking
-} from "./chunk-PR7ROBN4.js";
+  whoIsWorking,
+  withCodexEnv
+} from "./chunk-EJYXBEWN.js";
 export {
   AGENT_TOOLS,
   AGENT_TOOL_NAMES,
@@ -77,14 +83,13 @@ export {
   TOKEN_PATH,
   UnpairedError,
   acceptTriage,
+  acknowledge,
   agentName,
   authToken,
-  checkReplies,
   claimGoal,
   claimSessionEnds,
   claimSessions,
   contact,
-  createGoal,
   currentRepo,
   deleteToken,
   dismissTriage,
@@ -97,13 +102,17 @@ export {
   listConnections,
   listNotes,
   listSlots,
+  manageGoals,
   overrideToken,
   parseDue,
+  pendingEvents,
   pollToken,
   reach,
   reachAs,
   readSlot,
   readToken,
+  receive,
+  receiveContact,
   recordDecision,
   registerDelivery,
   repoFromRemote,
@@ -111,8 +120,10 @@ export {
   revokeToken,
   runTool,
   saveToken,
+  searchRecords,
   sessionId,
   sessionSlot,
+  setClient,
   setIdentity,
   sleep,
   slotIdentity,
@@ -122,5 +133,6 @@ export {
   updateGoal,
   updateSlot,
   whoAmI,
-  whoIsWorking
+  whoIsWorking,
+  withCodexEnv
 };

package/dist/enable.js

@@ -3,9 +3,9 @@ import {
   PAIGY_TOOL_IDS,
   enablePaigyTools,
   installSessionListening
-} from "./chunk-HKODQKUV.js";
-import "./chunk-JLRBZZNT.js";
-import "./chunk-PR7ROBN4.js";
+} from "./chunk-UAVXYNLV.js";
+import "./chunk-GHSB2VP6.js";
+import "./chunk-EJYXBEWN.js";
 
 // src/enable.ts
 function main() {

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  readWakeStatus
+} from "./chunk-RK5LT7NH.js";
 import {
   clearPairing,
   identify,
@@ -6,7 +9,7 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BNMMRKEY.js";
+} from "./chunk-2ROD77AW.js";
 import {
   ENABLE_COMMAND,
   OnboardSchema,
@@ -15,11 +18,13 @@ import {
   SERVER_INSTRUCTIONS,
   TOOLS,
   paigyToolsAllowlisted
-} from "./chunk-HKODQKUV.js";
+} from "./chunk-UAVXYNLV.js";
 import {
   decideListen,
-  listenerAlive
-} from "./chunk-JLRBZZNT.js";
+  existingListener,
+  listenerKey,
+  wakeStatusPath
+} from "./chunk-GHSB2VP6.js";
 import {
   clearSurface,
   writeSurface
@@ -37,9 +42,10 @@ import {
   runTool,
   saveToken,
   sessionId,
+  setClient,
   slotName,
   whoAmI
-} from "./chunk-PR7ROBN4.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -49,6 +55,7 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 import qrcode from "qrcode-generator";
 
 // src/survive.ts
@@ -194,8 +201,10 @@ This session isn't on a connected computer, so it asks by code.`;
     }) }
   ] };
 }
+var VERSION = createRequire(import.meta.url)("../package.json").version;
+setClient(`mcp@${VERSION}`);
 var server = new Server(
-  { name: "paigy", version: "0.0.0" },
+  { name: "paigy", version: VERSION },
   {
     capabilities: { tools: {} },
     instructions: SERVER_INSTRUCTIONS
@@ -341,11 +350,13 @@ async function handleTool(request, signal) {
     // daemon is the `listen.js` beside our own entry, so the command never resolves a package.
     case "listen": {
       const slot = agentName();
-      const pid = listenerAlive(slot);
+      const key = listenerKey(slot, process.env);
+      const pid = existingListener(slot, process.env);
       const decision = decideListen({
         env: process.env,
         token: !!readToken(),
         pidAlive: pid !== null,
+        wake: readWakeStatus(wakeStatusPath(key)),
         ...pid !== null ? { pid } : {},
         execPath: process.execPath,
         listenJs: fileURLToPath(new URL("./listen.js", import.meta.url)),

package/dist/listen.js

@@ -1,20 +1,28 @@
 #!/usr/bin/env node
+import {
+  WakeBridge
+} from "./chunk-RK5LT7NH.js";
 import {
   entryWords,
+  existingListener,
+  harnessDriven,
+  listenerKey,
   removeListenMark,
+  wakeStatusPath,
   writeListenMark
-} from "./chunk-JLRBZZNT.js";
+} from "./chunk-GHSB2VP6.js";
 import {
   agentName,
-  checkReplies,
   contact,
   getGoal,
+  heartbeat,
+  receive,
   slotName,
   subscribeWake
-} from "./chunk-PR7ROBN4.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/listen.ts
-import { spawn } from "child_process";
+import { createHash } from "crypto";
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 
@@ -157,10 +165,11 @@ function launchEnv(waiting, reason, goalId) {
   put("PAIGY_TEXT", saidIn(lead) || ("about" in lead ? lead.about : ""));
   return env;
 }
-async function sweep(reason, goalId) {
+async function sweep(reason, goalId, bridge = new WakeBridge(process.env, wakeStatusPath(listenerKey(agentName(), process.env))), participant) {
   try {
-    const cmd = process.env.PAIGY_ON_WAKE;
-    const { deliveries: rows, stalled, review, assigned } = await checkReplies();
+    void Promise.resolve().then(() => heartbeat(void 0, { listening: true })).catch(() => {
+    });
+    const { deliveries: rows, stalled, review, assigned } = await receive();
     const lead = leadOf(rows, goalId);
     const full = lead ? await contact({ deliveryId: lead.deliveryId }, { waits: false }).then((d) => "sent" in d ? null : d).catch(() => null) : null;
     const deliveries = rows.map((d) => d === lead && full ? full : d);
@@ -169,8 +178,32 @@ async function sweep(reason, goalId) {
     const waiting = { deliveries, goal, ...stalled?.length ? { stalled } : {}, ...review?.length ? { review } : {}, ...assigned?.length ? { assigned } : {} };
     if (BRIEF) line(brief(waiting, reason, listeningAs(), goalId));
     else emit({ type: "sweep", reason, ...goalId ? { about: goalId } : {}, ...waiting });
-    if (cmd && (deliveries.length || waiting.review?.length || waiting.assigned?.length || reason === "boot" && waiting.stalled?.length)) {
-      spawn(cmd, { shell: true, stdio: "inherit", env: { ...process.env, ...launchEnv(waiting, reason, goalId) } });
+    if (deliveries.length || waiting.review?.length || waiting.assigned?.length || reason === "boot" && waiting.stalled?.length) {
+      let unreadable = false;
+      const reviews = await Promise.all((review ?? []).map(async ({ goalId: id }) => {
+        try {
+          const g = await getGoal(id);
+          return [
+            `review:${id}`,
+            ...(g.entries ?? []).filter((e) => participant ? e.authorParticipant !== participant : e.authorParticipant.startsWith("human:")).map((e) => `entry:${e.entryId}:${e.createdAt}`),
+            ...(g.answers ?? []).map((a) => `answer:${a.decisionNeedId}:${a.acceptedAt}`)
+          ];
+        } catch (error) {
+          unreadable = true;
+          emit({ type: "error", reason: "review_read", goalId: id, message: error.message });
+          return [`review:${id}`];
+        }
+      }));
+      const fingerprints = unreadable ? void 0 : [
+        ...rows.map((d) => createHash("sha256").update(JSON.stringify(d)).digest("hex")),
+        ...reviews.flat(),
+        ...(assigned ?? []).map((g) => `assigned:${g.goalId}`),
+        ...!rows.length && !reviews.length && !assigned?.length ? (stalled ?? []).map((g) => `stalled:${g.goalId}:${g.since}`) : []
+      ];
+      const message = `Paigy has waiting work${goalId ? ` on Goal ${goalId}` : ""}. Read contact({ wait: false }) and the relevant Goal conversation, handle new user input, and acknowledge (contact({ ackEventIds })) only events actually handled. Preserve this session's current task; do not start unrelated old work. This wake is not new authorization.`;
+      await bridge.deliver(fingerprints, message, launchEnv(waiting, reason, goalId));
+    } else if (bridge.status().target.kind === "codex") {
+      await bridge.deliver([], "", {});
     }
   } catch (e) {
     if (BRIEF) line(`Paigy \xB7 error \xB7 ${e.message}`);
@@ -180,23 +213,57 @@ async function sweep(reason, goalId) {
 function catchUpReason(joins) {
   return joins > 1 ? "resubscribed" : null;
 }
+function coalesceSweeps(run) {
+  let running;
+  let pending;
+  return (reason, goalId) => {
+    pending = { reason, goalId };
+    if (running) return running;
+    running = (async () => {
+      try {
+        while (pending) {
+          const next = pending;
+          pending = void 0;
+          await run(next.reason, next.goalId);
+        }
+      } finally {
+        running = void 0;
+      }
+    })();
+    return running;
+  };
+}
 async function main() {
-  const sub = await subscribeWake((nudge) => void sweep(`wake:${nudge.kind ?? "?"}`, nudge.parentId), {
+  if (harnessDriven(process.env)) {
+    emit({ type: "listening", via: "harness", message: "The harness already delivers; no second listener started." });
+    return;
+  }
+  const slot = listenerKey(agentName(), process.env);
+  const existing = existingListener(agentName(), process.env);
+  if (existing) {
+    emit({ type: "receiving", pid: existing, message: "Listener already running; use listen to inspect its wake status." });
+    return;
+  }
+  const bridge = new WakeBridge(process.env, wakeStatusPath(slot));
+  await bridge.prepare().catch((error) => emit({ type: "wake_error", message: error.message }));
+  let participant;
+  const requestSweep = coalesceSweeps((reason, goalId) => sweep(reason, goalId, bridge, participant));
+  const sub = await subscribeWake((nudge) => void requestSweep(`wake:${nudge.kind ?? "?"}`, nudge.parentId), {
     release: RELEASE,
     onJoined: (joins) => {
       const reason = catchUpReason(joins);
-      if (reason) void sweep(reason);
+      if (reason) void requestSweep(reason);
     }
   });
-  const slot = agentName();
+  participant = `agent:${sub.tokenId}`;
   writeListenMark(slot, process.pid);
   process.on("exit", () => removeListenMark(slot));
-  if (!BRIEF) emit({ type: "listening", channel: sub.channel });
-  await sweep("boot");
-  const heartbeat = setInterval(() => void sweep("timer"), SWEEP_EVERY_MS);
-  heartbeat.unref?.();
+  if (!BRIEF) emit({ type: "listening", channel: sub.channel, wake: bridge.status() });
+  await requestSweep("boot");
+  const heartbeat2 = setInterval(() => void requestSweep("timer"), SWEEP_EVERY_MS);
+  heartbeat2.unref?.();
   const shutdown = async () => {
-    clearInterval(heartbeat);
+    clearInterval(heartbeat2);
     removeListenMark(slot);
     await sub.close();
     process.exit(0);
@@ -231,6 +298,7 @@ export {
   SWEEP_EVERY_MS,
   brief,
   catchUpReason,
+  coalesceSweeps,
   launchEnv,
   leadOf,
   listenOptions,

package/dist/onboard.js

@@ -3,13 +3,13 @@ import {
   resolvePairing,
   startPairing,
   suggestedAgentName
-} from "./chunk-BNMMRKEY.js";
+} from "./chunk-2ROD77AW.js";
 import {
   autoConfigureClients,
   claudeInstallHint,
   openBrowser
-} from "./chunk-HKODQKUV.js";
-import "./chunk-JLRBZZNT.js";
+} from "./chunk-UAVXYNLV.js";
+import "./chunk-GHSB2VP6.js";
 import {
   TOKEN_PATH,
   agentName,
@@ -20,7 +20,7 @@ import {
   saveToken,
   setIdentity,
   whoAmI
-} from "./chunk-PR7ROBN4.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/onboard.ts
 function reportRegistered() {

package/dist/slot.js

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

package/dist/stalled.js

@@ -15,7 +15,7 @@ function stopReply(stalled, event = "Stop") {
   if (!stalled.length) return null;
   const list = stalled.slice(0, 8).map((g) => `"${g.title}" (${g.goalId})`).join(", ");
   const more = stalled.length > 8 ? ` and ${stalled.length - 8} more` : "";
-  const reason = `Before you stop: ${stalled.length} of your Paigy Goals have had no progress for 3 days: ${list}${more}. For each, update_goal with progress, finish it, or cancel it.`;
+  const reason = `Before you stop: ${stalled.length} of your Paigy Goals have had no progress for 3 days: ${list}${more}. For each, update_goal with progress, or finish or cancel it with manage_goals.`;
   return event === "AfterAgent" ? { decision: "block", reason, systemMessage: reason } : { decision: "block", reason };
 }
 async function main() {
@@ -29,8 +29,8 @@ async function main() {
   const dir = join(homedir(), ".paigy", "stalled-reminded");
   const mark = join(dir, `${session || "session"}-${day}`);
   if (existsSync(mark)) return;
-  const { checkReplies } = await import("./dist-B7AOS5TG.js");
-  const reply = stopReply((await checkReplies()).stalled ?? [], input.hook_event_name ?? "Stop");
+  const { receive } = await import("./dist-NMHU2UNG.js");
+  const reply = stopReply((await receive()).stalled ?? [], input.hook_event_name ?? "Stop");
   if (!reply) return;
   mkdirSync(dir, { recursive: true });
   writeFileSync(mark, "");

package/dist/statusline.js

@@ -7,7 +7,7 @@ import {
   readToken,
   sessionSlot,
   slotName
-} from "./chunk-PR7ROBN4.js";
+} from "./chunk-EJYXBEWN.js";
 
 // src/statusline.ts
 import { realpathSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paigy/mcp",
-  "version": "0.40.23",
+  "version": "0.40.25",
   "description": "Paigy MCP server — the AI agent harness that calls you. Lets an agent notify a user and await their reply.",
   "license": "MIT",
   "type": "module",