@ddtcorex/dsh-maestro-supervisor 0.7.8 → 0.7.10

package/lib/plugin.d.ts

@@ -73,6 +73,27 @@ export declare function runAutoResume(ctx: any, opts?: {
     logResume?: (entry: ResumeLogEntry) => void;
     config?: SupervisorPluginConfig;
 }): Promise<void>;
+export interface RecoveredRoute {
+    provider: string;
+    model: string;
+}
+/**
+ * Recover the provider/model route a resumed agent needs for its
+ * `{{model}}` persona variable: handle seam first, raw session log as
+ * fallback. Returns `undefined` only for genuinely corrupt/routeless
+ * sessions, which the caller skips instead of resuming.
+ */
+export declare function recoverAgentOptions(input: {
+    persistence: any;
+    sid: unknown;
+    sessionsRoot: string;
+    group: string;
+    sessionId: string;
+    logger?: {
+        warn?: (msg: string) => void;
+    };
+    id: string;
+}): Promise<RecoveredRoute | undefined>;
 export declare function resumeInterrupted(ctx: any, ids: string[], deps?: {
     readIntent?: (id: string) => RestartIntent | undefined;
     consumeIntent?: (id: string) => void;

package/lib/plugin.js

@@ -257,6 +257,98 @@ export async function runAutoResume(ctx, opts = {}) {
         catch { }
     }
 }
+function routeFromEvents(events) {
+    if (!Array.isArray(events))
+        return undefined;
+    const context = [...events].reverse().find((event) => event?.type === 'request/context')?.data;
+    if (typeof context?.provider === 'string' && typeof context?.model === 'string') {
+        return { provider: context.provider, model: context.model };
+    }
+    return undefined;
+}
+/**
+ * Route recovery through the handle seam (`open(id, 'read')` + `read(0)`).
+ * A `read` handle never takes ownership, so this works while another handle
+ * or process holds `write`. Replaces the removed `persistence.load(id)`
+ * API (gone since DSH's handle-based persistence seam) — calling `load`
+ * now resolves to `undefined` and every resumed agent would lose its
+ * provider/model.
+ */
+async function readRouteFromHandle(persistence, sid) {
+    const handle = await persistence?.open?.(sid, 'read');
+    if (handle === undefined || handle === null)
+        return undefined;
+    try {
+        return routeFromEvents(await handle.read(0));
+    }
+    finally {
+        try {
+            await handle.close?.();
+        }
+        catch { }
+    }
+}
+/**
+ * Raw-log fallback when the backend cannot open the session: stream the
+ * stored log for the first `request/context` line. `grep -m1` stops at the
+ * first match so huge logs cost one streamed pass, not a full decode.
+ */
+async function readRouteFromRawLog(sessionsRoot, group, sessionId) {
+    const zstdPath = path.join(sessionsRoot, group, sessionId, 'session.jsonl.zstd');
+    const jsonlPath = path.join(sessionsRoot, group, sessionId, 'session.jsonl');
+    try {
+        if (fs.existsSync(zstdPath)) {
+            const { execSync } = await import('node:child_process');
+            const out = execSync(`zstd -d -c ${JSON.stringify(zstdPath)} 2>/dev/null | grep -a -m1 '"type":"request/context"'`, { encoding: 'utf-8' });
+            const line = out.split('\n').find((l) => l.includes('request/context'));
+            if (line !== undefined) {
+                try {
+                    return routeFromEvents([JSON.parse(line)]);
+                }
+                catch { }
+            }
+            return undefined;
+        }
+        if (fs.existsSync(jsonlPath)) {
+            const content = fs.readFileSync(jsonlPath, 'utf-8');
+            for (const line of content.split('\n')) {
+                if (!line.includes('"request/context"'))
+                    continue;
+                try {
+                    const route = routeFromEvents([JSON.parse(line)]);
+                    if (route !== undefined)
+                        return route;
+                }
+                catch { }
+            }
+        }
+    }
+    catch { }
+    return undefined;
+}
+/**
+ * Recover the provider/model route a resumed agent needs for its
+ * `{{model}}` persona variable: handle seam first, raw session log as
+ * fallback. Returns `undefined` only for genuinely corrupt/routeless
+ * sessions, which the caller skips instead of resuming.
+ */
+export async function recoverAgentOptions(input) {
+    try {
+        const viaHandle = await readRouteFromHandle(input.persistence, input.sid);
+        if (viaHandle !== undefined)
+            return viaHandle;
+    }
+    catch (e) {
+        input.logger?.warn?.(`[supervisor] auto-resume: could not recover route for ${input.id}: ${e?.message ?? String(e)}`);
+    }
+    try {
+        return await readRouteFromRawLog(input.sessionsRoot, input.group, input.sessionId);
+    }
+    catch (e) {
+        input.logger?.warn?.(`[supervisor] auto-resume: could not recover route for ${input.id}: ${e?.message ?? String(e)}`);
+        return undefined;
+    }
+}
 export async function resumeInterrupted(ctx, ids, deps = {}) {
     const doReadIntent = deps.readIntent ?? readIntent;
     const doConsumeIntent = deps.consumeIntent ?? consumeIntent;
@@ -277,22 +369,22 @@ export async function resumeInterrupted(ctx, ids, deps = {}) {
                 const { SessionId } = await import('@deepseek-ai/dsh-session').catch(() => ({ SessionId: (s) => s }));
                 const sid = SessionId ? SessionId(sessionId) : sessionId;
                 const persistence = ctx.get?.('sessionPersistence') ?? ctx.sessionPersistence;
-                let agentOptions;
-                try {
-                    const loaded = await persistence?.load?.(sessionId);
-                    const context = Array.isArray(loaded?.events)
-                        ? [...loaded.events].reverse().find((event) => event?.type === 'request/context')?.data
-                        : undefined;
-                    if (typeof context?.provider === 'string' && typeof context?.model === 'string') {
-                        agentOptions = { provider: context.provider, model: context.model };
-                    }
-                }
-                catch (e) {
-                    ctx.logger?.warn?.(`[supervisor] auto-resume: could not recover route for ${id}: ${e?.message ?? String(e)}`);
+                const sessionsRoot = deps.config?.sessionLogRoot ?? path.join(os.homedir(), '.dsh', 'sessions');
+                const group = id.slice(0, Math.max(0, id.length - sessionId.length - 1));
+                const agentOptions = await recoverAgentOptions({ persistence, sid, sessionsRoot, group, sessionId, logger: ctx.logger, id });
+                if (agentOptions === undefined) {
+                    // Resuming without a provider/model builds an agent whose
+                    // {{model}} persona variable has no value, so the very next turn
+                    // fails with `prompt variable "{{model}}" has no value for this
+                    // assembly (section "deployment:persona")`. Skip corrupt/routeless
+                    // sessions instead of triggering a continue that can only fail.
+                    ctx.logger?.warn?.(`[supervisor] auto-resume: skipping ${id} — no provider/model recovered (corrupt or routeless session)`);
+                    doLog({ ts: Date.now(), sessionId, kind: 'resume-failed', error: 'missing provider/model: persistence has no request/context route — skipping corrupt/routeless session' });
+                    continue;
                 }
                 const handle = await agents?.resume?.({
                     resumeSessionId: sid,
-                    ...(agentOptions === undefined ? {} : { agentOptions }),
+                    agentOptions,
                 });
                 agent = handle?.agent;
                 if (agent !== undefined)

package/lib/restart-tool.d.ts

@@ -13,6 +13,16 @@
  *      (out-of-band). This tool NEVER restarts the host in-tree.
  */
 import { writeRestartRequest } 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
+ * (e.g. `../../../shared/pkg`) that resolve against the copy location and
+ * dangle. Every symlink left dangling by the copy is rewritten to the
+ * absolute live target it pointed at, so the dry-boot loads the same code
+ * the live tree loads. Links already broken in the live tree are left alone
+ * (the dry-boot must stay faithful, not fix the live tree).
+ */
+export declare function copyProfileForDryBoot(srcDir: string, destDir: string): void;
 /**
  * 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

package/lib/restart-tool.js

@@ -12,12 +12,44 @@
  *      callerSessionId) that the supervisor daemon owns and acts on
  *      (out-of-band). This tool NEVER restarts the host in-tree.
  */
-import { join } from 'node:path';
-import { mkdtempSync, rmSync, cpSync, existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+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 { createRequire } from 'node:module';
 import { writeRestartRequest } 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
+ * (e.g. `../../../shared/pkg`) that resolve against the copy location and
+ * dangle. Every symlink left dangling by the copy is rewritten to the
+ * absolute live target it pointed at, so the dry-boot loads the same code
+ * the live tree loads. Links already broken in the live tree are left alone
+ * (the dry-boot must stay faithful, not fix the live tree).
+ */
+export function copyProfileForDryBoot(srcDir, destDir) {
+    cpSync(srcDir, destDir, { recursive: true, preserveTimestamps: true });
+    const repair = (dir, rel) => {
+        for (const name of readdirSync(dir)) {
+            const p = join(dir, name);
+            const r = rel ? `${rel}/${name}` : name;
+            const st = lstatSync(p);
+            if (st.isSymbolicLink()) {
+                if (!existsSync(p)) {
+                    const liveTarget = resolve(srcDir, dirname(r), readlinkSync(p));
+                    if (existsSync(liveTarget)) {
+                        unlinkSync(p);
+                        symlinkSync(liveTarget, p);
+                    }
+                }
+            }
+            else if (st.isDirectory()) {
+                repair(p, r);
+            }
+        }
+    };
+    repair(destDir, '');
+}
 /**
  * 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
@@ -39,7 +71,7 @@ export async function dryBootVerify(harnessRoot, opts = {}) {
     const logs = [];
     let child = null;
     try {
-        cpSync(liveProfile, join(tmpHome, 'profiles', 'web'), { recursive: true, preserveTimestamps: true });
+        copyProfileForDryBoot(liveProfile, join(tmpHome, 'profiles', 'web'));
         const port = String(9000 + Math.floor(Math.random() * 1000));
         const url = `http://127.0.0.1:${port}/`;
         child = spawn('node', ['--import', 'tsx/esm', 'apps/cli/src/bin.ts', 'web', '--no-open', '--port', port], {

package/package.json

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