@brutalsystems/muster 3.3.0 → 3.3.2

package/dist/guard.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import { closeSync, existsSync, openSync, readdirSync, readFileSync, readSync, realpathSync, } from "node:fs";
 import { realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { isAbsolute, join, relative, resolve } from "node:path";
@@ -425,16 +425,24 @@ export function resolveResume(req) {
  *   tincan and the ledger could not say which one a message reaches. A fork
  *   only reads the original, so it may resume a live one.
  */
-export function assertResumable(resume, env, alive = pidAlive) {
+export function assertResumable(resume, env, cwd, alive = pidAlive) {
     const configDir = claudeConfigDir(env);
     const projects = join(configDir, "projects");
-    let found = false;
+    let transcript;
     try {
-        found = readdirSync(projects).some((dir) => existsSync(join(projects, dir, resume.id + ".jsonl")));
+        transcript = readdirSync(projects)
+            .map((dir) => join(projects, dir, resume.id + ".jsonl"))
+            .find((file) => existsSync(file));
     }
     catch { }
-    if (!found)
+    if (!transcript)
         throw new Error(`No Claude conversation ${resume.id} in ${configDir}; --resume reopens a session recorded in the profile this launch runs in`);
+    // Claude 2.1.302 resumes a conversation from any directory, so this is
+    // muster's to refuse (#10): the history would describe one tree while the
+    // agent works in another. Unknown when the transcript names no cwd.
+    const recorded = transcriptCwd(transcript);
+    if (recorded !== undefined && realPath(recorded) !== realPath(cwd))
+        throw new Error(`Claude session ${resume.id} was recorded in ${recorded}, not ${cwd}; resume it with --cwd ${recorded}`);
     if (resume.fork)
         return;
     const sessions = claudeSessionsDir(env);
@@ -458,6 +466,43 @@ export function assertResumable(resume, env, alive = pidAlive) {
             throw new Error(`Claude session ${resume.id} is running (pid ${pid}); stop it before resuming it, or pass --fork-session to continue it under a new id`);
     }
 }
+/** The first `cwd` a transcript records, read from its head: a transcript can
+ *  run to many megabytes, and the cwd is on its first message. */
+function transcriptCwd(file) {
+    let head = "";
+    try {
+        const fd = openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(1 << 20);
+            head = buf.toString("utf8", 0, readSync(fd, buf, 0, buf.length, 0));
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of head.split("\n")) {
+        if (!line.includes('"cwd"'))
+            continue;
+        try {
+            const { cwd } = JSON.parse(line);
+            if (typeof cwd === "string" && cwd)
+                return cwd;
+        }
+        catch { }
+    }
+    return undefined;
+}
+function realPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
 function pidAlive(pid) {
     try {
         process.kill(pid, 0);

package/dist/reap.js

@@ -125,8 +125,10 @@ async function stopSession(home, socket, launchId) {
     });
     try {
         const entry = (await new Registry(home).all()).find((e) => e.launchId === launchId);
+        // By launch id: since --resume, the durable id may name a newer launch of
+        // the same session, which this check was not armed for.
         if (entry)
-            await muster.stop(entry.id);
+            await muster.stop(entry.launchId);
     }
     finally {
         await muster.close();

package/dist/registry.js

@@ -45,6 +45,21 @@ export class IdempotencyKeyReuse extends Error {
  */
 const UNOWNED_LOCK_MS = 60_000;
 let self;
+/** Statuses whose process is over: such an entry no longer holds its id. */
+const FINISHED = ["exited", "failed", "stopped"];
+/**
+ * The entry a durable id names. One id can have several since `--resume`: the
+ * launches that ran a session before, now finished, and the one running it
+ * now. The live one is meant, else the newest; two live ones cannot arise,
+ * because `update` refuses a second live holder of an id.
+ */
+export function currentEntry(entries) {
+    const live = entries.filter((e) => !FINISHED.includes(e.status));
+    if (live.length > 1)
+        throw new Error("Ambiguous durable id; update by launchId");
+    return (live[0] ??
+        [...entries].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0]);
+}
 export class Registry {
     home;
     lockWait;
@@ -300,16 +315,16 @@ export class Registry {
     async update(id, patch) {
         return this.transaction(async (entries) => {
             const byLaunch = entries.find((e) => e.launchId === id);
-            const durable = entries.filter((e) => e.id === id);
-            if (!byLaunch && durable.length > 1)
-                throw new Error("Ambiguous durable id; update by launchId");
-            const entry = byLaunch ?? durable[0];
+            const entry = byLaunch ?? currentEntry(entries.filter((e) => e.id === id));
             if (!entry)
                 throw new Error(`Unknown launch ${id}`);
             if ("requester" in patch)
                 throw new Error("requester is recorded once and cannot be updated");
             if (patch.id &&
-                entries.some((e) => e !== entry && e.runtime === entry.runtime && e.id === patch.id))
+                entries.some((e) => e !== entry &&
+                    e.runtime === entry.runtime &&
+                    e.id === patch.id &&
+                    !FINISHED.includes(e.status)))
                 throw new Error("Durable identity already registered");
             Object.assign(entry, patch);
             return structuredClone(entry);

package/dist/run.js

@@ -11,7 +11,7 @@ import { assertEnforcementMeetsMinimum, assertLevelWithinCeiling, assertMayAct,
 import { IdentityError, readIdentity, } from "./identity-store.js";
 import { resolveCredential } from "./identity-token.js";
 import { copyIdentity, identityEnv } from "./identity-copy.js";
-import { Registry } from "./registry.js";
+import { currentEntry, Registry } from "./registry.js";
 import { LaunchLog } from "./log.js";
 import { hosts, selectHost } from "./hosts/index.js";
 import { AGENTS } from "./agents.js";
@@ -802,6 +802,15 @@ export class Muster {
                         ? await resolveOpenCode(root.pid, entry.server_url, req.cwd, startedAt, deadline, req.prompt)
                         : await resolveClaude(root.pid, resolveEnv, deadline);
                 if (identity) {
+                    // The answer #10 asks for: a resume that registered some other
+                    // session is a launch that failed, never a new session reported as
+                    // the old one. Not fatal at once, like every other diagnosis here,
+                    // in case the registry is read mid-write.
+                    const resume = req.runtime === "claude" ? resolveResume(req) : null;
+                    if (resume && (identity.id === resume.id) === resume.fork)
+                        throw new Error(resume.fork
+                            ? `--fork-session registered the original session ${resume.id} instead of a new one`
+                            : `Claude registered session ${identity.id} instead of resuming ${resume.id}`);
                     diagnostic =
                         req.runtime === "codex"
                             ? "thread id reserved but no rollout"
@@ -923,7 +932,7 @@ export class Muster {
                 throw new Error("--resume is available to a local requester only");
             if (identityName)
                 throw new Error("--resume cannot be combined with an identity: the identity's config dir holds none of this profile's conversations");
-            assertResumable(resume, agentBase);
+            assertResumable(resume, agentBase, effective.cwd);
         }
         let argv = plannedArgv;
         let codexPolicy = [];
@@ -1176,11 +1185,21 @@ export class Muster {
     }
     async find(id) {
         const all = await this.registry.all();
+        // A launch id names exactly one launch, so a caller that holds one (the
+        // reaper) can never reach a later launch of the same resumed session.
+        const launch = all.find((e) => e.launchId === id);
+        if (launch)
+            return launch;
         const exact = all.filter((e) => e.id === id);
         if (exact.length === 1)
             return exact[0];
-        if (exact.length > 1)
-            throw new Error(`Ambiguous durable id: ${exact.map((e) => e.runtime + ":" + e.id).join(", ")}`);
+        // The same session under two runtimes is ambiguous. Under one, it was
+        // resumed: the launch running it now, else the latest, is the one meant.
+        if (exact.length > 1) {
+            if (new Set(exact.map((e) => e.runtime)).size > 1)
+                throw new Error(`Ambiguous durable id: ${exact.map((e) => e.runtime + ":" + e.id).join(", ")}`);
+            return currentEntry(exact);
+        }
         const peers = all.filter((e) => e.kind === "session" && e.status === "running" && e.peer);
         const named = peers.map((e) => ({
             runtime: runtimeName(e.runtime),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Launch instructed, reachable local agent sessions",
   "type": "module",
   "engines": {