@ddtcorex/dsh-maestro-supervisor 0.7.10 → 0.8.2

package/lib/restart-guards.js

@@ -11,6 +11,36 @@ export function buildKillStalePortsCommand(ports = [3080]) {
     const filter = ports.map(p => `sport = :${p}`).join(' or ');
     return `pids=$(ss -tlnp '( ${filter} )' 2>/dev/null | sed -n 's/.*pid=\\([0-9]*\\).*/\\1/p' | sort -u); if [ -n "$pids" ]; then echo "[supervisor] killing stale pids $pids"; kill $pids 2>/dev/null || true; sleep 2; fi`;
 }
+/**
+ * Sentinel appended to dsh-web.log immediately before a supervised restart.
+ *
+ * The log is append-only and carries no timestamps, so this line is the only
+ * durable ordering between "the previous boot's crash" and "this boot's
+ * output". Without it the health scan inherited the previous, failed boot's
+ * `EADDRINUSE` stack and rolled back a healthy, still-booting instance
+ * (incident 2026-09-13).
+ */
+export const BOOT_BOUNDARY_MARKER = '[supervisor] boot-boundary';
+/** The production dsh-web log (override with DSH_WEB_LOG for tests/tools). */
+export function dshWebLogPath() {
+    return process.env.DSH_WEB_LOG ?? path.join(os.homedir(), '.dsh/dsh-web.log');
+}
+/**
+ * Append the boot-boundary sentinel. Pass an explicit `logPath` in tests, or
+ * redirect with DSH_WEB_LOG. With no destination at all under VITEST this is a
+ * deliberate no-op so a unit test can never append to the operator's real log.
+ */
+export function markBootBoundary(logPath) {
+    const explicit = logPath ?? process.env.DSH_WEB_LOG;
+    if (explicit === undefined && process.env.VITEST)
+        return;
+    const p = explicit ?? dshWebLogPath();
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.appendFileSync(p, `${BOOT_BOUNDARY_MARKER} ${new Date().toISOString()}\n`);
+    }
+    catch { }
+}
 // LKG rollback copies each entry with fs.cpSync — an entry that resolves back
 // into itself (e.g. a symlink cycle reachable from ~/.dsh, observed in
 // production pointing into ~/.npm/_npx/.../node_modules/unist-util-position)
@@ -43,6 +73,9 @@ export function writePlannedRestart(ttlMs = 30000) {
         fs.chmodSync(p, 0o600);
     }
     catch { }
+    // The boundary belongs to the restart, not to the poller: every sanctioned
+    // restart path already writes this marker first.
+    markBootBoundary();
 }
 export function checkPlannedRestart(markerPath) {
     // Legacy path explicit: check mtime of that file
@@ -109,7 +142,7 @@ export function readRestartRequest() {
         if (typeof j.ts === 'number' && typeof j.ttl === 'number') {
             if (Date.now() - j.ts >= j.ttl)
                 return undefined;
-            return { ts: j.ts, ttl: j.ttl, callerSessionId: j.callerSessionId, reason: j.reason };
+            return { ts: j.ts, ttl: j.ttl, callerSessionId: j.callerSessionId, reason: j.reason, oldPid: j.oldPid };
         }
     }
     catch { }

package/lib/restart-tool.d.ts

@@ -12,7 +12,7 @@
  *      callerSessionId) that the supervisor daemon owns and acts on
  *      (out-of-band). This tool NEVER restarts the host in-tree.
  */
-import { writeRestartRequest } from './restart-guards.js';
+import { writeRestartRequest, readRestartRequest } from './restart-guards.js';
 /**
  * Copy a live profile tree for an isolated dry-boot. A naive recursive copy
  * breaks `link:` installs: their node_modules entries are relative symlinks
@@ -23,6 +23,32 @@ import { writeRestartRequest } from './restart-guards.js';
  * (the dry-boot must stay faithful, not fix the live tree).
  */
 export declare function copyProfileForDryBoot(srcDir: string, destDir: string): void;
