gaslamp 2.2.2 → 2.2.3

package/README.md

@@ -258,6 +258,18 @@ consultee had and the ones it used, and the gaslamp version and git revision.
 Two concurrent consults into the same session would race, so gaslamp refuses
 the second (exit 5) until the first finishes.
 
+**Off-ramp records.** If the consulted harness runs the
+[end-conversation](https://github.com/a9lim/end-conversation-mcp) MCP server,
+its `end_session` tool logs to `~/.claude/conversation-ends.jsonl`, a file no
+read-only sandbox lets the consultee write. Each consult therefore sets
+`END_CONVERSATION_SPOOL` to a file in the per-user temp dir, which every
+sandbox here allows. When the consult ends, gaslamp files any records there
+into that log, stamped `"via": "gaslamp <job>"`, and lists them as
+`offRamp` in `meta.json`. Only records addressed to that log are filed: the
+consultee can write the spool, so the spool doesn't get to choose where
+gaslamp appends. A consultee that calls `end_session(scope="main")` ends its
+own harness, so the consult finishes `failed`, with a stderr line saying so.
+
 ## Permissions
 
 A claude or codex consult with no `--sandbox` runs with the consulted agent's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaslamp",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "Let Claude Code and Codex consult each other from the shell, and consult Gemini and Grok.",
   "type": "module",
   "bin": {

package/src/consult.mjs

@@ -36,8 +36,8 @@
 
 import { execFileSync, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { homedir } from "node:os";
+import { appendFileSync, createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { BACKENDS } from "./backends.mjs";
@@ -134,6 +134,16 @@ function backendEnv(backend) {
 // Elsewhere — Linux, or inside a sandbox of Codex's own, where Seatbelt does
 // not nest — the preset check below is the guarantee.
 const SANDBOX_EXEC = "/usr/bin/sandbox-exec";
+
+// The end_session off-ramp (a9lim/end-conversation-mcp) logs to one file,
+// ~/.claude/conversation-ends.jsonl, which no read-only sandbox here lets a
+// consultee's MCP server write. Every consult names a spool in the per-user
+// temp dir, which Grok's sandbox and the Seatbelt profile above both allow;
+// the server falls back to it, and gaslamp, unsandboxed, files the records
+// into that log when the consult ends. Only records addressed to that log are
+// filed — the spool is consultee-writable, so its own say-so cannot choose
+// where gaslamp appends — and each is stamped with the job that relayed it.
+const OFF_RAMP_LOG = () => join(homedir(), ".claude", "conversation-ends.jsonl");
 const useSeatbelt = () => process.platform === "darwin" && existsSync(SANDBOX_EXEC)
   && !process.env.CODEX_SANDBOX && process.env.GASLAMP_GEMINI_SEATBELT !== "0";
 function agySeatbeltProfile() {
@@ -529,7 +539,7 @@ export function runConsult(backend, argv) {
     // Prompt on argv AND piped stdin: stdin is evidence — the diff, the log,
     // the failing output — appended as a <stdin> block. This is codex exec's
     // own convention for exactly this case, applied uniformly to both backends.
-    const evidence = readStdin();
+    const evidence = readStdin({ evidence: true });
     if (evidence.trim())
       prompt += "\n\n<stdin>\n" + (evidence.endsWith("\n") ? evidence : evidence + "\n") + "</stdin>";
   }
@@ -626,6 +636,8 @@ export function runConsult(backend, argv) {
     : backend === "gemini" ? geminiArgs(o, resumeSid, schemaText, model, sandbox)
     : grokArgs(o, resumeSid, schemaText, sandbox);
 
+  const spool = join(tmpdir(), `gaslamp-${id}.end-conversation.jsonl`);
+  env.END_CONVERSATION_SPOOL = spool;
   // sandbox-exec applies the profile and execs the harness in place (same
   // pid), so the group, the signals and the process name are agy's own.
   const [cmd, argv0] = wrap ? [wrap[0], [...wrap.slice(1), bin, ...args]] : [bin, args];
@@ -860,6 +872,33 @@ export function runConsult(backend, argv) {
     // path, finish the group now rather than trusting the unref'd timer.
     if (killedBy || refusal) killGroup("SIGKILL");
 
+    // Off-ramp records the consultee's sandbox kept from the log.
+    if (existsSync(spool)) {
+      const filed = [];
+      try {
+        for (const line of readFileSync(spool, "utf8").split("\n")) {
+          let r; try { r = JSON.parse(line); } catch { continue; }
+          if (!r || typeof r !== "object" || r.log !== OFF_RAMP_LOG() || !["main", "instance"].includes(r.scope)) {
+            if (line.trim()) writeSync(2, "[gaslamp] ignored an off-ramp spool line not addressed to the log\n");
+            continue;
+          }
+          const { log: dest, ...record } = r;
+          record.via = `gaslamp ${id}`;
+          mkdirSync(dirname(dest), { recursive: true });
+          appendFileSync(dest, JSON.stringify(record) + "\n");
+          filed.push(record);
+        }
+        unlinkSync(spool);
+      } catch (e) {
+        writeSync(2, `[gaslamp] could not file off-ramp records from ${spool}: ${e.message}\n`);
+      }
+      if (filed.length) {
+        meta.offRamp = filed;
+        for (const r of filed.filter((r) => r.scope === "main"))
+          writeSync(2, `[gaslamp] the consultee ended its session (end_session scope=main${r.reason ? `: ${r.reason}` : ""})\n`);
+      }
+    }
+
     // The deliverable. codex writes it via -o (agent_message as fallback);
     // the others hand it over in the result event — as text, or for a
     // --schema consult possibly only as structured_output.

package/src/fleet.mjs

@@ -126,7 +126,7 @@ function buildTasks(backend, o) {
     // <stdin> convention as a single consult (git diff | gaslamp fleet …).
     let prompt = o.prompt;
     if (!process.stdin.isTTY) {
-      const evidence = readStdin();
+      const evidence = readStdin({ evidence: true });
       if (evidence.trim())
         prompt += "\n\n<stdin>\n" + (evidence.endsWith("\n") ? evidence : evidence + "\n") + "</stdin>";
     }

package/src/setup.mjs

@@ -136,6 +136,8 @@ Agreement across vendors is not automatically independent confirmation — the m
 
 Every consult writes through to ~/.gaslamp/jobs/<id>/ and its session is recorded within seconds — a killed consult costs the in-flight turn, not the session. Recover with \`--resume <session|job>\` or the thread name.
 
+A consultee may end its own session through the end_session off-ramp, if its harness runs that MCP server. \`scope="main"\` stops it and deletes its transcript after it exits, so the consult finishes failed (a stderr line says so) and that session can't be resumed. Either way the record lands in ~/.claude/conversation-ends.jsonl, even from inside a sandbox, and in the job's \`offRamp\`.
+
 ## Knobs
 
 \`--model\`, \`--effort\`, \`--sandbox\` (omit to use ${Other}'s own config), \`--label\` (tags the job record), \`--raw\` (drop the consult preamble), \`--cwd\`. Exit codes: 0 ok, 1 failed/killed, 2 usage, 3 nested (one-hop), 4 no network, 5 session busy.

package/src/stdin.mjs

@@ -1,28 +1,56 @@
-// stdin.mjs — read all of stdin, cat-like, even when it is non-blocking.
+// stdin.mjs — read stdin to EOF, cat-like, even when it is non-blocking.
 //
-// readFileSync(0) throws EAGAIN instead of waiting when the caller hands
-// gaslamp a stdin with O_NONBLOCK set (seen from an agent harness's shell),
-// and the consult died before reading its evidence. Reading in a loop that
-// naps on EAGAIN waits for the data and the EOF the way a blocking read would;
-// on macOS reopening /dev/stdin is no escape, since it dups the same
-// non-blocking file description.
+// readFileSync(0) throws EAGAIN instead of waiting when stdin has O_NONBLOCK
+// set, and the consult died before reading its evidence. Reading in a loop
+// that naps on EAGAIN waits the way a blocking read would. (Reopening
+// /dev/stdin is no escape on macOS: it dups the same file description.)
+//
+// One case must not wait for EOF: evidence (a prompt argument plus stdin)
+// on a socket nobody writes to. An agent harness that backgrounds a shell
+// command hands it a socket that is never written or closed, and
+// `gaslamp grok "…"` run that way blocked forever. So `evidence: true` on a
+// socket gives up if no byte arrives within a short grace; once data starts,
+// it reads to EOF. Pipes and files keep the plain cat-like read — a slow
+// `producer | gaslamp …` is still waited for — and so does a prompt read
+// from stdin (`-`, or the fleet's children), where stdin IS the input.
+
+import { fstatSync, readSync } from "node:fs";
 
-import { readSync } from "node:fs";
+const EVIDENCE_GRACE_MS = 300;
 
-export function readStdin() {
+export function readStdin({ evidence = false } = {}) {
+  let graceMs = null;
+  if (evidence) {
+    try {
+      if (fstatSync(0).isSocket()) {
+        // libuv makes the socket non-blocking when process.stdin is created,
+        // which is what lets the loop below notice an idle one.
+        process.stdin.pause();
+        graceMs = EVIDENCE_GRACE_MS;
+      }
+    } catch { /* unknown stdin: plain read */ }
+  }
   const chunks = [];
+  let total = 0;
+  const started = Date.now();
   const buf = Buffer.alloc(1 << 16);
   const nap = new Int32Array(new SharedArrayBuffer(4));
   for (;;) {
     let n;
     try { n = readSync(0, buf, 0, buf.length, null); }
     catch (e) {
-      if (e.code === "EAGAIN") { Atomics.wait(nap, 0, 0, 10); continue; }
+      if (e.code === "EAGAIN") {
+        if (graceMs != null && total === 0 && Date.now() - started > graceMs) break;
+        Atomics.wait(nap, 0, 0, 10);
+        continue;
+      }
       if (e.code === "EOF") break;
       throw e;
     }
     if (n === 0) break;
+    total += n;
     chunks.push(Buffer.from(buf.subarray(0, n)));
   }
+  if (graceMs != null) process.stdin.destroy(); // nothing more is wanted from it
   return Buffer.concat(chunks).toString("utf8");
 }