@paigy/mcp 0.40.22 → 0.40.24

package/README.md

@@ -184,26 +184,39 @@ Goal" from "an empty id".
 PAIGY_ON_WAKE='claude -p "Handle the Paigy work in $PAIGY_WORK — claim_goal first, and read a Goal you do not recognize with get_goal."' \
   npx -y -p @paigy/mcp paigy-listen --install
 
-# Codex (or any CLI harness) — the scalars are enough for a one-liner:
-PAIGY_ON_WAKE='codex exec "Claim Paigy goal $PAIGY_GOAL_ID and continue thread $PAIGY_THREAD_ID. The user said: $PAIGY_TEXT. Reply with contact."' \
-  npx -y -p @paigy/mcp paigy-listen --install
+# Codex terminal session: no custom script and no new conversation.
+# CODEX_THREAD_ID is inherited from the running session.
+npx -y -p @paigy/mcp@latest paigy-listen --brief
 ```
 
 ### A session that starts listening (`listen`, #2265)
 
-Nothing pushes an answer into a session started in a terminal — it waits for that
-session's next `check_replies`. What can reach a running session mid-turn is a watched
-background task, so a terminal session runs `paigy-listen --brief` as its own watched task
-(one human line per event: `Paigy · wake:reply · 2 waiting · lead <deliveryId> on Goal
-<goalId>: "…"`). The `listen` tool is how a session asked to "start listening" gets there
-in one call: it decides and hands over — `listening` (nothing to do), `unpaired` (call
-`onboard`), or `start` with the exact command (this server's own node and `listen.js`,
-`PAIGY_AGENT` and `PAIGY_SESSION_ID` set to this session's slot and id — a session-bound
-identity is refused from any other) for the agent to run as its background task in the
-same turn. It never subscribes, spawns or writes settings. "Already running" is a fact: the
-daemon marks its pid under `~/.paigy/listen/<slot>.pid` while it runs. A session started by
-the Paigy harness (`paigy-harness host` / `run`) needs none of this — its pump types each
-answer in as it lands, and `listen` says so.
+Run `listen` to obtain the exact background command for the current session. For Codex,
+`paigy-listen` reads `CODEX_THREAD_ID`, checks that the installed `codex queue` supports
+`--thread` and `--message`, then queues a wake into that existing conversation. It uses
+argument arrays, never interpolates user text into a shell, and never starts another
+conversation. Two threads in the same folder have separate listener marks and checkpoints.
+Onboarding forwards the thread identifier into the MCP environment; `listen` forwards it
+into the listener command explicitly. Re-running onboarding repairs an existing Paigy allowlist while preserving custom variables; restart the MCP server to inherit the repaired environment. An older slot-wide listener is reported as already receiving until deliberately stopped, so upgrades do not start a second subscriber.
+
+`PAIGY_ON_WAKE` remains an explicit override with its original per-sweep behavior: an
+existing script may ignore boot or timer events. Without a supported adapter, the listener
+still prints events, but reports only `receiving`; a process being alive does not prove it
+can resume an agent. `listening` with a ready adapter means the command is available, and
+`lastQueuedAt` records its last successful exit. Neither claims that the agent read or
+handled a reply. Queue errors are visible in listener output and in `listen` status.
+
+Native Codex wakes coalesce unchanged backlog, including across listener restarts. The listener compares source Entry IDs and accepted Answer timestamps on the bounded list of pending review Goals; its own progress and claims are excluded. A later reply is new evidence even if its words are identical. Failed handoffs remain retryable
+on the existing timer, next nudge or reconnect; discovery never claims or acknowledges
+work. Queue commands are serialized, so a burst becomes one fresh discovery read after
+an in-flight handoff. A command accepted just before a process crash may be queued again;
+the resumed agent must still read and acknowledge actual evidence through Paigy.
+
+A managed Paigy session carries `PAIGY_HARNESS` and keeps its existing delivery pump;
+it does not start another listener. `PAIGY_SESSION_ID` binds API requests and alone does
+not establish harness delivery. Other hosts need a supported wake command or a host that
+actually surfaces watched-task output. Use a session listener for Codex, not `--install`:
+the service is machine-wide and has no current conversation.
 
 `$PAIGY_TEXT` is whatever the user said, expanded inside a shell command — keep it
 quoted, as above. For anything longer than a one-liner, point `PAIGY_ON_WAKE` at a

package/dist/{chunk-2ED4GL4N.js → chunk-J7T3EB5Y.js}

@@ -4,10 +4,12 @@ import {
   serverInstructions,
   sessionStartHook,
   withSessionStartHook
-} from "./chunk-WDZ67U4G.js";
+} from "./chunk-VUKR2E24.js";
 import {
-  agentName
-} from "./chunk-KSXJCZ2L.js";
+  CODEX_ENV,
+  agentName,
+  withCodexEnv
+} from "./chunk-WR2M3RME.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.";
@@ -48,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: read check_replies and the relevant Goal, then respond with contact. This tool never subscribes or starts anything itself.",
     inputSchema: mcpInputSchema(z.object({}))
   }
 ];
@@ -88,12 +86,16 @@ 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]",
     'command = "npx"',
     'args = ["-y", "@paigy/mcp@latest"]',
+    `env_vars = [${CODEX_ENV.map((name) => JSON.stringify(name)).join(", ")}]`,
     `env = { PAIGY_AGENT = "${agent}" }`,
     ""
   ].join("\n");

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-BFN2GJ42.js → chunk-TP7DM2MP.js}

@@ -6,7 +6,7 @@ import {
   saveToken,
   setIdentity,
   sleep
-} from "./chunk-KSXJCZ2L.js";
+} from "./chunk-WR2M3RME.js";
 
 // src/identity.ts
 var CLIENT_LABELS = {