@ddtcorex/dsh-maestro-supervisor 0.7.6 → 0.7.7

package/lib/plugin.d.ts

@@ -7,6 +7,7 @@
  */
 import { findInterrupted as defaultFindInterrupted, findDanglingOpenTurns as defaultFindDanglingOpenTurns } from './resume.js';
 import type { RestartIntent } from './intents.js';
+import { type ResumeLogEntry } from './resume-log.js';
 import { runSessionHealthCheck } from './session-health.js';
 export * from './resume-tools.js';
 export declare const inject: readonly ["sessions", "agents", "connection", "tools", "skills"];
@@ -69,6 +70,7 @@ export declare function runAutoResume(ctx: any, opts?: {
     findInterrupted?: typeof defaultFindInterrupted;
     findDanglingOpenTurns?: typeof defaultFindDanglingOpenTurns;
     resumeInterrupted?: typeof resumeInterrupted;
+    logResume?: (entry: ResumeLogEntry) => void;
     config?: SupervisorPluginConfig;
 }): Promise<void>;
 export declare function resumeInterrupted(ctx: any, ids: string[], deps?: {
@@ -78,6 +80,7 @@ export declare function resumeInterrupted(ctx: any, ids: string[], deps?: {
     resolveToolScope?: ToolScopeResolver;
     notify?: (line: string) => Promise<void>;
     injectSessionMessage?: (sessionId: string, content: string) => unknown;
+    logResume?: (entry: ResumeLogEntry) => void;
     config?: SupervisorPluginConfig;
 }): Promise<string[]>;
 export declare function createResumeRpcHandler(ctx: any, opts?: {

package/lib/plugin.js

@@ -11,6 +11,7 @@ import * as os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { findInterrupted as defaultFindInterrupted, findDanglingOpenTurns as defaultFindDanglingOpenTurns } from './resume.js';
 import { readIntent, consumeIntent } from './intents.js';
+import { appendResumeLog } from './resume-log.js';
 import { makeSkillProvider } from './skill-provider.js';
 import { registerRestartTool } from './restart-tool.js';
 import { makePreExecuteGuard } from './self-kill-guard.js';
@@ -214,8 +215,13 @@ export async function runAutoResume(ctx, opts = {}) {
         const doFind = opts.findInterrupted ?? defaultFindInterrupted;
         const doFindDangling = opts.findDanglingOpenTurns ?? defaultFindDanglingOpenTurns;
         const doResume = opts.resumeInterrupted ?? resumeInterrupted;
+        const doLog = opts.logResume ?? ((entry) => { try {
+            appendResumeLog(entry);
+        }
+        catch { } });
         if (!getAutoResumeEnabled(opts?.config)) {
             ctx.logger?.info?.('[supervisor] auto-resume disabled — skip');
+            doLog({ ts: Date.now(), kind: 'scan', scanned: 0, interrupted: [], detail: 'auto-resume disabled' });
             return;
         }
         const withinMs = getResumeWithinMs(opts?.config);
@@ -233,12 +239,16 @@ export async function runAutoResume(ctx, opts = {}) {
             ctx.logger?.warn?.(`[supervisor] auto-resume: dangling-open-turn scan failed, continuing with closed-turn results only: ${e?.message ?? String(e)}`);
         }
         const merged = Array.from(new Set([...interrupted, ...dangling]));
+        doLog({ ts: Date.now(), kind: 'scan', scanned, interrupted: merged, detail: `withinMs=${withinMs}` });
         if (!merged.length) {
             ctx.logger?.info?.(`[supervisor] auto-resume: 0/${scanned} interrupted within ${withinMs}ms — nothing to do`);
             return;
         }
         ctx.logger?.info?.(`[supervisor] auto-resume: ${merged.length}/${scanned} interrupted within ${withinMs}ms: ${merged.slice(0, 3).join(', ')}`);
-        await doResume(ctx, merged, { ...(opts?.config !== undefined ? { config: opts.config } : {}) });
+        await doResume(ctx, merged, {
+            ...(opts?.config !== undefined ? { config: opts.config } : {}),
+            ...(opts.logResume !== undefined ? { logResume: opts.logResume } : {}),
+        });
     }
     catch (e) {
         try {
@@ -252,6 +262,10 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
     const doConsumeIntent = deps.consumeIntent ?? consumeIntent;
     const doProbe = deps.probeToolView ?? probeToolView;
     const doResolveToolScope = deps.resolveToolScope ?? defaultResolveToolScope;
+    const doLog = deps.logResume ?? ((entry) => { try {
+        appendResumeLog(entry);
+    }
+    catch { } });
     const coreToolPolicy = getResumeCoreToolPolicy(deps.config);
     const resumed = [];
     for (const id of ids) {
@@ -286,6 +300,7 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
             }
             if (typeof agent?.followup !== 'function') {
                 ctx.logger?.warn?.(`[supervisor] auto-resume: no live agent available for ${id}`);
+                doLog({ ts: Date.now(), sessionId, kind: 'no-agent', detail: 'agents.resume returned no followup-capable handle' });
                 continue;
             }
             // Ensure bash tool is registered before followup — initial resume header with
@@ -337,10 +352,13 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
             // message instead of the generic "outcome unknown" recovery prompt, then
             // consume the sidecar so it cannot re-trigger on a later resume.
             let resumeMessage = idleMessage;
+            let intentReason = '';
             try {
                 const intent = doReadIntent(sessionId);
-                if (intent)
-                    resumeMessage = `You requested a dsh web restart${intent.reason ? ` (reason: ${intent.reason})` : ''} and it completed. Do NOT call dsh_web_restart again. Verify current state if needed, then continue the original task.`;
+                if (intent) {
+                    intentReason = intent.reason ?? '';
+                    resumeMessage = `You requested a dsh web restart${intentReason ? ` (reason: ${intentReason})` : ''} and it completed. Do NOT call dsh_web_restart again. Verify current state if needed, then continue the original task.`;
+                }
             }
             catch { }
             agent.followup(createUserMessage({
@@ -354,6 +372,12 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
             catch { }
             resumed.push(id);
             ctx.logger?.info?.(`[supervisor] auto-resume: sent recovery continue for ${id}`);
+            doLog({
+                ts: Date.now(),
+                sessionId,
+                kind: 'resumed',
+                detail: resumeMessage === idleMessage ? 'idle-recovery-prompt' : `restart-intent:${intentReason.slice(0, 100)}`,
+            });
             // C1 observability probe — snapshot the resumed session's SCOPED tool
             // view at the success point so a post-resume bash loss surfaces in the
             // journal the moment it happens (Part D reads this line). Defensive:
@@ -379,6 +403,7 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
         }
         catch (e) {
             ctx.logger?.warn?.(`[supervisor] auto-resume failed ${id}: ${e?.message ?? String(e)}`);
+            doLog({ ts: Date.now(), sessionId: String(id).split('/').pop() ?? String(id), kind: 'resume-failed', error: e?.message ?? String(e) });
         }
     }
     return resumed;

package/lib/resume-log.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Durable out-of-band resume log (`~/.dsh/.supervisor/resume.log.jsonl`).
+ *
+ * The in-tree supervisor's `ctx.logger` output does not reach `dsh-web.log`
+ * (it goes to the per-session console), which made every `agents.resume`
+ * failure invisible on real machines — the 2026-09-02 investigation only
+ * recovered the pattern ("last successful continue 12:00Z, then 5 restarts
+ * with none", `lastResumeProbe: null`, unconsumed intents) by scanning the
+ * session logs. This append-only JSONL sidecar gives a machine-local audit
+ * trail of resume outcomes that survives no matter where plugin logs land.
+ * Never throws: a write failure must not break the resume path.
+ */
+export interface ResumeLogEntry {
+    ts: number;
+    sessionId?: string;
+    kind: 'scan' | 'resume-failed' | 'resumed' | 'no-agent';
+    error?: string;
+    detail?: string;
+    scanned?: number;
+    interrupted?: string[];
+}
+export declare function resumeLogPath(): string;
+export declare function appendResumeLog(entry: ResumeLogEntry): void;

package/lib/resume-log.js

@@ -0,0 +1,18 @@
+import { appendFileSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export function resumeLogPath() {
+    return join(homedir(), '.dsh', '.supervisor', 'resume.log.jsonl');
+}
+export function appendResumeLog(entry) {
+    try {
+        const p = resumeLogPath();
+        mkdirSync(join(homedir(), '.dsh', '.supervisor'), { recursive: true });
+        appendFileSync(p, JSON.stringify(entry) + '\n', 'utf8');
+        try {
+            chmodSync(p, 0o600);
+        }
+        catch { }
+    }
+    catch { }
+}

package/lib/resume.js

@@ -117,7 +117,11 @@ async function readSessionAllLines(zstdPath, jsonlPath, sinceMs) {
     }
     if (fs.existsSync(zstdPath)) {
         const { execSync } = await import('node:child_process');
-        const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null`, { encoding: 'utf-8' });
+        // 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 });
         return out.split('\n').filter(Boolean);
     }
     if (fs.existsSync(jsonlPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddtcorex/dsh-maestro-supervisor",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
   "main": "./lib/index.js",