arcane-agents 1.2.0 → 1.2.3

package/dist/server/server/status/runtime/runtimeProcess.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAgentRuntimeProcess = findAgentRuntimeProcess;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const maxProcessTreeDepth = 5;
+async function findAgentRuntimeProcess(panePid) {
+    return findAgentRuntimeProcessAtDepth(panePid, 0);
+}
+async function findAgentRuntimeProcessAtDepth(parentPid, depth) {
+    if (depth >= maxProcessTreeDepth) {
+        return undefined;
+    }
+    try {
+        const { stdout } = await execFileAsync("pgrep", ["-P", String(parentPid)], {
+            maxBuffer: 1024 * 16
+        });
+        const childPids = stdout
+            .trim()
+            .split("\n")
+            .map((line) => Number.parseInt(line.trim(), 10))
+            .filter((pid) => Number.isFinite(pid) && pid > 0);
+        for (const childPid of childPids) {
+            const details = await describeProcess(childPid);
+            if (details) {
+                const runtime = classifyAgentRuntime(details.command, details.args);
+                if (runtime) {
+                    return {
+                        pid: childPid,
+                        runtime,
+                        command: details.command,
+                        args: details.args
+                    };
+                }
+            }
+            const nestedMatch = await findAgentRuntimeProcessAtDepth(childPid, depth + 1);
+            if (nestedMatch) {
+                return nestedMatch;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+async function describeProcess(pid) {
+    try {
+        const { stdout } = await execFileAsync("ps", ["-o", "comm=", "-o", "args=", "-p", String(pid)], {
+            maxBuffer: 1024 * 16
+        });
+        const line = stdout.trim();
+        if (!line) {
+            return undefined;
+        }
+        const [command = "", ...argsParts] = line.split(/\s+/);
+        return {
+            command: command.trim(),
+            args: argsParts.join(" ").trim()
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function classifyAgentRuntime(command, args) {
+    const commandLower = command.trim().toLowerCase();
+    const argsLower = args.trim().toLowerCase();
+    const commandAndArgs = `${commandLower} ${argsLower}`.trim();
+    if (commandLower === "claude" ||
+        commandAndArgs.includes("/claude") ||
+        /\bclaude(?:-code)?\b/.test(commandAndArgs)) {
+        return "claude";
+    }
+    if (commandLower === "opencode" || commandAndArgs.includes("opencode")) {
+        return "opencode";
+    }
+    if (commandLower === "codex" ||
+        commandAndArgs.includes("@openai/codex") ||
+        commandAndArgs.includes("/bin/codex") ||
+        /\bcodex\b/.test(commandAndArgs)) {
+        return "codex";
+    }
+    return undefined;
+}

package/dist/server/server/status/runtime/sessionDetection.js

@@ -3,13 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.capturePaneLineCount = capturePaneLineCount;
 exports.isLikelyClaudeSession = isLikelyClaudeSession;
 exports.isLikelyOpenCodeSession = isLikelyOpenCodeSession;
+exports.isLikelyCodexSession = isLikelyCodexSession;
 const defaultCapturePaneLines = 35;
 const claudeCapturePaneLines = 60;
 const openCodeCapturePaneLines = 420;
+const codexCapturePaneLines = 420;
 function capturePaneLineCount(worker, commandLower) {
     if (isLikelyOpenCodeSession(worker, commandLower)) {
         return openCodeCapturePaneLines;
     }
+    if (isLikelyCodexSession(worker, commandLower)) {
+        return codexCapturePaneLines;
+    }
     if (isLikelyClaudeSession(worker, commandLower)) {
         return claudeCapturePaneLines;
     }
@@ -35,3 +40,13 @@ function isLikelyOpenCodeSession(worker, commandLower) {
     }
     return commandLower.includes("opencode");
 }
+function isLikelyCodexSession(worker, commandLower) {
+    if (worker.runtimeId.toLowerCase().includes("codex")) {
+        return true;
+    }
+    const runtimeBinary = worker.command[0]?.toLowerCase() ?? "";
+    if (runtimeBinary.includes("codex")) {
+        return true;
+    }
+    return commandLower.includes("codex");
+}

package/dist/server/server/status/runtimeSignals.js

@@ -1,19 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractRuntimeActivityText = exports.hasWaitingActivityText = exports.hasActiveWorkActivityText = exports.preferOpenCodeSpecificActivityText = exports.hasOpenCodeActiveSignal = exports.hasOpenCodePromptSignal = exports.detectOpenCodeSignals = exports.isGenericClaudeProgressLabel = exports.hasClaudeLiveProgressSignal = exports.extractClaudeActiveTask = exports.isLikelyOpenCodeSession = exports.isLikelyClaudeSession = exports.capturePaneLineCount = void 0;
+exports.extractRuntimeActivityText = exports.hasWaitingActivityText = exports.hasActiveWorkActivityText = exports.hasCodexActiveSignal = exports.hasCodexPromptSignal = exports.detectCodexSignals = exports.preferOpenCodeSpecificActivityText = exports.hasOpenCodeActiveSignal = exports.hasOpenCodePromptSignal = exports.detectOpenCodeSignals = exports.isGenericClaudeProgressLabel = exports.hasClaudePromptSignal = exports.hasClaudeLiveProgressSignal = exports.extractClaudeActiveTask = exports.detectClaudeSignals = exports.isLikelyCodexSession = exports.isLikelyOpenCodeSession = exports.isLikelyClaudeSession = exports.capturePaneLineCount = void 0;
 var sessionDetection_1 = require("./runtime/sessionDetection");
 Object.defineProperty(exports, "capturePaneLineCount", { enumerable: true, get: function () { return sessionDetection_1.capturePaneLineCount; } });
 Object.defineProperty(exports, "isLikelyClaudeSession", { enumerable: true, get: function () { return sessionDetection_1.isLikelyClaudeSession; } });
 Object.defineProperty(exports, "isLikelyOpenCodeSession", { enumerable: true, get: function () { return sessionDetection_1.isLikelyOpenCodeSession; } });
+Object.defineProperty(exports, "isLikelyCodexSession", { enumerable: true, get: function () { return sessionDetection_1.isLikelyCodexSession; } });
 var claudeSignals_1 = require("./runtime/claudeSignals");
+Object.defineProperty(exports, "detectClaudeSignals", { enumerable: true, get: function () { return claudeSignals_1.detectClaudeSignals; } });
 Object.defineProperty(exports, "extractClaudeActiveTask", { enumerable: true, get: function () { return claudeSignals_1.extractClaudeActiveTask; } });
 Object.defineProperty(exports, "hasClaudeLiveProgressSignal", { enumerable: true, get: function () { return claudeSignals_1.hasClaudeLiveProgressSignal; } });
+Object.defineProperty(exports, "hasClaudePromptSignal", { enumerable: true, get: function () { return claudeSignals_1.hasClaudePromptSignal; } });
 Object.defineProperty(exports, "isGenericClaudeProgressLabel", { enumerable: true, get: function () { return claudeSignals_1.isGenericClaudeProgressLabel; } });
 var openCodeSignals_1 = require("./runtime/openCodeSignals");
 Object.defineProperty(exports, "detectOpenCodeSignals", { enumerable: true, get: function () { return openCodeSignals_1.detectOpenCodeSignals; } });
 Object.defineProperty(exports, "hasOpenCodePromptSignal", { enumerable: true, get: function () { return openCodeSignals_1.hasOpenCodePromptSignal; } });
 Object.defineProperty(exports, "hasOpenCodeActiveSignal", { enumerable: true, get: function () { return openCodeSignals_1.hasOpenCodeActiveSignal; } });
 Object.defineProperty(exports, "preferOpenCodeSpecificActivityText", { enumerable: true, get: function () { return openCodeSignals_1.preferOpenCodeSpecificActivityText; } });
+var codexSignals_1 = require("./runtime/codexSignals");
+Object.defineProperty(exports, "detectCodexSignals", { enumerable: true, get: function () { return codexSignals_1.detectCodexSignals; } });
+Object.defineProperty(exports, "hasCodexPromptSignal", { enumerable: true, get: function () { return codexSignals_1.hasCodexPromptSignal; } });
+Object.defineProperty(exports, "hasCodexActiveSignal", { enumerable: true, get: function () { return codexSignals_1.hasCodexActiveSignal; } });
 var textSignals_1 = require("./runtime/textSignals");
 Object.defineProperty(exports, "hasActiveWorkActivityText", { enumerable: true, get: function () { return textSignals_1.hasActiveWorkActivityText; } });
 Object.defineProperty(exports, "hasWaitingActivityText", { enumerable: true, get: function () { return textSignals_1.hasWaitingActivityText; } });

package/dist/server/server/status/statusEvaluator.js

@@ -3,15 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateWorkerStatus = evaluateWorkerStatus;
 const signalContext_1 = require("./engine/signalContext");
 const stateMachine_1 = require("./engine/stateMachine");
-function evaluateWorkerStatus({ worker, currentCommand, output, observation, transcriptSnapshot, interactiveCommands }) {
+function evaluateWorkerStatus({ worker, currentCommand, output, observation, transcriptSnapshot, runtimeProcess, interactiveCommands, runtimeFreshnessWindowMs }) {
     const context = (0, signalContext_1.buildWorkerStatusSignalContext)({
         worker,
         currentCommand,
         output,
         observation,
         transcriptSnapshot,
+        runtimeProcess,
         nowMs: Date.now(),
-        interactiveCommands
+        interactiveCommands,
+        runtimeFreshnessWindowMs
     });
     return (0, stateMachine_1.deriveWorkerStatusDecision)(context);
 }

package/dist/server/server/status/statusMonitor.js

@@ -10,10 +10,15 @@ const defaultDecisionFacts = {
     workerAgeMs: 0,
     isClaudeSession: false,
     isOpenCodeSession: false,
+    isCodexSession: false,
+    hasClaudePromptSignal: false,
     hasOpenCodePromptSignal: false,
     hasOpenCodeActiveSignal: false,
+    hasCodexPromptSignal: false,
+    hasCodexActiveSignal: false,
     hasClaudeProgressSignal: false,
     hasActiveClaudeTask: false,
+    hasActiveRuntimeProcess: false,
     hasRuntimeActivityText: false,
     hasParsedStrongSignal: false,
     hasParsedNeedsInput: false,
@@ -41,6 +46,7 @@ class StatusMonitor {
     traceMode = resolveStatusTraceMode();
     workerPollConcurrency = resolveStatusPollConcurrency();
     interactiveCommands;
+    runtimeFreshnessOverrides;
     constructor(workers, tmux, pollIntervalMs, onWorkerUpdated, onWorkerRemoved, config) {
         this.workers = workers;
         this.tmux = tmux;
@@ -48,6 +54,13 @@ class StatusMonitor {
         this.onWorkerUpdated = onWorkerUpdated;
         this.onWorkerRemoved = onWorkerRemoved;
         this.interactiveCommands = new Set(config.status.interactiveCommands.map((cmd) => cmd.toLowerCase()));
+        const freshnessOverrides = new Map();
+        for (const [id, runtime] of Object.entries(config.runtimes)) {
+            if (runtime.freshnessWindowMs !== undefined) {
+                freshnessOverrides.set(id, runtime.freshnessWindowMs);
+            }
+        }
+        this.runtimeFreshnessOverrides = freshnessOverrides;
     }
     start() {
         if (this.intervalId) {
@@ -170,7 +183,8 @@ class StatusMonitor {
                 tmux: this.tmux,
                 paneObservation: this.paneObservation,
                 claudeTranscript: this.claudeTranscript,
-                interactiveCommands: this.interactiveCommands
+                interactiveCommands: this.interactiveCommands,
+                runtimeFreshnessWindowMs: this.runtimeFreshnessOverrides.get(worker.runtimeId)
             });
             if (!signals) {
                 this.removeWorker(worker.id);
@@ -276,7 +290,8 @@ class StatusMonitor {
         if (this.traceMode !== "verbose") {
             return;
         }
-        console.log(`[arcane-agents][status] poll workers=${timing.workerCount} duration=${Math.round(timing.durationMs)}ms ` +
+        const timestamp = new Date().toLocaleTimeString("en-AU", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        console.log(`[arcane-agents][status] ${timestamp} poll workers=${timing.workerCount} duration=${Math.round(timing.durationMs)}ms ` +
             `avgWorker=${Math.round(timing.averageWorkerDurationMs)}ms maxWorker=${Math.round(timing.maxWorkerDurationMs)}ms ` +
             `outcomes={updated:${timing.outcomeCounts.updated},unchanged:${timing.outcomeCounts.unchanged},removed:${timing.outcomeCounts.removed},failed:${timing.outcomeCounts.failed}}`);
     }
@@ -305,8 +320,11 @@ class StatusMonitor {
             `outQuiet=${Math.round(evaluation.facts.outputQuietForMs)}ms ` +
             `cmdQuiet=${Math.round(evaluation.facts.commandQuietForMs)}ms ` +
             `claude=${evaluation.facts.isClaudeSession ? 1 : 0} ` +
-            `opencode=${evaluation.facts.isOpenCodeSession ? 1 : 0}`;
-        console.log(`[arcane-agents][status] ${worker.displayName ?? worker.name} ${fromTo} (${Math.round(evaluation.confidence * 100)}%)${activityText} reasons=[${reasonText}] ${traceFacts}`);
+            `opencode=${evaluation.facts.isOpenCodeSession ? 1 : 0} ` +
+            `codex=${evaluation.facts.isCodexSession ? 1 : 0} ` +
+            `runtimeProc=${evaluation.facts.hasActiveRuntimeProcess ? 1 : 0}`;
+        const timestamp = new Date().toLocaleTimeString("en-AU", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+        console.log(`[arcane-agents][status] ${timestamp} ${worker.displayName ?? worker.name} ${fromTo} (${Math.round(evaluation.confidence * 100)}%)${activityText} reasons=[${reasonText}] ${traceFacts}`);
     }
     recordStatusTransition(worker, evaluation) {
         if (evaluation.status === worker.status) {

package/dist/server/server/status/statusMonitor.test.js

@@ -8,7 +8,7 @@ vitest_1.vi.mock("./statusPipeline", () => ({
     evaluateWorkerStatusSignals: vitest_1.vi.fn(),
     normalizeWorkerStatusEvaluation: vitest_1.vi.fn((evaluation) => evaluation)
 }));
-const testConfig = { status: { interactiveCommands: [] } };
+const testConfig = { status: { interactiveCommands: [] }, runtimes: {} };
 const defaultFacts = {
     command: "claude",
     commandQuietForMs: 0,
@@ -16,10 +16,15 @@ const defaultFacts = {
     workerAgeMs: 0,
     isClaudeSession: true,
     isOpenCodeSession: false,
+    isCodexSession: false,
+    hasClaudePromptSignal: false,
     hasOpenCodePromptSignal: false,
     hasOpenCodeActiveSignal: false,
+    hasCodexPromptSignal: false,
+    hasCodexActiveSignal: false,
     hasClaudeProgressSignal: false,
     hasActiveClaudeTask: false,
+    hasActiveRuntimeProcess: false,
     hasRuntimeActivityText: false,
     hasParsedStrongSignal: false,
     hasParsedNeedsInput: false,
@@ -90,7 +95,9 @@ function createSignals() {
             lastOutputChangeAtMs: Date.now()
         },
         transcriptSnapshot: undefined,
-        interactiveCommands: new Set()
+        runtimeProcess: undefined,
+        interactiveCommands: new Set(),
+        runtimeFreshnessWindowMs: undefined
     };
 }
 function createEvaluation(status) {

package/dist/server/server/status/statusPipeline.js

@@ -4,15 +4,21 @@ exports.collectWorkerStatusSignals = collectWorkerStatusSignals;
 exports.evaluateWorkerStatusSignals = evaluateWorkerStatusSignals;
 exports.normalizeWorkerStatusEvaluation = normalizeWorkerStatusEvaluation;
 const runtimeSignals_1 = require("./runtimeSignals");
+const runtimeProcess_1 = require("./runtime/runtimeProcess");
 const statusEvaluator_1 = require("./statusEvaluator");
 const paneObservation_1 = require("./paneObservation");
-async function collectWorkerStatusSignals({ worker, tmux, paneObservation, claudeTranscript, interactiveCommands }) {
+async function collectWorkerStatusSignals({ worker, tmux, paneObservation, claudeTranscript, interactiveCommands, runtimeFreshnessWindowMs }) {
     const paneState = await tmux.getPaneState(worker.tmuxRef);
     if (paneState.isDead) {
         return undefined;
     }
+    const currentCommandLower = paneState.currentCommand.toLowerCase();
+    const runtimeProcess = paneState.panePid && (currentCommandLower === "bash" || currentCommandLower === "zsh" || currentCommandLower === "sh")
+        ? await (0, runtimeProcess_1.findAgentRuntimeProcess)(paneState.panePid)
+        : undefined;
+    const captureCommand = runtimeProcess?.runtime ?? currentCommandLower;
     const [output, transcriptSnapshot] = await Promise.all([
-        tmux.capturePane(worker.tmuxRef, (0, runtimeSignals_1.capturePaneLineCount)(worker, paneState.currentCommand.toLowerCase())),
+        tmux.capturePane(worker.tmuxRef, (0, runtimeSignals_1.capturePaneLineCount)(worker, captureCommand)),
         claudeTranscript.poll(worker, paneState.currentCommand, paneState.currentPath, paneState.panePid)
     ]);
     const observation = (0, paneObservation_1.observePane)(paneObservation, worker.id, paneState.currentCommand, output);
@@ -21,7 +27,9 @@ async function collectWorkerStatusSignals({ worker, tmux, paneObservation, claud
         output,
         observation,
         transcriptSnapshot,
-        interactiveCommands
+        runtimeProcess,
+        interactiveCommands,
+        runtimeFreshnessWindowMs
     };
 }
 function evaluateWorkerStatusSignals(worker, signals) {
@@ -31,7 +39,9 @@ function evaluateWorkerStatusSignals(worker, signals) {
         output: signals.output,
         observation: signals.observation,
         transcriptSnapshot: signals.transcriptSnapshot,
-        interactiveCommands: signals.interactiveCommands
+        runtimeProcess: signals.runtimeProcess,
+        interactiveCommands: signals.interactiveCommands,
+        runtimeFreshnessWindowMs: signals.runtimeFreshnessWindowMs
     });
 }
 function normalizeWorkerStatusEvaluation(evaluation) {

package/dist/server/server/tmux/tmuxAdapter.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TmuxAdapter = void 0;
+exports.clipboardCandidatesForEnvironment = clipboardCandidatesForEnvironment;
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
+const tmuxClient_1 = require("./tmuxClient");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 class TmuxAdapter {
-    sessionName;
-    sessionClipboardConfigured = false;
-    constructor(sessionName) {
-        this.sessionName = sessionName;
+    config;
+    managedDefaultsConfigured = false;
+    constructor(config) {
+        this.config = config;
     }
     async spawnWorker(input) {
-        const target = `${this.sessionName}:${input.windowName}`;
+        const target = `${this.config.sessionName}:${input.windowName}`;
         const commandLine = input.command.map(shellQuote).join(" ");
         const env = `ARCANE_AGENTS_WORKER_ID=${input.workerId}`;
         if (await this.hasSession()) {
@@ -19,7 +21,7 @@ class TmuxAdapter {
                 "new-window",
                 "-d",
                 "-t",
-                this.sessionName,
+                this.config.sessionName,
                 "-n",
                 input.windowName,
                 "-c",
@@ -30,11 +32,12 @@ class TmuxAdapter {
             ]);
         }
         else {
+            this.managedDefaultsConfigured = false;
             await this.runTmux([
                 "new-session",
                 "-d",
                 "-s",
-                this.sessionName,
+                this.config.sessionName,
                 "-n",
                 input.windowName,
                 "-c",
@@ -44,7 +47,7 @@ class TmuxAdapter {
                 commandLine
             ]);
         }
-        await this.ensureSessionClipboardDefaults();
+        await this.ensureManagedDefaults();
         await this.setWindowMetadata(target, {
             "@arcane_agents_managed": "1",
             "@arcane_agents_worker_id": input.workerId,
@@ -63,7 +66,7 @@ class TmuxAdapter {
             throw new Error(`Unable to resolve tmux pane for ${target}.`);
         }
         return {
-            session: this.sessionName,
+            session: this.config.sessionName,
             window: input.windowName,
             pane
         };
@@ -75,23 +78,18 @@ class TmuxAdapter {
         }
         await this.stopGracefully(ref);
     }
-    async ensureSessionClipboardDefaults() {
-        if (this.sessionClipboardConfigured) {
+    async ensureManagedDefaults() {
+        if (this.managedDefaultsConfigured) {
             return;
         }
         if (!(await this.hasSession())) {
             return;
         }
         const copyCommand = await detectClipboardCopyCommand();
-        if (!copyCommand) {
-            this.sessionClipboardConfigured = true;
-            return;
+        for (const command of (0, tmuxClient_1.buildFriendlyTmuxDefaults)({ copyCommand })) {
+            await this.runTmux(command).catch(() => undefined);
         }
-        await Promise.all([
-            this.runTmux(["set-option", "-t", this.sessionName, "set-clipboard", "external"]),
-            this.runTmux(["set-option", "-t", this.sessionName, "copy-command", copyCommand])
-        ]).catch(() => undefined);
-        this.sessionClipboardConfigured = true;
+        this.managedDefaultsConfigured = true;
     }
     async windowExists(ref) {
         try {
@@ -160,7 +158,8 @@ class TmuxAdapter {
             throw error;
         }
         await new Promise((resolve, reject) => {
-            const guardCommand = `tmux has-session -t ${shellQuote(externalSession)} >/dev/null 2>&1 || exit 0; exec tmux attach-session -t ${shellQuote(externalSession)}`;
+            const tmuxCommand = (0, tmuxClient_1.buildTmuxCommandPrefix)(this.config);
+            const guardCommand = `${tmuxCommand} has-session -t ${shellQuote(externalSession)} >/dev/null 2>&1 || exit 0; exec ${tmuxCommand} attach-session -t ${shellQuote(externalSession)}`;
             const child = (0, node_child_process_1.spawn)("xdg-terminal-exec", ["sh", "-lc", guardCommand], {
                 detached: true,
                 stdio: "ignore"
@@ -219,7 +218,7 @@ class TmuxAdapter {
     }
     async hasSession() {
         try {
-            await this.runTmux(["has-session", "-t", this.sessionName]);
+            await this.runTmux(["has-session", "-t", this.config.sessionName]);
             return true;
         }
         catch {
@@ -230,7 +229,7 @@ class TmuxAdapter {
         return `${ref.session}:${ref.window}`;
     }
     async runTmux(args) {
-        const { stdout } = await execFileAsync("tmux", args, {
+        const { stdout } = await execFileAsync("tmux", (0, tmuxClient_1.buildTmuxArgs)(args, this.config), {
             maxBuffer: 1024 * 1024
         });
         return stdout.trimEnd();
@@ -246,21 +245,6 @@ class TmuxAdapter {
         }
         await this.runTmux(["send-keys", "-t", target, "C-c"]).catch(() => undefined);
         await delay(220);
-        const paneInfo = await this.runTmux([
-            "list-panes",
-            "-t",
-            target,
-            "-F",
-            "#{pane_pid}\t#{pane_current_command}\t#{pane_dead}"
-        ]).catch(() => "");
-        const [panePidText = "", paneCommand = "", paneDeadFlag = "1"] = firstLine(paneInfo).split("\t");
-        const panePid = Number.parseInt(panePidText, 10);
-        const currentCommand = paneCommand.trim().toLowerCase();
-        const paneDead = paneDeadFlag === "1";
-        if (!paneDead && Number.isFinite(panePid) && panePid > 1 && currentCommand !== "bash" && currentCommand !== "zsh") {
-            await terminateProcessGroup(panePid).catch(() => undefined);
-            await delay(90);
-        }
         await this.runTmux(["kill-window", "-t", target]).catch(() => undefined);
     }
 }
@@ -292,7 +276,7 @@ function normalizeOption(value) {
     return value;
 }
 async function detectClipboardCopyCommand() {
-    const candidates = clipboardCandidatesForPlatform(process.platform);
+    const candidates = clipboardCandidatesForEnvironment(process.platform, process.env);
     for (const candidate of candidates) {
         if (await commandExists(candidate.binary)) {
             return candidate.command;
@@ -300,18 +284,22 @@ async function detectClipboardCopyCommand() {
     }
     return undefined;
 }
-function clipboardCandidatesForPlatform(platform) {
+function clipboardCandidatesForEnvironment(platform, env = process.env) {
     if (platform === "darwin") {
         return [{ binary: "pbcopy", command: "pbcopy" }];
     }
     if (platform === "win32") {
         return [{ binary: "clip.exe", command: "clip.exe" }];
     }
-    return [
+    const linuxCandidates = [
         { binary: "wl-copy", command: "wl-copy" },
         { binary: "xclip", command: "xclip -selection clipboard -in" },
         { binary: "xsel", command: "xsel --clipboard --input" }
     ];
+    if (platform === "linux" && isWslEnvironment(env)) {
+        return [{ binary: "clip.exe", command: "clip.exe" }, ...linuxCandidates];
+    }
+    return linuxCandidates;
 }
 async function commandExists(binary) {
     const locator = process.platform === "win32" ? "where" : "which";
@@ -325,15 +313,6 @@ async function commandExists(binary) {
         return false;
     }
 }
-async function terminateProcessGroup(panePid) {
-    const { stdout } = await execFileAsync("ps", ["-o", "pgid=", "-p", String(panePid)], {
-        maxBuffer: 1024 * 64
-    });
-    const pgid = Number.parseInt(stdout.trim(), 10);
-    if (!Number.isFinite(pgid) || pgid <= 1) {
-        return;
-    }
-    await execFileAsync("kill", ["-TERM", `-${pgid}`], { maxBuffer: 1024 * 64 }).catch(() => undefined);
-    await delay(120);
-    await execFileAsync("kill", ["-KILL", `-${pgid}`], { maxBuffer: 1024 * 64 }).catch(() => undefined);
+function isWslEnvironment(env) {
+    return Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP || env.WSLENV);
 }

package/dist/server/server/tmux/tmuxClient.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTmuxArgs = buildTmuxArgs;
+exports.buildTmuxAttachArgs = buildTmuxAttachArgs;
+exports.buildTmuxCommandPrefix = buildTmuxCommandPrefix;
+exports.buildFriendlyTmuxDefaults = buildFriendlyTmuxDefaults;
+function buildTmuxArgs(args, options) {
+    return ["-L", options.socketName, ...args];
+}
+function buildTmuxAttachArgs(target, options) {
+    return buildTmuxArgs(["attach-session", "-t", target], options);
+}
+function buildTmuxCommandPrefix(options) {
+    return `tmux -L ${shellQuote(options.socketName)}`;
+}
+function buildFriendlyTmuxDefaults(options = {}) {
+    const copyAction = options.copyCommand ? "copy-pipe-and-cancel" : "copy-selection-and-cancel";
+    const commands = [
+        ["set-option", "-g", "mouse", "on"],
+        ["set-option", "-s", "escape-time", "0"],
+        ["set-window-option", "-g", "history-limit", "100000"],
+        ["bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", copyAction],
+        ["bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", copyAction]
+    ];
+    if (options.copyCommand) {
+        commands.splice(3, 0, ["set-option", "-s", "set-clipboard", "external"], ["set-option", "-s", "copy-command", options.copyCommand]);
+    }
+    return commands;
+}
+function shellQuote(value) {
+    if (value.length === 0) {
+        return "''";
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}

package/dist/server/server/tmux/tmuxClient.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tmuxClient_1 = require("./tmuxClient");
+const tmuxAdapter_1 = require("./tmuxAdapter");
+(0, vitest_1.describe)("tmuxClient", () => {
+    (0, vitest_1.it)("prefixes tmux commands with the managed socket name", () => {
+        (0, vitest_1.expect)((0, tmuxClient_1.buildTmuxArgs)(["list-sessions"], { socketName: "arcane-agents" })).toEqual([
+            "-L",
+            "arcane-agents",
+            "list-sessions"
+        ]);
+    });
+    (0, vitest_1.it)("builds attach-session commands on the managed socket", () => {
+        (0, vitest_1.expect)((0, tmuxClient_1.buildTmuxAttachArgs)("arcane-agents:worker-1", { socketName: "arcane-agents" })).toEqual([
+            "-L",
+            "arcane-agents",
+            "attach-session",
+            "-t",
+            "arcane-agents:worker-1"
+        ]);
+    });
+    (0, vitest_1.it)("builds a shell-safe tmux command prefix", () => {
+        (0, vitest_1.expect)((0, tmuxClient_1.buildTmuxCommandPrefix)({ socketName: "arcane-agents-demo" })).toBe("tmux -L 'arcane-agents-demo'");
+    });
+    (0, vitest_1.it)("enables friendly defaults with clipboard-aware copy bindings when a copy command is available", () => {
+        (0, vitest_1.expect)((0, tmuxClient_1.buildFriendlyTmuxDefaults)({ copyCommand: "wl-copy" })).toEqual([
+            ["set-option", "-g", "mouse", "on"],
+            ["set-option", "-s", "escape-time", "0"],
+            ["set-window-option", "-g", "history-limit", "100000"],
+            ["set-option", "-s", "set-clipboard", "external"],
+            ["set-option", "-s", "copy-command", "wl-copy"],
+            ["bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel"],
+            ["bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel"]
+        ]);
+    });
+    (0, vitest_1.it)("falls back to tmux buffer copy bindings when no clipboard command is available", () => {
+        (0, vitest_1.expect)((0, tmuxClient_1.buildFriendlyTmuxDefaults)()).toEqual([
+            ["set-option", "-g", "mouse", "on"],
+            ["set-option", "-s", "escape-time", "0"],
+            ["set-window-option", "-g", "history-limit", "100000"],
+            ["bind-key", "-T", "copy-mode", "MouseDragEnd1Pane", "send-keys", "-X", "copy-selection-and-cancel"],
+            ["bind-key", "-T", "copy-mode-vi", "MouseDragEnd1Pane", "send-keys", "-X", "copy-selection-and-cancel"]
+        ]);
+    });
+    (0, vitest_1.it)("prefers the Windows clipboard bridge when running inside WSL", () => {
+        (0, vitest_1.expect)((0, tmuxAdapter_1.clipboardCandidatesForEnvironment)("linux", { WSL_DISTRO_NAME: "Ubuntu" })[0]).toEqual({
+            binary: "clip.exe",
+            command: "clip.exe"
+        });
+    });
+    (0, vitest_1.it)("keeps native Linux clipboard commands first outside WSL", () => {
+        (0, vitest_1.expect)((0, tmuxAdapter_1.clipboardCandidatesForEnvironment)("linux", {})[0]).toEqual({
+            binary: "wl-copy",
+            command: "wl-copy"
+        });
+    });
+});