+/**
+ * A dry-boot orphan candidate: a `dsh web` process rooted at a temp DSH_HOME
+ * with an ephemeral-port listener. Ports 3080/3081/3082 are the live tree and
+ * can never be candidates.
+ */
+export interface DryBootCandidate {
+    pid: number;
+    port: number;
+    dshHome: string;
+}
+export interface GcReaders {
+    readProc?: () => Array<{
+        pid: number;
+        cmd: string;
+        env: string;
+    }>;
+    ssPortsOf?: (pid: number) => number[];
+    selfPid?: number;
+}
+/**
+ * List dry-boot orphans: `dsh web` processes on a temp DSH_HOME holding an
+ * ephemeral 9000-9999 listener. Conjunctive fingerprint + absolute exclusions
+ * (self PID, live ports, real-home DSH_HOME) — a process is returned only when
+ * every signal agrees it is a disposable dry-boot.
+ */
+export declare function listDryBootCandidates(readers?: GcReaders): DryBootCandidate[];
 /**
  * Boot a copy of the live web profile on an isolated DSH_HOME and verify the
  * plugin tree loads and serves. Returns ok + a one-line detail for the tool
@@ -89,5 +115,8 @@ export declare function registerRestartTool(ctx: any, deps?: {
     sessionIdOf?: (exec: any) => string | undefined;
     dryBoot?: typeof dryBootVerify;
     writeRestartRequest?: typeof writeRestartRequest;
+    readRestartRequest?: typeof readRestartRequest;
     harnessRoot?: string;
+    gcReaders?: GcReaders;
+    killPid?: (pid: number, sig: string) => void;
 }): () => void;

package/lib/restart-tool.js

@@ -15,9 +15,10 @@
 import { join, dirname, resolve } from 'node:path';
 import { mkdtempSync, rmSync, cpSync, existsSync, readFileSync, readdirSync, statSync, lstatSync, readlinkSync, symlinkSync, unlinkSync } from 'node:fs';
 import { tmpdir, homedir } from 'node:os';
-import { spawn } from 'node:child_process';
+import { spawn, execFileSync } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { writeRestartRequest } from './restart-guards.js';
+import { writeRestartRequest, readRestartRequest } from './restart-guards.js';
+import { intentPath, readIntent, readRestartOutcome } from './intents.js';
 /**
  * Copy a live profile tree for an isolated dry-boot. A naive recursive copy
  * breaks `link:` installs: their node_modules entries are relative symlinks
@@ -50,6 +51,74 @@ export function copyProfileForDryBoot(srcDir, destDir) {
     };
     repair(destDir, '');
 }
+const LIVE_PORTS = new Set([3080, 3081, 3082]);
+function defaultReadProc() {
+    const out = [];
+    let names = [];
+    try {
+        names = readdirSync('/proc');
+    }
+    catch {
+        return out;
+    }
+    for (const name of names) {
+        if (!/^\d+$/.test(name))
+            continue;
+        try {
+            const cmd = readFileSync(`/proc/${name}/cmdline`, 'utf8').replace(/\0/g, ' ');
+            const env = readFileSync(`/proc/${name}/environ`, 'utf8');
+            out.push({ pid: Number(name), cmd, env });
+        }
+        catch { /* process exited mid-scan — ignore */ }
+    }
+    return out;
+}
+function defaultSsPortsOf(pid) {
+    try {
+        const out = execFileSync('ss', ['-tlnp'], { encoding: 'utf8' });
+        const ports = [];
+        for (const line of out.split('\n')) {
+            if (!line.includes(`pid=${pid},`))
+                continue;
+            const m = /:(\d+)\s/.exec(line);
+            if (m)
+                ports.push(Number(m[1]));
+        }
+        return ports;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List dry-boot orphans: `dsh web` processes on a temp DSH_HOME holding an
+ * ephemeral 9000-9999 listener. Conjunctive fingerprint + absolute exclusions
+ * (self PID, live ports, real-home DSH_HOME) — a process is returned only when
+ * every signal agrees it is a disposable dry-boot.
+ */
+export function listDryBootCandidates(readers = {}) {
+    const readProc = readers.readProc ?? defaultReadProc;
+    const ssPortsOf = readers.ssPortsOf ?? defaultSsPortsOf;
+    const selfPid = readers.selfPid ?? process.pid;
+    const out = [];
+    for (const p of readProc()) {
+        if (p.pid === selfPid)
+            continue;
+        if (!/bin\.ts web/.test(p.cmd))
+            continue;
+        const home = /^DSH_HOME=([^\0]*)/m.exec(p.env)?.[1] ?? '';
+        if (!home.startsWith(join(tmpdir(), 'dsh-dryboot-')))
+            continue;
+        const ports = ssPortsOf(p.pid);
+        if (ports.some(port => LIVE_PORTS.has(port)))
+            continue;
+        const eph = ports.filter(port => port >= 9000 && port <= 9999);
+        if (eph.length === 0)
+            continue;
+        out.push({ pid: p.pid, port: eph[0], dshHome: home });
+    }
+    return out;
+}
 /**
  * Boot a copy of the live web profile on an isolated DSH_HOME and verify the
  * plugin tree loads and serves. Returns ok + a one-line detail for the tool
@@ -237,8 +306,12 @@ function currentSessionId(exec, fallback) {
 export function registerRestartTool(ctx, deps = {}) {
     const doDryBoot = deps.dryBoot ?? dryBootVerify;
     const doWrite = deps.writeRestartRequest ?? writeRestartRequest;
+    const doRead = deps.readRestartRequest ?? readRestartRequest;
     const doSessionId = deps.sessionIdOf ?? currentSessionId;
     let dispose;
+    let disposeDryboot;
+    let disposeGc;
+    let disposeStatus;
     try {
         dispose = ctx.tools.register({
             name: 'dsh_web_restart',
@@ -256,6 +329,23 @@ export function registerRestartTool(ctx, deps = {}) {
                 render: (_args, value) => [{ type: 'text', text: value.detail }],
             },
             execute: async (args, exec) => {
+                // Serialize: a fresh restart-request marker means a restart is
+                // already in flight (another session, the daemon, or an earlier
+                // call of this tool). Scheduling another one overlaps the ~90s
+                // SIGTERM stop and crash-loops on EADDRINUSE — refuse fast, before
+                // the dry-boot gate, and point at the status tool instead.
+                let inflight;
+                try {
+                    inflight = doRead();
+                }
+                catch {
+                    inflight = undefined;
+                }
+                if (inflight !== undefined) {
+                    const by = inflight.callerSessionId ?? 'unknown session';
+                    const why = inflight.reason ? `: ${inflight.reason.slice(0, 120)}` : '';
+                    return { ok: false, detail: `restart already in progress (requested by ${by}${why}) — check dsh_web_restart_status instead of scheduling another` };
+                }
                 const harnessRoot = deps.harnessRoot ?? (await import('./paths.js')).resolveDeepseekHarnessDir();
                 const lkgDir = join(homedir(), '.dsh/.supervisor/lkg');
                 const changed = args.pluginChanged === true || (args.pluginChanged !== false && isPluginTreeChanged(harnessRoot, lkgDir));
@@ -270,9 +360,9 @@ export function registerRestartTool(ctx, deps = {}) {
                     // marker would be written but no restart would ever be supervised.
                     return { ok: false, detail: 'cannot identify the calling session — restart not scheduled' };
                 }
-                doWrite({ callerSessionId, reason: typeof args.reason === 'string' ? args.reason : undefined }, 180_000);
+                doWrite({ callerSessionId, reason: typeof args.reason === 'string' ? args.reason : undefined, oldPid: process.pid }, 180_000);
                 writeIntentSidecar(callerSessionId, args.reason);
-                return { ok: true, detail: `restart scheduled (≈30s) — caller ${callerSessionId}` };
+                return { ok: true, detail: `restart scheduled (≈30s) — caller ${callerSessionId}`, oldPid: process.pid, intentPath: intentPath(callerSessionId) };
             },
         });
     }
@@ -282,11 +372,135 @@ export function registerRestartTool(ctx, deps = {}) {
         }
         catch { }
     }
-    return () => { try {
-        if (typeof dispose === 'function')
-            dispose();
+    try {
+        disposeDryboot = ctx.tools.register({
+            name: 'dsh_web_dryboot',
+            description: 'Validate the plugin tree by booting a copy of the live profile on an ephemeral port. Never schedules or performs a restart; temp home removed afterwards.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    timeoutMs: { type: 'number', description: 'Gate timeout in ms (default 60000).' },
+                },
+                additionalProperties: false,
+            },
+            output: {
+                schema: { type: 'object', additionalProperties: true, properties: { ok: { type: 'boolean' }, detail: { type: 'string' } } },
+                render: (_args, value) => [{ type: 'text', text: value.detail }],
+            },
+            execute: async (args) => {
+                const harnessRoot = deps.harnessRoot ?? (await import('./paths.js')).resolveDeepseekHarnessDir();
+                const gate = await doDryBoot(harnessRoot, typeof args.timeoutMs === 'number' ? { timeoutMs: args.timeoutMs } : undefined);
+                return { ok: gate.ok, detail: gate.detail };
+            },
+        });
+    }
+    catch (e) {
+        try {
+            ctx.logger?.warn?.(`[supervisor] dsh_web_dryboot tool failed: ${e?.message ?? String(e)}`);
+        }
+        catch { }
     }
-    catch { } };
+    try {
+        const doKill = deps.killPid ?? ((pid, sig) => process.kill(pid, sig));
+        disposeGc = ctx.tools.register({
+            name: 'dsh_web_gc',
+            description: 'Reap orphaned dry-boot dsh web processes (temp DSH_HOME + ephemeral port). Preview-first: returns candidates without killing unless confirm:true.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    confirm: { type: 'boolean', description: 'Actually SIGKILL the candidates and verify they are gone.' },
+                },
+                additionalProperties: false,
+            },
+            output: {
+                schema: { type: 'object', additionalProperties: true, properties: { killed: { type: 'array' }, candidates: { type: 'array' } } },
+                render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+            },
+            execute: async (args) => {
+                // INVARIANT: kill only conjunctive-fingerprint dry-boots (temp DSH_HOME
+                // + ephemeral listener), never self / live ports / real-home processes.
+                // Preview is the default; killing requires explicit confirm:true.
+                const found = listDryBootCandidates(deps.gcReaders);
+                if (args.confirm !== true)
+                    return { killed: [], candidates: found };
+                const killed = [];
+                for (const c of found) {
+                    try {
+                        doKill(c.pid, 'SIGKILL');
+                    }
+                    catch { }
+                }
+                const remaining = listDryBootCandidates(deps.gcReaders);
+                const alive = new Set(remaining.map(c => c.pid));
+                for (const c of found) {
+                    if (!alive.has(c.pid))
+                        killed.push(c.pid);
+                }
+                return { killed, candidates: remaining };
+            },
+        });
+    }
+    catch (e) {
+        try {
+            ctx.logger?.warn?.(`[supervisor] dsh_web_gc tool failed: ${e?.message ?? String(e)}`);
+        }
+        catch { }
+    }
+    try {
+        disposeStatus = ctx.tools.register({
+            name: 'dsh_web_restart_status',
+            description: 'Read the outcome of the calling session\u2019s latest scheduled dsh web restart (pending until the daemon swaps and health-checks).',
+            parameters: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false,
+            },
+            output: {
+                schema: { type: 'object', additionalProperties: true },
+                render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+            },
+            execute: async (_args, exec) => {
+                const callerSessionId = doSessionId(exec);
+                if (!callerSessionId)
+                    return { state: 'none', detail: 'cannot identify the calling session' };
+                const outcome = readRestartOutcome(callerSessionId);
+                if (outcome)
+                    return { ...outcome };
+                const intent = readIntent(callerSessionId);
+                if (intent)
+                    return { state: 'pending', detail: 'restart scheduled, daemon has not reported back yet' };
+                return { state: 'none', detail: 'no restart scheduled for this session' };
+            },
+        });
+    }
+    catch (e) {
+        try {
+            ctx.logger?.warn?.(`[supervisor] dsh_web_restart_status tool failed: ${e?.message ?? String(e)}`);
+        }
+        catch { }
+    }
+    return () => {
+        try {
+            if (typeof dispose === 'function')
+                dispose();
+        }
+        catch { }
+        try {
+            if (typeof disposeDryboot === 'function')
+                disposeDryboot();
+        }
+        catch { }
+        try {
+            if (typeof disposeGc === 'function')
+                disposeGc();
+        }
+        catch { }
+        try {
+            if (typeof disposeStatus === 'function')
+                disposeStatus();
+        }
+        catch { }
+    };
 }
 function writeIntentSidecar(sessionId, reason) {
     try {

package/lib/restart-web.d.ts

@@ -0,0 +1,26 @@
+import { type BootLockDeps } from './boot-lock.js';
+/** Boot budget: how long a boot may take before its failures are judged. */
+export declare const DEFAULT_BOOT_GRACE_MS = 180000;
+export interface RestartWebDeps {
+    exec?: (cmd: string, opts?: {
+        timeout?: number;
+    }) => void;
+    writeMarker?: (ttlMs?: number) => void;
+    serializedRestart?: () => Promise<void>;
+    startViaSystemd?: () => void;
+    spawnNohup?: () => void | Promise<void>;
+    unitExists?: () => boolean;
+    bootGraceMs?: number;
+    lock?: BootLockDeps;
+}
+export interface RestartWebResult {
+    restarted: boolean;
+    reason?: string;
+}
+/**
+ * The single implementation of a supervised dsh web restart. Single-flight:
+ * boot.lock is held from before the marker is written until the port answers,
+ * so a racing tick or a second rollback skips instead of producing the second
+ * systemd start that turned the incident's log tail toxic (2026-09-13).
+ */
+export declare function performSingleBootRestart(deps?: RestartWebDeps): Promise<RestartWebResult>;

package/lib/restart-web.js

@@ -0,0 +1,58 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { buildKillStalePortsCommand, writePlannedRestart } from './restart-guards.js';
+import { serializedSystemdRestart, shouldUseNohupFallback, systemdUnitExists } from './restart-exec.js';
+import { withBootLock } from './boot-lock.js';
+import { resolveDeepseekHarnessDir } from './paths.js';
+/** Boot budget: how long a boot may take before its failures are judged. */
+export const DEFAULT_BOOT_GRACE_MS = 180_000;
+/**
+ * The single implementation of a supervised dsh web restart. Single-flight:
+ * boot.lock is held from before the marker is written until the port answers,
+ * so a racing tick or a second rollback skips instead of producing the second
+ * systemd start that turned the incident's log tail toxic (2026-09-13).
+ */
+export async function performSingleBootRestart(deps = {}) {
+    const grace = deps.bootGraceMs ?? DEFAULT_BOOT_GRACE_MS;
+    const outcome = await withBootLock(async () => {
+        // Marker first, and inside the lock: every poll during the boot must know a
+        // restart is in flight, and the TTL is the boot budget — not 30 s (D5).
+        ;
+        (deps.writeMarker ?? writePlannedRestart)(grace);
+        const { execSync } = await import('node:child_process');
+        const exec = deps.exec ?? ((cmd, opts) => {
+            execSync(cmd, { timeout: opts?.timeout ?? 15_000, stdio: 'pipe' });
+        });
+        // A stale MainThread holding :3080/:3082 survives an EADDRINUSE crash with
+        // http 200 still served, so the new start would lose the race.
+        try {
+            exec(buildKillStalePortsCommand(), { timeout: 5000 });
+        }
+        catch { }
+        try {
+            await (deps.serializedRestart ?? (() => serializedSystemdRestart()))();
+            return;
+        }
+        catch { }
+        try {
+            ;
+            (deps.startViaSystemd ?? (() => exec('systemctl --user start dsh-web.service', { timeout: 15_000 })))();
+            return;
+        }
+        catch { }
+        const unitExists = (deps.unitExists ?? systemdUnitExists)();
+        if (!shouldUseNohupFallback(unitExists)) {
+            throw new Error('systemd manages dsh-web.service but start failed — refusing the direct-node fallback (it would create a second boot)');
+        }
+        await (deps.spawnNohup ?? defaultNohup)();
+    }, deps.lock ?? {});
+    if (!outcome.acquired)
+        return { restarted: false, reason: 'another boot already holds boot.lock' };
+    return { restarted: true };
+}
+async function defaultNohup() {
+    const { execSync } = await import('node:child_process');
+    const harnessRoot = resolveDeepseekHarnessDir();
+    const logPath = path.join(os.homedir(), '.dsh/dsh-web.log');
+    execSync(`setsid nohup bash -c 'export NVM_DIR="$HOME/.nvm"; [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"; cd ${JSON.stringify(harnessRoot)} && exec node --import tsx/esm apps/cli/src/bin.ts web --no-open >> ${JSON.stringify(logPath)} 2>&1' &`, { timeout: 5000 });
+}

package/lib/resume.d.ts

@@ -6,6 +6,16 @@ export interface FindInterruptedOpts {
     withinMs?: number;
     sinceMs?: number;
 }
+/**
+ * Resolve the readable session log inside one session directory across
+ * format generations. `session.v3.jsonl.zstd` is the current successor;
+ * `session.jsonl.zstd` / `session.jsonl` remain for committed older
+ * generations (migrations never move or delete them). Prefer v3 when
+ * present — live sessions persist there, and a scan that only knows the
+ * old names silently skips every current session (2026-09-11: auto-resume
+ * found nothing after a restart, so no recovery continue was triggered).
+ */
+export declare function resolveSessionLogPath(dir: string): string | undefined;
 export declare function findInterrupted(dshHome?: string, opts?: FindInterruptedOpts): Promise<ResumeResult>;
 /**
  * Detect sessions whose raw log ends with a `turn/start` that has no

package/lib/resume.js

@@ -1,6 +1,27 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+/**
+ * Resolve the readable session log inside one session directory across
+ * format generations. `session.v3.jsonl.zstd` is the current successor;
+ * `session.jsonl.zstd` / `session.jsonl` remain for committed older
+ * generations (migrations never move or delete them). Prefer v3 when
+ * present — live sessions persist there, and a scan that only knows the
+ * old names silently skips every current session (2026-09-11: auto-resume
+ * found nothing after a restart, so no recovery continue was triggered).
+ */
+export function resolveSessionLogPath(dir) {
+    const v3 = path.join(dir, 'session.v3.jsonl.zstd');
+    if (fs.existsSync(v3))
+        return v3;
+    const zstd = path.join(dir, 'session.jsonl.zstd');
+    if (fs.existsSync(zstd))
+        return zstd;
+    const jsonl = path.join(dir, 'session.jsonl');
+    if (fs.existsSync(jsonl))
+        return jsonl;
+    return undefined;
+}
 /**
  * Read the last ~100 lines of one session's raw log, applying the mtime
  * pre-filter before any (potentially expensive) zstd decompression: a
@@ -13,27 +34,26 @@ import * as os from 'node:os';
  * @returns `undefined` when the session has no log file, or is filtered
  *   out by `sinceMs` — callers must treat that the same as "nothing found".
  */
-async function readSessionTailLines(zstdPath, jsonlPath, sinceMs) {
+async function readSessionTailLines(logPath, sinceMs) {
+    if (logPath === undefined)
+        return undefined;
     if (sinceMs !== undefined) {
         try {
-            const statPath = fs.existsSync(zstdPath) ? zstdPath : (fs.existsSync(jsonlPath) ? jsonlPath : undefined);
-            if (statPath) {
-                const mtimeMs = fs.statSync(statPath).mtimeMs;
-                if (mtimeMs < sinceMs)
-                    return undefined;
-            }
+            if (fs.statSync(logPath).mtimeMs < sinceMs)
+                return undefined;
         }
         catch { }
     }
-    if (fs.existsSync(zstdPath)) {
+    if (logPath.endsWith('.zstd')) {
         const { execSync } = await import('node:child_process');
-        const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null | tail -100`, { encoding: 'utf-8' });
+        const out = execSync(`zstd -d -c ${JSON.stringify(logPath)} 2>/dev/null | tail -100`, { encoding: 'utf-8' });
         return out.split('\n').filter(Boolean);
     }
-    if (fs.existsSync(jsonlPath)) {
-        const content = fs.readFileSync(jsonlPath, 'utf-8');
+    try {
+        const content = fs.readFileSync(logPath, 'utf-8');
         return content.trim().split('\n').slice(-100);
     }
+    catch { }
     return undefined;
 }
 export async function findInterrupted(dshHome, opts) {
@@ -55,10 +75,9 @@ export async function findInterrupted(dshHome, opts) {
                 if (!s.isDirectory())
                     continue;
                 scanned++;
-                const zstdPath = path.join(groupPath, s.name, 'session.jsonl.zstd');
-                const jsonlPath = path.join(groupPath, s.name, 'session.jsonl');
+                const logPath = resolveSessionLogPath(path.join(groupPath, s.name));
                 try {
-                    const lines = await readSessionTailLines(zstdPath, jsonlPath, sinceMs);
+                    const lines = await readSessionTailLines(logPath, sinceMs);
                     if (lines === undefined)
                         continue;
                     let found = false;
@@ -103,31 +122,30 @@ export async function findInterrupted(dshHome, opts) {
  * The mtime pre-filter ensures this full decompression runs only for
  * recent sessions (within 5m, typically 1-2 files), not for all 425.
  */
-async function readSessionAllLines(zstdPath, jsonlPath, sinceMs) {
+async function readSessionAllLines(logPath, sinceMs) {
+    if (logPath === undefined)
+        return undefined;
     if (sinceMs !== undefined) {
         try {
-            const statPath = fs.existsSync(zstdPath) ? zstdPath : (fs.existsSync(jsonlPath) ? jsonlPath : undefined);
-            if (statPath) {
-                const mtimeMs = fs.statSync(statPath).mtimeMs;
-                if (mtimeMs < sinceMs)
-                    return undefined;
-            }
+            if (fs.statSync(logPath).mtimeMs < sinceMs)
+                return undefined;
         }
         catch { }
     }
-    if (fs.existsSync(zstdPath)) {
+    if (logPath.endsWith('.zstd')) {
         const { execSync } = await import('node:child_process');
         // maxBuffer must exceed the decompressed size of any real session log —
         // worker sessions decode to 8-23MB while execSync's default 1MB would
         // throw ENOBUFS and silently drop the session from every scan that needs
         // the full file (findDanglingOpenTurns). Use 64MB to leave headroom.
-        const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null`, { encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 });
+        const out = execSync(`zstd -d -c ${JSON.stringify(logPath)} 2>/dev/null`, { encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 });
         return out.split('\n').filter(Boolean);
     }
-    if (fs.existsSync(jsonlPath)) {
-        const content = fs.readFileSync(jsonlPath, 'utf-8');
+    try {
+        const content = fs.readFileSync(logPath, 'utf-8');
         return content.trim().split('\n').filter(Boolean);
     }
+    catch { }
     return undefined;
 }
 /**
@@ -162,10 +180,9 @@ export async function findDanglingOpenTurns(dshHome, opts) {
                 if (!s.isDirectory())
                     continue;
                 scanned++;
-                const zstdPath = path.join(groupPath, s.name, 'session.jsonl.zstd');
-                const jsonlPath = path.join(groupPath, s.name, 'session.jsonl');
+                const logPath = resolveSessionLogPath(path.join(groupPath, s.name));
                 try {
-                    const lines = await readSessionAllLines(zstdPath, jsonlPath, sinceMs);
+                    const lines = await readSessionAllLines(logPath, sinceMs);
                     if (lines === undefined)
                         continue;
                     let openTurn;