commandmate 0.42.0 → 0.42.2

package/dist/server/src/lib/verification/env-clean-gate.js

@@ -17,7 +17,9 @@
  *      counted, and it is the single failure this gate must not reproduce.
  *   2. **Additions and removals are judged asymmetrically.** Everything that
  *      existed at task start must still exist, whoever it belonged to — that is
- *      the pkill (#1739) and `kill-server` (#1624) case. New things are a
+ *      the pkill (#1739) and `kill-server` (#1624) case — with one exception: a
+ *      tmux session the baseline recorded as *another CommandMate server's*
+ *      (#2627), which that server may close whenever it likes. New things are a
  *      violation *unless they are attributable to another worker*, because
  *      parallel delegations legitimately start their own sessions and servers
  *      inside each other's measurement windows — or unless they are the one
@@ -36,6 +38,10 @@ exports.attributeAnchor = attributeAnchor;
 exports.resolveTaskSessionName = resolveTaskSessionName;
 exports.recordTaskSession = recordTaskSession;
 exports.readTaskSession = readTaskSession;
+exports.currentSessionServer = currentSessionServer;
+exports.isOtherServerSession = isOtherServerSession;
+exports.recordOtherServerSessions = recordOtherServerSessions;
+exports.readOtherServerSessions = readOtherServerSessions;
 exports.diffEnvSnapshots = diffEnvSnapshots;
 exports.formatEnvCleanReport = formatEnvCleanReport;
 exports.envCleanNoBaseline = envCleanNoBaseline;
@@ -166,8 +172,12 @@ function resolveTaskSessionName(task) {
     }
 }
 /** A freshly captured baseline, stamped with its task's own agent session. */
-function recordTaskSession(snapshot, task) {
-    return { ...snapshot, taskSession: resolveTaskSessionName(task) };
+function recordTaskSession(snapshot, task, server = currentSessionServer()) {
+    return {
+        ...snapshot,
+        taskSession: resolveTaskSessionName(task),
+        otherServerSessions: recordOtherServerSessions(snapshot, server),
+    };
 }
 /**
  * The session a baseline excuses: its name, `null` when it was recorded as
@@ -180,6 +190,106 @@ function readTaskSession(baseline) {
     const recorded = baseline.taskSession;
     return typeof recorded === 'string' && recorded !== '' ? recorded : null;
 }
+/**
+ * The identity of the server process this module runs in.
+ *
+ * The adoption table is read through `resolveSessionName`, which returns the
+ * adopted legacy name in place of the new-format one — this module may not
+ * reach into `lib/tmux` (#1922).
+ */
+function currentSessionServer() {
+    return {
+        namespace: (0, session_name_1.getActiveSessionNamespace)(),
+        legacyAliasOf: (newName) => {
+            const parsed = (0, session_name_1.parseSessionName)(newName);
+            if (!parsed)
+                return undefined;
+            try {
+                const resolved = (0, session_name_1.resolveSessionName)(parsed.cliToolId, parsed.rest);
+                return resolved !== newName ? resolved : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}
+/**
+ * Whether a session name positively belongs to a CommandMate server other than
+ * `server`.
+ *
+ * False whenever that cannot be shown: this server has no namespace (then every
+ * name could be its own), or the name is not a CommandMate session name at all.
+ */
+function isOtherServerSession(name, server) {
+    if (server.namespace === null)
+        return false;
+    const parsed = (0, session_name_1.parseSessionName)(name);
+    if (!parsed)
+        return false;
+    if (parsed.namespace !== null)
+        return parsed.namespace !== server.namespace;
+    let ownName;
+    try {
+        ownName = (0, session_name_1.resolveNamespacedSessionName)(server.namespace, parsed.cliToolId, parsed.rest);
+    }
+    catch {
+        // A name this server could never have built is not one of its adoptions.
+        return true;
+    }
+    return server.legacyAliasOf(ownName) !== name;
+}
+/**
+ * The baseline's `mcbd-*` sessions that belonged to another CommandMate server
+ * at task creation.
+ *
+ * Recorded then, because only then is it knowable: this server's legacy
+ * adoptions are dropped when their session goes away, so by verification time
+ * a vanished adopted session would look like a stranger's.
+ *
+ * Why this is the line removals are excused on — the design note for #2627:
+ *
+ *   - A removal is a violation because a worker may have killed someone else's
+ *     session (#1624) or server (#1739). A session *of this server* — the
+ *     sibling worktree in #1624, whose name carries this server's namespace —
+ *     stays guarded exactly as before.
+ *   - A session of *another server* is closed by that server's own lifecycle:
+ *     the incident of 2026-09-17 was a global-install server's orchestrate
+ *     finishing issue-107 and moving on to issue-108, with no kill of any kind
+ *     in the three workers' transcripts. This task has no way to tell that
+ *     from a worker's kill, and that server — not this gate — owns the fact.
+ *   - The namespace is the designed marker of "which server" (#2866); nothing
+ *     else here needs this server's database or a guess at the other
+ *     repository's paths.
+ *
+ * Rejected: counting (`one other session gone is fine`) — that is the #1624
+ * shape, a sibling session disappearing while this worktree's stays; ignoring
+ * every `other` removal — that drops #1624 outright; the database's worktree
+ * table — the other server has a different database and the same worktree ids
+ * can exist in both, which is why #2866 exists; timing — the two snapshots do
+ * not say *when* inside the window something went away; the worker's command
+ * log — not recorded in a form the gate reads, and a kill run through a script
+ * would not name the session anyway.
+ *
+ * @returns the names, or null when `server` has no namespace to judge by
+ */
+function recordOtherServerSessions(snapshot, server) {
+    if (server.namespace === null)
+        return null;
+    const sessions = snapshot.probes['tmux-sessions'];
+    if (!sessions || sessions.status !== 'ok')
+        return [];
+    return sessions.entries
+        .map((entry) => entry.key)
+        .filter((name) => isOtherServerSession(name, server));
+}
+/** The recorded other-server sessions of a baseline; empty when none was recorded. */
+function readOtherServerSessions(baseline) {
+    const recorded = baseline.otherServerSessions;
+    if (!Array.isArray(recorded))
+        return new Set();
+    return new Set(recorded.filter((name) => typeof name === 'string'));
+}
 function toChange(entry, owner) {
     return { key: entry.key, detail: entry.detail, owner };
 }
@@ -193,6 +303,7 @@ function toChange(entry, owner) {
  */
 function diffEnvSnapshots(baseline, final, context, options = {}) {
     const taskSession = readTaskSession(baseline);
+    const otherServerSessions = readOtherServerSessions(baseline);
     const ignoredHomeEntries = new Set(options.ignoreHomeEntries ?? []);
     const probes = env_snapshot_1.ENV_PROBE_IDS.map((probeId) => {
         const before = baseline.probes[probeId];
@@ -206,6 +317,7 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
                 ignoredAdded: [],
                 taskSessionAdded: [],
                 removed: [],
+                removedByOtherServer: [],
                 ignoredByConfig: [],
             };
         }
@@ -218,6 +330,7 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
                 ignoredAdded: [],
                 taskSessionAdded: [],
                 removed: [],
+                removedByOtherServer: [],
                 ignoredByConfig: [],
             };
         }
@@ -246,12 +359,29 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
             }
             (owner === 'other' ? ignoredAdded : added).push(toChange(entry, owner));
         }
+        // An excuse for another server's session presumes the tmux server lived
+        // through the task. When nothing from the baseline survived and the task's
+        // own session is gone too, the likeliest story is `kill-server` (#1624), and
+        // every removal is counted.
+        const tmuxServerSurvived = probeId === 'tmux-sessions' &&
+            after.entries.some((entry) => beforeKeys.has(entry.key) || (taskSession !== null && entry.key === taskSession));
         const removed = [];
+        const removedByOtherServer = [];
         for (const entry of before.entries) {
             if (afterKeys.has(entry.key))
                 continue;
             const change = toChange(entry, attributeEntry(probeId, entry, context));
-            (isIgnoredByConfig(entry) ? ignoredByConfig : removed).push(change);
+            if (isIgnoredByConfig(entry)) {
+                ignoredByConfig.push(change);
+            }
+            else if (tmuxServerSurvived &&
+                change.owner !== 'self' &&
+                otherServerSessions.has(entry.key)) {
+                removedByOtherServer.push(change);
+            }
+            else {
+                removed.push(change);
+            }
         }
         return {
             probeId,
@@ -261,6 +391,7 @@ function diffEnvSnapshots(baseline, final, context, options = {}) {
             ignoredAdded,
             taskSessionAdded,
             removed,
+            removedByOtherServer,
             ignoredByConfig,
         };
     });
@@ -318,6 +449,10 @@ function formatTaskSessionChanges(changes) {
  * session is: a verdict that silently discounted an entry would read exactly
  * like one that never saw it.
  */
+/** Removals excused as another CommandMate server's sessions (#2627), one line each. */
+function formatRemovedByOtherServer(changes) {
+    return changes.map((change) => `    · - ${change.key} (ignored: another CommandMate server's session, recorded at task start)`);
+}
 function formatIgnoredByConfig(changes) {
     if (changes.length === 0)
         return [];
@@ -350,6 +485,7 @@ function formatEnvCleanReport(diff) {
                 : '';
             lines.push(`  ${probe.probeId} clean (${label})${excused}`);
             lines.push(...formatTaskSessionChanges(probe.taskSessionAdded));
+            lines.push(...formatRemovedByOtherServer(probe.removedByOtherServer));
             lines.push(...formatIgnoredByConfig(probe.ignoredByConfig));
             continue;
         }
@@ -357,6 +493,7 @@ function formatEnvCleanReport(diff) {
         lines.push(...formatChanges('+', probe.added));
         lines.push(...formatChanges('-', probe.removed));
         lines.push(...formatTaskSessionChanges(probe.taskSessionAdded));
+        lines.push(...formatRemovedByOtherServer(probe.removedByOtherServer));
         lines.push(...formatIgnoredByConfig(probe.ignoredByConfig));
         for (const excused of probe.ignoredAdded) {
             lines.push(`    · ${excused.key} (ignored: belongs to another worktree)`);

package/dist/server/src/lib/verification/env-snapshot.js

@@ -23,6 +23,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENV_SNAPSHOT_RETENTION_MS = exports.ENV_SNAPSHOT_DIR_NAME = exports.VOLATILE_ENTRY_PATTERNS = exports.MCBD_SESSION_PREFIX = exports.COMMANDMATE_PROCESS_PATTERN = exports.DEFAULT_ENV_PROBE_DEPS = exports.ENV_PROBE_LABELS = exports.ENV_PROBE_IDS = exports.ENV_SNAPSHOT_VERSION = void 0;
+exports.isCommandMateCommandLine = isCommandMateCommandLine;
 exports.probeListeners = probeListeners;
 exports.probeTmuxSessions = probeTmuxSessions;
 exports.probeHomeEntries = probeHomeEntries;
@@ -109,8 +110,71 @@ exports.DEFAULT_ENV_PROBE_DEPS = {
  * to "CommandMate 関連" for exactly that reason, so relevance is decided from
  * the owning process's command line rather than from the port number — a
  * developer's `commandmate start --port 3179` is as relevant as port 3000.
+ *
+ * This is only the vocabulary, and a cheap first filter. Matched against the
+ * whole command line it also hits a process that merely *mentions* a
+ * CommandMate path among its arguments — an editor's language server started
+ * with `--workspace_id …_commandmate_issue_2616` was recorded as a CommandMate
+ * listener and then read as "killed" when it exited (#2627). The decision is
+ * {@link isCommandMateCommandLine}'s, which looks only at the program.
  */
 exports.COMMANDMATE_PROCESS_PATTERN = /commandmate|dist\/server\/server\.js|next-server|next (dev|start)|server\.ts/i;
+/**
+ * Executables that run a script named by a later argument. CommandMate is
+ * never a native binary of its own: every shape it runs as is one of these
+ * with a CommandMate script, or a process title set by one of them.
+ */
+const SCRIPT_LAUNCHERS = new Set(['node', 'nodejs', 'bun', 'tsx', 'ts-node', 'npx', 'next']);
+/** Executables that are CommandMate by their own name (process title or bin). */
+const COMMANDMATE_EXECUTABLES = /^(commandmate(\.js)?|next-server)$/i;
+/** A script argument that is CommandMate's server or CLI, judged by its path's end. */
+function isCommandMateScript(token) {
+    const name = (0, path_1.basename)(token);
+    return (/(^|\/)dist\/server\/server\.js$/.test(token) ||
+        name === 'server.ts' ||
+        /^commandmate(\.js)?$/i.test(name));
+}
+/**
+ * Whether a `ps` command line is a CommandMate process (#2627).
+ *
+ * Judged on the program, never on free-form arguments:
+ *
+ *   - the executable itself (`next-server (v14…)`, a `commandmate` bin run
+ *     directly) — its basename, so a directory called `commandmate` in the
+ *     executable's *path* does not count either;
+ *   - or, when the executable is a script launcher (`node`, `tsx`, `next`, …),
+ *     its positional arguments matched as whole paths by their end:
+ *     `…/dist/server/server.js`, `server.ts`, a `commandmate` bin, or `next`
+ *     followed by `dev` / `start`.
+ *
+ * Flags are dropped before matching, `--workspace=/x/commandmate` included,
+ * and a positional counts only as a whole token: `/x/commandmate-issue-1` is a
+ * path that mentions CommandMate, not CommandMate. Any other executable —
+ * `language_server_macos_arm`, Chrome, postgres — is not CommandMate whatever
+ * its arguments say.
+ *
+ * Why not `ps -o comm=` (the executable alone): `node dist/server/server.js` is
+ * `node` there, indistinguishable from every other node process, so the
+ * production server itself would stop being recorded.
+ */
+function isCommandMateCommandLine(commandLine) {
+    if (!exports.COMMANDMATE_PROCESS_PATTERN.test(commandLine))
+        return false;
+    const [program, ...rest] = commandLine.trim().split(/\s+/);
+    if (!program)
+        return false;
+    const name = (0, path_1.basename)(program);
+    if (COMMANDMATE_EXECUTABLES.test(name))
+        return true;
+    if (!SCRIPT_LAUNCHERS.has(name.toLowerCase()))
+        return false;
+    const positionals = [name, ...rest.filter((token) => !token.startsWith('-'))];
+    return positionals.some((token, index) => {
+        if (index > 0 && isCommandMateScript(token))
+            return true;
+        return (0, path_1.basename)(token) === 'next' && /^(dev|start)$/.test(positionals[index + 1] ?? '');
+    });
+}
 /** `ps` line: leading pid, then the full command line. */
 function parseProcessTable(stdout) {
     const table = new Map();
@@ -213,7 +277,7 @@ async function probeListeners(deps) {
     const table = parseProcessTable(processes.stdout);
     const relevant = blocks.filter((block) => {
         const commandLine = table.get(block.pid);
-        return commandLine !== undefined && exports.COMMANDMATE_PROCESS_PATTERN.test(commandLine);
+        return commandLine !== undefined && isCommandMateCommandLine(commandLine);
     });
     if (relevant.length === 0)
         return ok([]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.42.0",
+  "version": "0.42.2",
   "description": "A local control plane for agent CLIs — orchestration and visibility for Claude Code, Codex, Gemini CLI, and more across Git worktrees",
   "keywords": [
     "claude-code",

package/release-notes/0.42.1.json

@@ -0,0 +1,16 @@
+{
+  "version": "0.42.1",
+  "date": "2026-09-28",
+  "highlight": {
+    "ja": "opencode の新しい版で、起動直後に送信できないことがある問題を直しました。",
+    "en": "Sending to a newly started opencode session on recent versions works again."
+  },
+  "added": [],
+  "improved": [],
+  "fixed": [
+    {
+      "ja": "opencode 1.18.31 以降で、起動直後の入力待ちを認識できず送信が拒否されることがある問題を直しました。",
+      "en": "Fixed messages sometimes being refused right after opencode 1.18.31 or later started, because its input prompt was not recognized."
+    }
+  ]
+}

package/release-notes/0.42.2.json

@@ -0,0 +1,20 @@
+{
+  "version": "0.42.2",
+  "date": "2026-09-28",
+  "highlight": {
+    "ja": "ブランチごとに選んだ既定のエージェントが、同期のたびに Claude に戻ってしまう問題を直しました。",
+    "en": "Fixed the default agent chosen for a branch switching back to Claude every time branches were synced."
+  },
+  "added": [],
+  "improved": [],
+  "fixed": [
+    {
+      "ja": "ブランチごとに選んだ既定のエージェントが、同期のたびに Claude に戻ってしまう問題を直しました。",
+      "en": "Fixed the default agent chosen for a branch switching back to Claude every time branches were synced."
+    },
+    {
+      "ja": "commandmate verify でタスクを指定できるようになり、完了済みのタスクを検証し直せるようになりました。",
+      "en": "commandmate verify can now take a task, so a finished task can be verified again."
+    }
+  ]
+}