@brutalsystems/muster 3.3.0 → 3.3.1

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/run.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 = [];

package/package.json

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