larkin 0.5.4 → 0.5.5

package/dist/runtime/pi-tmux.mjs

@@ -0,0 +1,408 @@
+import { spawnSync } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ensureOwnedTree, mkdirPrivateExclusive, writePrivateExclusive } from "./pi-state-dir.mjs";
+export const DEFAULT_BASH_WAIT_SECONDS = 30;
+export const OUTPUT_TAIL_BYTES = 32 * 1024;
+export const LARKIN_TMUX_COMPLETION_TYPE = "larkin-tmux-completion";
+export class ForeignTmuxTaskError extends Error {
+    taskId;
+    constructor(taskId) {
+        super(`tmux task ${taskId} is not owned by this Larkin instance`);
+        this.name = "ForeignTmuxTaskError";
+        this.taskId = taskId;
+    }
+}
+export function tmuxAvailable(env = process.env, platform = process.platform) {
+    if (platform === "win32")
+        return false;
+    const result = spawnSync("tmux", ["-V"], { env: tmuxClientEnv(env), encoding: "utf8", timeout: 5_000 });
+    const version = /tmux\s+(\d+)\.(\d+)/i.exec(`${result.stdout || ""} ${result.stderr || ""}`);
+    return result.status === 0 && version !== null
+        && (Number(version[1]) > 3 || (Number(version[1]) === 3 && Number(version[2]) >= 2));
+}
+function posixQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function sanitizeName(value, fallback) {
+    const cleaned = value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+    return cleaned || fallback;
+}
+function taskRoot(stateDir, agentId, instanceId) {
+    return path.join(stateDir, "pi-tmux", sanitizeName(agentId, "agent"), sanitizeName(instanceId, "inst"));
+}
+function taskDir(stateDir, agentId, instanceId, taskId) {
+    return path.join(taskRoot(stateDir, agentId, instanceId), taskId);
+}
+function sessionName(agentId, instanceId, taskId) {
+    return `lkn-${sanitizeName(agentId, "agent")}-${sanitizeName(instanceId, "inst")}-${taskId}`;
+}
+function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function writePrivate(file, body) {
+    fs.writeFileSync(file, body, { mode: 0o600 });
+    fs.chmodSync(file, 0o600);
+}
+function isRegularFile(file) {
+    try {
+        const stat = fs.lstatSync(file);
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function tailBytes(file, maxBytes) {
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            const size = fs.fstatSync(fd).size;
+            const start = size > maxBytes ? size - maxBytes : 0;
+            const buf = Buffer.alloc(size - start);
+            fs.readSync(fd, buf, 0, buf.length, start);
+            return buf.toString("utf8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function writeEnvScript(file, env) {
+    const lines = ["#!/bin/bash", "set -eu"];
+    for (const [key, value] of Object.entries(env)) {
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        if (value === undefined)
+            continue;
+        // 不写入继承的 tmux 会话坐标；pane 会带上本次 new-session 的值。
+        if (key === "PWD" || key === "TMUX" || key === "TMUX_PANE")
+            continue;
+        lines.push(`export ${key}=${posixQuote(value)}`);
+    }
+    writePrivateExclusive(file, `${lines.join("\n")}\n`);
+}
+function tmuxClientEnv(env) {
+    const next = { ...env };
+    delete next.TMUX;
+    delete next.TMUX_PANE;
+    delete next.BASH_ENV;
+    return next;
+}
+function tmuxHasSession(name, env) {
+    return spawnSync("tmux", ["has-session", "-t", `=${name}`], { env: tmuxClientEnv(env), encoding: "utf8", timeout: 5_000 }).status === 0;
+}
+function killSession(name, env) {
+    spawnSync("tmux", ["kill-session", "-t", `=${name}`], { env: tmuxClientEnv(env), encoding: "utf8", timeout: 5_000 });
+}
+function parseExitCode(raw) {
+    if (raw === null)
+        return null;
+    const value = Number.parseInt(raw.trim(), 10);
+    return Number.isInteger(value) ? value : null;
+}
+function processTable() {
+    const listed = spawnSync("ps", ["-ax", "-o", "pid=,ppid=,pgid=,state="], { encoding: "utf8", timeout: 5_000 });
+    if (listed.status !== 0)
+        return [];
+    return listed.stdout.split("\n").flatMap((line) => {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/);
+        if (!match)
+            return [];
+        return [{
+                pid: Number.parseInt(match[1], 10),
+                ppid: Number.parseInt(match[2], 10),
+                pgid: Number.parseInt(match[3], 10),
+                state: match[4],
+            }];
+    });
+}
+function liveOwnedPanePid(session, env) {
+    if (!tmuxHasSession(session, env))
+        return null;
+    const listed = spawnSync("tmux", ["list-panes", "-t", `=${session}`, "-F", "#{pane_pid}"], {
+        env: tmuxClientEnv(env), encoding: "utf8", timeout: 5_000,
+    });
+    if (listed.status !== 0)
+        return null;
+    const pid = Number.parseInt(listed.stdout.trim().split(/\s+/)[0] ?? "", 10);
+    if (!Number.isInteger(pid) || pid <= 1)
+        return null;
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return null;
+    }
+    return pid;
+}
+function ownedPids(panePid, rows) {
+    const pane = rows.find((row) => row.pid === panePid);
+    const owned = new Set([panePid]);
+    if (pane) {
+        for (const row of rows)
+            if (row.pgid === pane.pgid)
+                owned.add(row.pid);
+    }
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const row of rows) {
+            if (owned.has(row.ppid) && !owned.has(row.pid) && !row.state.startsWith("Z")) {
+                owned.add(row.pid);
+                grew = true;
+            }
+        }
+    }
+    return [...owned].filter((pid) => pid > 1 && pid !== process.pid);
+}
+function pidAlive(pid) {
+    const listed = spawnSync("ps", ["-p", String(pid), "-o", "stat="], { encoding: "utf8", timeout: 5_000 });
+    const state = listed.stdout.trim();
+    return listed.status === 0 && Boolean(state) && !state.startsWith("Z");
+}
+function signalGroup(pgid, signal) {
+    try {
+        process.kill(-pgid, signal);
+    }
+    catch { /* 组已不存在或不是 leader */ }
+}
+/** 只杀当前 pane 进程组及其子孙；不读落盘 pid。SIGKILL 覆盖 trap 忽略 TERM/HUP。 */
+function terminateOwnedPane(session, env) {
+    const panePid = liveOwnedPanePid(session, env);
+    const rows = processTable();
+    const pane = rows.find((row) => row.pid === panePid);
+    const pids = panePid ? ownedPids(panePid, rows) : [];
+    if (pane)
+        signalGroup(pane.pgid, "SIGTERM");
+    killSession(session, env);
+    if (pane)
+        signalGroup(pane.pgid, "SIGKILL");
+    for (const pid of pids) {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch { /* already gone */ }
+    }
+    if (tmuxHasSession(session, env))
+        killSession(session, env);
+    if (tmuxHasSession(session, env))
+        throw new Error(`tmux session ${session} still present after kill`);
+    const deadline = Date.now() + 250;
+    while (Date.now() < deadline && pids.some(pidAlive)) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+    if (pids.some(pidAlive))
+        throw new Error(`tmux pane descendants still present after kill`);
+}
+function snapshotFromDir(dir, taskId, env, session) {
+    // 先探活再读终态：exit_code 在 shell 退出前落盘。先读再 has-session 会把探测窗口里写完的快命令判成 failed+null。
+    const live = tmuxHasSession(session, env);
+    const readExit = () => parseExitCode(readText(path.join(dir, "exit_code")));
+    const cancelled = readText(path.join(dir, "cancelled")) !== null;
+    let exitCode = readExit();
+    if (!live && exitCode === null)
+        exitCode = readExit();
+    const startedAt = readText(path.join(dir, "started_at"))?.trim() || null;
+    const endedAt = readText(path.join(dir, "ended_at"))?.trim() || null;
+    const output = tailBytes(path.join(dir, "output"), OUTPUT_TAIL_BYTES);
+    let status;
+    if (exitCode === null) {
+        if (live)
+            status = cancelled ? "cancelled" : "running";
+        else
+            status = cancelled ? "cancelled" : "failed";
+    }
+    else if (cancelled)
+        status = "cancelled";
+    else
+        status = exitCode === 0 ? "completed" : "failed";
+    return { taskId, status, exitCode, output, startedAt, endedAt };
+}
+export function formatTmuxTaskText(snapshot) {
+    const exit = snapshot.exitCode === null ? "null" : String(snapshot.exitCode);
+    const body = snapshot.output ? `\n${snapshot.output}` : "";
+    return `taskId=${snapshot.taskId} status=${snapshot.status} exitCode=${exit}${body}`;
+}
+export function createLarkinTmux(input) {
+    const env = input.env ?? process.env;
+    const agentId = input.agentId;
+    const instanceId = input.instanceId || crypto.randomUUID();
+    const stateDir = path.resolve(input.stateDir);
+    const ownedParts = ["pi-tmux", sanitizeName(agentId, "agent"), sanitizeName(instanceId, "inst")];
+    const root = taskRoot(stateDir, agentId, instanceId);
+    const expectedSession = (taskId) => sessionName(agentId, instanceId, taskId);
+    const assertPrivateScripts = (dir) => {
+        for (const name of ["env.sh", "command.sh", "run.sh", "meta.json"]) {
+            const file = path.join(dir, name);
+            if (!fs.existsSync(file)) {
+                if (name === "meta.json")
+                    throw new ForeignTmuxTaskError(path.basename(dir));
+                continue;
+            }
+            if (!isRegularFile(file))
+                throw new ForeignTmuxTaskError(path.basename(dir));
+        }
+    };
+    const requireOwned = (taskId) => {
+        if (!/^[A-Za-z0-9_-]+$/.test(taskId))
+            throw new ForeignTmuxTaskError(taskId);
+        let instanceRoot;
+        try {
+            instanceRoot = ensureOwnedTree(stateDir, ownedParts, false);
+        }
+        catch {
+            throw new ForeignTmuxTaskError(taskId);
+        }
+        const dir = taskDir(stateDir, agentId, instanceId, taskId);
+        try {
+            const stat = fs.lstatSync(dir);
+            if (stat.isSymbolicLink() || !stat.isDirectory() || !isInside(instanceRoot, dir))
+                throw new ForeignTmuxTaskError(taskId);
+        }
+        catch (error) {
+            if (error instanceof ForeignTmuxTaskError)
+                throw error;
+            throw new ForeignTmuxTaskError(taskId);
+        }
+        const metaFile = path.join(dir, "meta.json");
+        if (!isRegularFile(metaFile))
+            throw new ForeignTmuxTaskError(taskId);
+        let meta;
+        try {
+            meta = JSON.parse(fs.readFileSync(metaFile, "utf8"));
+        }
+        catch {
+            throw new ForeignTmuxTaskError(taskId);
+        }
+        if (meta.taskId !== taskId
+            || meta.agentId !== agentId
+            || meta.instanceId !== instanceId
+            || meta.session !== expectedSession(taskId)
+            || typeof meta.cwd !== "string")
+            throw new ForeignTmuxTaskError(taskId);
+        try {
+            assertPrivateScripts(dir);
+        }
+        catch (error) {
+            if (error instanceof ForeignTmuxTaskError)
+                throw error;
+            throw new ForeignTmuxTaskError(taskId);
+        }
+        return dir;
+    };
+    const start = (command, cwd) => {
+        const taskId = crypto.randomBytes(8).toString("hex");
+        const parent = ensureOwnedTree(stateDir, ownedParts);
+        const dir = path.join(parent, taskId);
+        mkdirPrivateExclusive(dir);
+        if (!tmuxAvailable(env))
+            throw new Error("tmux is not available");
+        const session = expectedSession(taskId);
+        writePrivateExclusive(path.join(dir, "meta.json"), `${JSON.stringify({
+            taskId, agentId, instanceId, session, cwd,
+        })}\n`);
+        writeEnvScript(path.join(dir, "env.sh"), env);
+        writePrivateExclusive(path.join(dir, "command.sh"), command.endsWith("\n") ? command : `${command}\n`);
+        const envFile = path.join(dir, "env.sh");
+        const commandFile = path.join(dir, "command.sh");
+        const outputFile = path.join(dir, "output");
+        const exitFile = path.join(dir, "exit_code");
+        const startedFile = path.join(dir, "started_at");
+        const endedFile = path.join(dir, "ended_at");
+        // 包装器用 /bin/bash；用户命令另启 bash -o pipefail，保留数组 / [[ / pipefail。
+        writePrivateExclusive(path.join(dir, "run.sh"), [
+            "#!/bin/bash",
+            `PANE_TMUX=\${TMUX-}`,
+            `PANE_TMUX_PANE=\${TMUX_PANE-}`,
+            `. ${posixQuote(envFile)}`,
+            "set +eu",
+            "unset TMUX TMUX_PANE",
+            `if [ -n "$PANE_TMUX" ]; then export TMUX="$PANE_TMUX"; fi`,
+            `if [ -n "$PANE_TMUX_PANE" ]; then export TMUX_PANE="$PANE_TMUX_PANE"; fi`,
+            `cd ${posixQuote(cwd)} || { date -u +%Y-%m-%dT%H:%M:%SZ > ${posixQuote(endedFile)}; printf '%s\\n' 127 > ${posixQuote(exitFile)}; exit 127; }`,
+            `date -u +%Y-%m-%dT%H:%M:%SZ > ${posixQuote(startedFile)}`,
+            `/bin/bash -o pipefail ${posixQuote(commandFile)} > ${posixQuote(outputFile)} 2>&1`,
+            `status=$?`,
+            `date -u +%Y-%m-%dT%H:%M:%SZ > ${posixQuote(endedFile)}`,
+            `printf '%s\\n' "$status" > ${posixQuote(exitFile)}`,
+            "",
+        ].join("\n"));
+        const created = spawnSync("tmux", ["new-session", "-d", "-s", session, "-n", "bash", "-e", "BASH_ENV=", "/usr/bin/env", "-u", "BASH_ENV", "/bin/bash", path.join(dir, "run.sh")], {
+            env: tmuxClientEnv(env),
+            encoding: "utf8",
+            timeout: 5_000,
+        });
+        if (created.status !== 0) {
+            throw new Error(`tmux new-session failed: ${(created.stderr || created.stdout || "").trim() || created.status}`);
+        }
+        return snapshotFromDir(dir, taskId, env, session);
+    };
+    const peek = (taskId) => {
+        const dir = requireOwned(taskId);
+        return snapshotFromDir(dir, taskId, env, expectedSession(taskId));
+    };
+    const list = () => {
+        let instanceRoot;
+        try {
+            instanceRoot = ensureOwnedTree(stateDir, ownedParts, false);
+        }
+        catch {
+            return [];
+        }
+        return fs.readdirSync(instanceRoot).sort().flatMap((taskId) => {
+            try {
+                return [peek(taskId)];
+            }
+            catch {
+                return [];
+            }
+        });
+    };
+    const wait = async (taskId, timeoutSeconds, signal) => {
+        const deadline = Date.now() + Math.max(0, timeoutSeconds) * 1000;
+        while (true) {
+            if (signal?.aborted) {
+                kill(taskId);
+                return peek(taskId);
+            }
+            const current = peek(taskId);
+            // 会话已消失但 exit 尚未落盘时继续等到 WAIT 窗口结束，避免快命令被误判 failed。
+            const flushing = current.status === "failed" && current.exitCode === null;
+            if (current.status !== "running" && !flushing)
+                return current;
+            if (Date.now() >= deadline)
+                return current;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    };
+    const kill = (taskId) => {
+        const dir = requireOwned(taskId);
+        const session = expectedSession(taskId);
+        if (parseExitCode(readText(path.join(dir, "exit_code"))) !== null)
+            return snapshotFromDir(dir, taskId, env, session);
+        const live = tmuxHasSession(session, env) || liveOwnedPanePid(session, env) !== null;
+        if (live) {
+            writePrivate(path.join(dir, "cancelled"), "1\n");
+            terminateOwnedPane(session, env);
+            if (!readText(path.join(dir, "ended_at"))) {
+                writePrivate(path.join(dir, "ended_at"), `${new Date().toISOString().slice(0, 19)}Z\n`);
+            }
+        }
+        return snapshotFromDir(dir, taskId, env, session);
+    };
+    return { start, peek, list, wait, kill, root, instanceId };
+}

package/dist/runtime/runtime-adapters.mjs

@@ -6,11 +6,8 @@ import { createInterface } from "node:readline";
 import { isPiThinkingLevel } from "./pi-model-catalog.mjs";
 import { PiRpcClient } from "./pi-rpc-client.mjs";
 import { traceProcessBoundary } from "../platform/process-boundary-trace.mjs";
-import { resolvePiSubagentExtensionArg } from "./pi-subagent-injection.mjs";
-import { extractCanonicalPiSubagentNotification, ledgerStatusFromPiNotificationStatus, } from "./pi-subagents-notification.mjs";
-import { resolvePiSubagentRecordWatchdogExtensionArg } from "./pi-subagent-record-watchdog-injection.mjs";
-import { effectivePiStateDir, extractBackgroundPiSubagentDispatch } from "./pi-subagent-ledger.mjs";
-import { resolvePiBashTimeoutExtensionArg } from "./pi-bash-timeout-injection.mjs";
+import { effectivePiStateDir, writePrivateAtomic } from "./pi-state-dir.mjs";
+import { resolvePiTmuxExtensionArg } from "./pi-tmux-injection.mjs";
 import { classifyPiMissingCredentialRejection, classifyRuntimePrerequisite, missingProviderCredentialReadiness, probeNativeRuntimeReadiness, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { buildStrictProviderErrorInput, classifyStrictProviderError, INTERNAL_CONTEXT_WINDOW_PROJECTION_REASON, safeProviderDiagnostic, } from "./provider-error-classifier.mjs";
 import { assertEffectivePiCompactionSettings, MINIMUM_PI_VERSION, calculatePiCompactionSettings, parsePiExecutableVersion, projectPiSettingsFile, readOwnedPiSettings, verifyPiCapabilities, writeOwnedPiSettings, } from "./pi-compaction-recovery.mjs";
@@ -482,9 +479,6 @@ class PiSession extends EventSession {
     observedSubmitEpochs = new Set();
     observedAcceptedEpochs = new Set();
     observedCompletedEpochs = new Set();
-    observedBackgroundCompletionKeys = new Set();
-    pendingUnownedCompletionKeys = new Set();
-    pendingUnownedCompletionStatuses = new Map();
     observedAgentEndEpochs = new Set();
     firstOutputObserved = false;
     toolCallOpen = false;
@@ -533,9 +527,9 @@ class PiSession extends EventSession {
     }
     async close(_reason) { this.unsubscribe?.(); await this.sdk.dispose?.(); }
     async enqueue(input, operation) {
-        if (this.ownedInputIds.size === 0)
+        if (this.ownedInputIds.size === 0 && this.activeEpoch === null)
             this.requestEpoch += 1;
-        const epoch = this.requestEpoch;
+        const epoch = this.activeEpoch ?? this.requestEpoch;
         this.ownedInputIds.add(input.inputId);
         this.inputEpochs.set(input.inputId, epoch);
         this.awaitingAcknowledgement.add(input.inputId);
@@ -598,9 +592,6 @@ class PiSession extends EventSession {
             this.observedSubmitEpochs.clear();
             this.observedAcceptedEpochs.clear();
             this.observedCompletedEpochs.clear();
-            this.observedBackgroundCompletionKeys.clear();
-            this.pendingUnownedCompletionKeys.clear();
-            this.pendingUnownedCompletionStatuses.clear();
             this.observedAgentEndEpochs.clear();
             this.activeEpoch = null;
             this.settleArmedEpoch = null;
@@ -620,11 +611,19 @@ class PiSession extends EventSession {
             this.emitObservation("retry_progress");
         }
         else if (event?.type === "turn_start") {
-            const epoch = this.oldestOwnedEpoch();
-            if (epoch === null || this.activeEpoch !== null)
+            if (this.activeEpoch !== null)
                 return;
-            this.activeEpoch = epoch;
-            this.settleArmedEpoch = null;
+            const owned = this.oldestOwnedEpoch();
+            if (owned === null) {
+                // Native Pi triggerTurn / extension follow-up: occupy busy without a host prompt.
+                this.requestEpoch += 1;
+                this.activeEpoch = this.requestEpoch;
+                this.settleArmedEpoch = this.activeEpoch;
+            }
+            else {
+                this.activeEpoch = owned;
+                this.settleArmedEpoch = null;
+            }
             this.firstOutputObserved = false;
             this.toolCallOpen = false;
             this.emitObservation("turn_start");
@@ -650,46 +649,13 @@ class PiSession extends EventSession {
                 this.observedCompletedEpochs.add(this.activeEpoch);
                 this.emitObservation("completed");
             }
-            const completionNotification = extractCanonicalPiSubagentNotification(event.messages);
-            if (completionNotification && !this.observedBackgroundCompletionKeys.has(completionNotification.key)) {
-                const completionStatuses = Object.fromEntries(completionNotification.notifications.map((notification) => [
-                    notification.taskId,
-                    ledgerStatusFromPiNotificationStatus(notification.status),
-                ]));
-                const owningTurnFailed = event.willRetry === true
-                    || this.finalAssistantStopReason === "error"
-                    || this.finalAssistantStopReason === "aborted";
-                if (this.activeEpoch === null || owningTurnFailed) {
-                    // Unowned agent_end still has an active Pi session, so prompting
-                    // before settle is rejected as "Agent is already processing".
-                    // A failed or retrying owned turn also did not process the
-                    // notification; do not emit handledInTurn so RuntimeHost can still
-                    // wake after input-error, retry, or restart.
-                    this.pendingUnownedCompletionKeys.add(completionNotification.key);
-                    this.pendingUnownedCompletionStatuses.set(completionNotification.key, completionStatuses);
-                }
-                else {
-                    // Already visible in the owned turn. Persist as acknowledged; do not
-                    // schedule another wake after the parent turn settles.
-                    this.observedBackgroundCompletionKeys.add(completionNotification.key);
-                    this.emitObservation("completed", {
-                        completionKey: completionNotification.key,
-                        completionStatuses,
-                        handledInTurn: true,
-                    });
-                }
-            }
         }
         else if (event?.type === "agent_settled") {
             const epoch = this.activeEpoch;
-            if (epoch === null) {
-                this.flushPendingUnownedCompletions();
+            if (epoch === null)
                 return;
-            }
-            if (this.settleArmedEpoch !== epoch) {
-                this.flushPendingUnownedCompletions();
+            if (this.settleArmedEpoch !== epoch)
                 return;
-            }
             this.activeEpoch = null;
             this.settleArmedEpoch = null;
             const error = this.finalAssistantError;
@@ -730,7 +696,6 @@ class PiSession extends EventSession {
             this.observedAcceptedEpochs.delete(epoch);
             this.observedCompletedEpochs.delete(epoch);
             this.observedAgentEndEpochs.delete(epoch);
-            this.flushPendingUnownedCompletions();
         }
         else if (event?.type === "tool_execution_start") {
             if (!this.firstOutputObserved) {
@@ -748,13 +713,6 @@ class PiSession extends EventSession {
                 this.toolCallOpen = false;
                 this.emit({ type: "runtime-observation", runtime: "pi", distribution: this.distribution, phase: "tool_result" });
             }
-            const dispatched = extractBackgroundPiSubagentDispatch(event);
-            if (dispatched) {
-                this.emitObservation("background_dispatched", {
-                    taskId: dispatched.taskId,
-                    ...(dispatched.outputFile ? { outputFile: dispatched.outputFile } : {}),
-                });
-            }
         }
         else if (event?.type === "message_update" && event.assistantMessageEvent?.delta) {
             if (!this.firstOutputObserved) {
@@ -765,20 +723,6 @@ class PiSession extends EventSession {
             this.emit({ type: "activity", activity: kind, text: String(event.assistantMessageEvent.delta) });
         }
     }
-    flushPendingUnownedCompletions() {
-        for (const completionKey of this.pendingUnownedCompletionKeys) {
-            if (this.observedBackgroundCompletionKeys.has(completionKey))
-                continue;
-            this.observedBackgroundCompletionKeys.add(completionKey);
-            const completionStatuses = this.pendingUnownedCompletionStatuses.get(completionKey);
-            this.emitObservation("completed", {
-                completionKey,
-                ...(completionStatuses ? { completionStatuses } : {}),
-            });
-        }
-        this.pendingUnownedCompletionKeys.clear();
-        this.pendingUnownedCompletionStatuses.clear();
-    }
     emitObservation(phase, fields = {}) {
         const inputId = this.oldestOwnedInput();
         const observation = { type: "runtime-observation", runtime: "pi",
@@ -788,8 +732,6 @@ class PiSession extends EventSession {
             Object.defineProperty(observation, "sessionId", { value: this.sessionId, enumerable: false });
         if (inputId)
             Object.defineProperty(observation, "inputId", { value: inputId, enumerable: false });
-        if (fields.completionKey)
-            Object.defineProperty(observation, "completionKey", { value: fields.completionKey, enumerable: false });
         this.emit(observation);
     }
     oldestOwnedInput() {
@@ -936,28 +878,6 @@ async function discoverEffectivePiContextWindow(input, command, commandPrefix, r
         await client.close();
     }
 }
-function writePrivateAtomic(file, content) {
-    try {
-        if (fs.lstatSync(file).isSymbolicLink())
-            throw new Error("standing prompt must not be a symlink");
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            throw error;
-    }
-    const temporary = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.${crypto.randomUUID()}.tmp`);
-    try {
-        fs.writeFileSync(temporary, content, { mode: 0o600, flag: "wx" });
-        fs.renameSync(temporary, file);
-        fs.chmodSync(file, 0o600);
-    }
-    finally {
-        try {
-            fs.unlinkSync(temporary);
-        }
-        catch { /* renamed or absent */ }
-    }
-}
 class PiRpcBackend {
     client;
     policy;
@@ -1012,27 +932,20 @@ class PiRpcBackend {
         return () => { offEvent(); offFailure(); };
     }
 }
-export function resolvePiProcessExtensionArgs(input, resolvers = {}) {
-    const resolverInput = { distribution: "external", piCommand: input.piCommand, env: input.env };
-    const args = [];
-    // Watchdog must load before the subagent extension so session_shutdown still
-    // sees AgentManager.getRecord and can bridge consumed or terminal state.
-    const recordWatchdog = (resolvers.recordWatchdog ?? resolvePiSubagentRecordWatchdogExtensionArg)(resolverInput);
-    if (recordWatchdog)
-        args.push("-e", recordWatchdog);
-    const subagents = (resolvers.subagents ?? resolvePiSubagentExtensionArg)(resolverInput);
-    if (subagents)
-        args.push("-e", subagents);
-    const bashTimeout = (resolvers.bashTimeout ?? resolvePiBashTimeoutExtensionArg)(resolverInput);
-    if (bashTimeout)
-        args.push("-e", bashTimeout);
-    return args;
+/** Inject only the Larkin-owned tmux extension. Skip native Windows so stock Pi bash remains. */
+export function resolvePiProcessExtensionArgs(input) {
+    const bundle = resolvePiTmuxExtensionArg({ env: input.env, platform: input.platform });
+    return bundle ? ["-e", bundle] : [];
 }
 async function createPiRpcBackend(input, dependencies, spawn, productionSpawn = true) {
     const stateRoot = effectivePiStateDir(input);
     const mergedEnv = stripPiCodingAgentDir({ ...globalThis.process.env, ...dependencies.env, ...input.env, NO_COLOR: "1" });
     if (mergedEnv.LARKIN_PI_DISTRIBUTION === "builtin")
         delete mergedEnv.LARKIN_PI_DISTRIBUTION;
+    mergedEnv.LARKIN_AGENT_ID = input.agentId;
+    mergedEnv.LARKIN_STATE_DIR = stateRoot;
+    if (!mergedEnv.LARKIN_TMUX_INSTANCE_ID)
+        mergedEnv.LARKIN_TMUX_INSTANCE_ID = crypto.randomUUID();
     const projectSettings = projectPiSettingsFile(input.workspaceDir);
     traceProcessBoundary(mergedEnv, "pi-rpc:child-env", { configDir: mergedEnv.LARKIN_CONFIG_DIR, agentId: input.agentId, targetDir: projectSettings, childEnvConfigDir: mergedEnv.LARKIN_CONFIG_DIR || null, childEnvHome: mergedEnv.HOME || null });
     const runtimeDir = path.join(stateRoot, "runtime");