handmux 0.33.3 → 0.34.0

package/dist/src/agent-runtime/tmuxRuntime.js

@@ -155,6 +155,21 @@ export async function processStartedAt(run, pid) {
     const parsed = Date.parse(String(await run('ps', ['-p', String(pid), '-o', 'lstart='])).trim());
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+function processPresence(pid) {
+    try {
+        process.kill(pid, 0);
+        return 'present';
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error !== null && 'code' in error
+            ? String(error.code) : '';
+        if (code === 'ESRCH')
+            return 'missing';
+        if (code === 'EPERM' || code === 'EACCES')
+            return 'present';
+        return 'unknown';
+    }
+}
 export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
     const PS_FORMAT = 'pid=,ppid=,stat=,etime=,tty=,command=';
     const rowsCache = new Map();
@@ -190,15 +205,15 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
     };
     // One `ps` read, shared by both evidence methods below. The full-system scan is only the fallback for a
     // platform whose targeted query returns nothing; rows are always re-filtered to the pane's own tty.
-    const foregroundGroup = async (pane) => {
+    const foregroundGroup = async (pane, fresh = false) => {
         const tty = normTty(pane.tty);
         if (!tty)
             return { tty: '', rows: [] };
-        const cached = rowsCache.get(tty);
+        const cached = fresh ? undefined : rowsCache.get(tty);
         const now = Date.now();
-        if (cached?.rows && cached.expiresAt > now)
+        if (!fresh && cached?.rows && cached.expiresAt > now)
             return { tty, rows: cached.rows };
-        if (cached?.promise && cached.expiresAt > now)
+        if (!fresh && cached?.promise && cached.expiresAt > now)
             return { tty, rows: await cached.promise };
         const promise = (async () => {
             let output = await run('ps', ['-t', tty, '-o', PS_FORMAT]);
@@ -206,6 +221,8 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
                 output = await run('ps', ['-Ao', PS_FORMAT]);
             return foregroundRows(output).filter((row) => row.tty === tty);
         })();
+        if (fresh)
+            return { tty, rows: await promise };
         const entry = {
             expiresAt: Date.now() + PROCESS_EVIDENCE_INFLIGHT_MS,
             promise,
@@ -260,6 +277,28 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
             };
             return { ...value };
         },
+        async inspectForegroundFresh(pane) {
+            const { tty, rows } = await foregroundGroup(pane, true);
+            if (!tty)
+                return null;
+            const row = foregroundLeaf(rows, tty, pane.currentCommand);
+            if (!row)
+                return null;
+            const processStart = await processStartedAt(run, row.pid);
+            if (processStart === undefined)
+                return null;
+            const executable = await executablePath(run, row.pid);
+            if (!executable)
+                return null;
+            return {
+                pid: row.pid,
+                ppid: row.ppid,
+                startedAt: processStart,
+                tty: pane.tty ?? `/dev/${tty}`,
+                executable,
+                ...(row.command ? { commandLine: row.command } : {}),
+            };
+        },
         async inspectForegroundGroup(pane) {
             const tty = normTty(pane.tty);
             if (!tty)
@@ -280,11 +319,54 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
             }));
             return value.map((entry) => ({ ...entry }));
         },
+        async inspectForegroundGroupFresh(pane) {
+            const tty = normTty(pane.tty);
+            if (!tty)
+                return [];
+            const { rows } = await foregroundGroup(pane, true);
+            const value = await Promise.all(rows.map(async (row) => {
+                const [startedAt, executable] = await Promise.all([
+                    processStartedAt(run, row.pid), executablePath(run, row.pid),
+                ]);
+                if (startedAt === undefined || !executable)
+                    return null;
+                return {
+                    pid: row.pid,
+                    ppid: row.ppid,
+                    tty: pane.tty ?? `/dev/${row.tty}`,
+                    startedAt,
+                    executable,
+                    ...(row.command ? { commandLine: row.command } : {}),
+                };
+            }));
+            return value.filter((entry) => entry !== null)
+                .map((entry) => ({ ...entry }));
+        },
         // One `ps -p`, and deliberately no executable lookup: a lease only needs to know that the pid it was
         // attached to is still the same process generation.
         async inspectProcess(pid) {
             const startedAt = await processStartedAt(run, pid);
             return startedAt === undefined ? null : { pid, startedAt };
         },
+        async inspectProcessGenerationFresh(identity) {
+            if (!Number.isSafeInteger(identity.pid) || identity.pid <= 0
+                || !Number.isSafeInteger(identity.startedAt) || identity.startedAt <= 0)
+                return 'unknown';
+            const initialPresence = processPresence(identity.pid);
+            if (initialPresence === 'missing')
+                return 'exited';
+            if (initialPresence === 'unknown')
+                return 'unknown';
+            try {
+                const currentStartedAt = await processStartedAt(run, identity.pid);
+                if (currentStartedAt !== undefined) {
+                    return currentStartedAt === identity.startedAt ? 'same' : 'replaced';
+                }
+            }
+            catch {
+                return 'unknown';
+            }
+            return processPresence(identity.pid) === 'missing' ? 'exited' : 'unknown';
+        },
     };
 }

package/dist/src/agents/codex.js

@@ -302,6 +302,7 @@ export const codex = {
         inbox: { apiVersion: 1 },
         conversation: { apiVersion: 1 },
         conversationActivation: { apiVersion: 1 },
+        conversationRestart: { apiVersion: 1 },
         conversationGoal: { apiVersion: 1 },
         conversationPlan: { apiVersion: 1 },
         conversationContext: { apiVersion: 1 },