@ddtcorex/dsh-maestro-supervisor 0.7.2 → 0.7.4

package/lib/debug-agent.d.ts

@@ -5,12 +5,10 @@ export interface DebugAgentOpts {
         httpCode?: number;
     };
     cooldownMs?: number;
-    fetchLLM?: (prompt: string) => Promise<string>;
     exec?: (cmd: string, opts?: any) => string;
     readFile?: (path: string) => string;
     writeFile?: (path: string, content: string) => void;
     dryBoot?: () => Promise<boolean>;
-    getCredentials?: () => Promise<string | null>;
 }
 export declare function runDebugAgent(opts: DebugAgentOpts): Promise<{
     fixed: boolean;

package/lib/debug-agent.js

@@ -16,27 +16,13 @@ export async function runDebugAgent(opts) {
     const readFile = opts.readFile ?? defaultReadFile;
     const writeFile = opts.writeFile ?? defaultWriteFile;
     const dryBoot = opts.dryBoot ?? defaultDryBoot;
-    const fetchLLM = opts.fetchLLM ?? defaultFetchLLM;
-    // Gather context
-    let report = '';
-    try {
-        report = readFile(opts.reportPath);
-    }
-    catch { }
     const err = opts.health.error ?? '';
-    let gitDiff = '';
-    try {
-        gitDiff = exec('git diff --stat 2>&1 | head -30', { timeout: 5000 });
-    }
-    catch {
-        gitDiff = '';
-    }
-    // Deterministic auto-fix for known patterns before LLM
+    // Deterministic auto-fix for known patterns
     try {
         await autoFixKnownPatterns(err, exec, readFile, writeFile);
     }
     catch { }
-    // Phase 1: reproduce — dryBoot check (if transient, already fixed)
+    // Reproduce — dryBoot check (if transient, already fixed)
     try {
         const ok = await dryBoot();
         if (ok) {
@@ -44,36 +30,8 @@ export async function runDebugAgent(opts) {
         }
     }
     catch { }
-    // Phase 2 & 3: LLM systematic-debugging (only if dryBoot failed)
-    const prompt = buildPrompt({ report, err, gitDiff, reportPath: opts.reportPath });
-    try {
-        const llmResponse = await fetchLLM(prompt);
-        // Try to apply LLM-suggested fix if it contains file+content
-        const applied = tryApplyLLMFix(llmResponse, writeFile, exec);
-        // Verify after apply
-        try {
-            exec('pnpm verify --silent 2>&1 | head -20', { timeout: 15000 });
-        }
-        catch { }
-        const ok2 = await dryBoot().catch(() => false);
-        if (ok2) {
-            const summary = extractSummary(llmResponse);
-            return { fixed: true, reason: `LLM fixed (attempt ${attempts}): ${summary}` };
-        }
-        // LLM responded but still not fixed
-        if (applied) {
-            return { fixed: false, reason: `LLM applied fix but dry-boot still fails (attempt ${attempts}) — ${extractSummary(llmResponse).slice(0, 120)}` };
-        }
-    }
-    catch (e) {
-        const msg = e?.message ?? String(e);
-        // If LLM unavailable, fall through to manual reason
-        if (msg.includes('no api key') || msg.includes('LLM')) {
-            return { fixed: false, reason: `would debug ${opts.reportPath} (attempt ${attempts}) — LLM not configured: ${msg}` };
-        }
-        return { fixed: false, reason: `would debug ${opts.reportPath} (attempt ${attempts}) — LLM error: ${msg}` };
-    }
-    return { fixed: false, reason: `would debug ${opts.reportPath} (attempt ${attempts}) — LLM not wired, manual fix needed` };
+    // No LLM auto-debug: deterministic auto-fix + dry-boot already tried — hand off to a human.
+    return { fixed: false, reason: `would debug ${opts.reportPath} (attempt ${attempts}) — manual fix needed (deterministic auto-fix + dry-boot already tried)` };
 }
 async function autoFixKnownPatterns(err, exec, readFile, writeFile) {
     const { resolveHarnessRoot } = await import('./paths.js');
@@ -129,78 +87,6 @@ async function autoFixKnownPatterns(err, exec, readFile, writeFile) {
         return;
     }
 }
-function buildPrompt(ctx) {
-    return [
-        'systematic-debugging — DSH Web crash auto-fix',
-        '',
-        'Phase 1: Root Cause Investigation. Read error carefully, reproduce, check recent changes.',
-        `Report: ${ctx.reportPath}`,
-        `Health error: ${ctx.err}`,
-        `Report snippet: ${ctx.report.slice(0, 2000)}`,
-        `Git diff: ${ctx.gitDiff.slice(0, 1500)}`,
-        '',
-        'Task: Propose minimal single-file fix. Respond as JSON: {"analysis":"...","file":"<abs path>","content":"<full file content or patch>"}',
-        'If unsure, explain analysis and suggest manual step.',
-    ].join('\n');
-}
-function tryApplyLLMFix(response, writeFile, exec) {
-    try {
-        // First try to extract inner JSON if response is OpenAI wrapper (choices) — unwrap message.content
-        let candidate = response;
-        try {
-            const outer = JSON.parse(response);
-            if (outer.choices?.[0]?.message?.content)
-                candidate = outer.choices[0].message.content;
-            else if (outer.output) {
-                // openai-responses wrapper: find message with output_text
-                const msg = outer.output.find((o) => o.type === 'message' && o.content?.[0]?.text);
-                if (msg)
-                    candidate = msg.content[0].text;
-            }
-        }
-        catch { }
-        // Also handle case where response is already the inner JSON string or contains it
-        const jsonMatch = candidate.match(/\{[\s\S]*\}/);
-        if (!jsonMatch)
-            return false;
-        const obj = JSON.parse(jsonMatch[0]);
-        if (obj.file && obj.content) {
-            writeFile(obj.file, obj.content);
-            // try to verify after write
-            try {
-                exec(`pnpm --dir ${obj.file.split('/packages/')[0] || '.'} verify --silent 2>&1 | head -10`, { timeout: 15000 });
-            }
-            catch { }
-            return true;
-        }
-    }
-    catch { }
-    return false;
-}
-function extractSummary(response) {
-    try {
-        let candidate = response;
-        try {
-            const outer = JSON.parse(response);
-            if (outer.choices?.[0]?.message?.content)
-                candidate = outer.choices[0].message.content;
-            else if (outer.output) {
-                const msg = outer.output.find((o) => o.type === 'message' && o.content?.[0]?.text);
-                if (msg)
-                    candidate = msg.content[0].text;
-            }
-        }
-        catch { }
-        const m = candidate.match(/\{[\s\S]*\}/);
-        if (m) {
-            const obj = JSON.parse(m[0]);
-            if (obj.analysis)
-                return obj.analysis.slice(0, 200);
-        }
-    }
-    catch { }
-    return response.slice(0, 200).replace(/\n/g, ' ');
-}
 // ---------- defaults ----------
 function defaultExec(cmd, opts) {
     const { execSync } = require('node:child_process');
@@ -252,228 +138,6 @@ async function defaultDryBoot() {
         }
     }
 }
-async function defaultFetchLLM(prompt) {
-    const cfg = await resolveLLMConfig();
-    if (!cfg.key)
-        throw new Error('no api key — set DEEPSEEK_API_KEY / OMNI_ROUTE_API_KEY / OPENCODE_GO_API_KEY / OPENAI_API_KEY or ~/.dsh/.credentials.yaml or AI_API_KEY');
-    // Build URLs from cfg.url (may be base or full endpoint). Support any provider/model — try completions then responses.
-    const base = cfg.url.replace(/\/v1\/(chat\/completions|responses).*/, '/v1').replace(/\/$/, '');
-    const completionsUrl = cfg.url.includes('/chat/completions') ? cfg.url : (cfg.url.includes('/responses') ? cfg.url.replace('/responses', '/chat/completions') : `${base}/chat/completions`);
-    const responsesUrl = cfg.url.includes('/responses') ? cfg.url : `${base}/responses`;
-    // Try openai-completions first (works for deepseek-v4, openai, openrouter, omni-route completions)
-    try {
-        const res = await fetch(completionsUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${cfg.key}` },
-            body: JSON.stringify({
-                model: cfg.model,
-                temperature: 0.2,
-                ...(cfg.reasoningEffort ? { reasoning_effort: cfg.reasoningEffort, reasoningEffort: cfg.reasoningEffort } : {}),
-                messages: [
-                    { role: 'system', content: 'You are a systematic-debugging agent for DSH Web resilience. Follow the 4 phases: root cause, pattern analysis, hypothesis, implementation. Always propose minimal single-file fix.' },
-                    { role: 'user', content: prompt },
-                ],
-            }),
-        });
-        if (res.ok) {
-            const j = await res.json();
-            const content = j.choices?.[0]?.message?.content;
-            if (content)
-                return content;
-            // Some providers return different shape but still ok — return stringified
-            return JSON.stringify(j);
-        }
-        // If completions fails, fall through to responses for providers that use openai-responses (e.g. opencode-go muse-spark)
-        const txt = await res.text().catch(() => '');
-        // Only fall through for 4xx/5xx that likely indicate wrong API — otherwise throw
-        if (res.status >= 400 && res.status < 600) {
-            // try responses as fallback for any provider/model
-        }
-        else {
-            throw new Error(`LLM ${res.status} ${txt}`);
-        }
-    }
-    catch (e) {
-        // Network error — if completionsUrl was tried and failed, try responses as generic fallback
-        if (!e.message?.includes('LLM ')) {
-            // will try responses below
-        }
-        else {
-            throw e;
-        }
-    }
-    // Fallback: try openai-responses (used by opencode-go muse-spark, minimax-m3, qwen3.7, etc.) — works for any provider that supports it
-    const res2 = await fetch(responsesUrl, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${cfg.key}` },
-        body: JSON.stringify({
-            model: cfg.model,
-            input: [
-                { role: 'system', content: 'You are a systematic-debugging agent for DSH Web resilience. Follow the 4 phases: root cause, pattern analysis, hypothesis, implementation. Always propose minimal single-file fix.' },
-                { role: 'user', content: prompt },
-            ],
-            max_output_tokens: 4000,
-            ...(cfg.reasoningEffort ? { reasoning: { effort: cfg.reasoningEffort } } : { reasoning: { effort: 'low' } }),
-        }),
-    });
-    if (!res2.ok)
-        throw new Error(`LLM ${res2.status} ${await res2.text().catch(() => '')}`);
-    const j2 = await res2.json();
-    // Extract text from responses output (opencode-go) or completions fallback
-    if (j2.output) {
-        const msg = j2.output.find((o) => o.type === 'message' && o.content?.[0]?.text);
-        if (msg)
-            return msg.content[0].text;
-    }
-    return j2.choices?.[0]?.message?.content ?? JSON.stringify(j2);
-}
-async function resolveLLMConfig() {
-    // Custom AI provider: env overrides, then settings.yaml (llm-pi-ai providers, DeepSeek suggested setup), then settings.json, then defaults
-    // Supports any provider/model the user configures via DeepSeek harness (opencode-go, omni-route, deepseek, openrouter, etc.)
-    let url = process.env.AI_API_URL ??
-        process.env.DEAPSEEK_API_URL ??
-        process.env.DEEPSEEK_API_URL ??
-        process.env.OPENAI_API_BASE ??
-        process.env.OMNI_ROUTE_API_URL ??
-        process.env.OPENCODE_API_URL ??
-        null;
-    // Model: AI_MODEL / DEEPSEEK_MODEL / settings.json domains.supervisor.model -> domains.review.model / default
-    // Supervisor has its own picker; falls back to review model for backward compat, then DSH default.
-    let model = process.env.AI_MODEL ?? process.env.DEEPSEEK_MODEL ?? process.env.OPENAI_MODEL ?? null;
-    // reasoningEffort: env first, then supervisor -> review, then settings.yaml fallback
-    let reasoningEffort = (process.env.AI_REASONING_EFFORT ?? process.env.REASONING_EFFORT ?? null) ?? undefined;
-    if (!model || !reasoningEffort) {
-        try {
-            const { readFileSync } = await import('node:fs');
-            const { homedir } = await import('node:os');
-            const settingsPath = `${homedir()}/.dsh/maestro/settings.json`;
-            const raw = readFileSync(settingsPath, 'utf-8');
-            const j = JSON.parse(raw);
-            // Prefer supervisor model, fall back to review model (so old installs keep working)
-            if (!model) {
-                const sup = j?.domains?.supervisor?.model?.model ?? j?.domains?.supervisor?.model;
-                const rev = j?.domains?.review?.model?.model ?? j?.domains?.review?.model;
-                let m = null;
-                if (typeof sup === 'string')
-                    m = sup;
-                else if (sup?.model && typeof sup.model === 'string')
-                    m = sup.model;
-                else if (typeof rev === 'string')
-                    m = rev;
-                else if (rev?.model && typeof rev.model === 'string')
-                    m = rev.model;
-                if (typeof m === 'string' && m.trim() !== '')
-                    model = m;
-            }
-            if (!reasoningEffort) {
-                // config-lib validator: model is {provider, model, reasoningEffort?} inside domains.supervisor.model / domains.review.model
-                // Support both nested object and flat legacy fallback for future compat
-                const supObj = j?.domains?.supervisor?.model;
-                const revObj = j?.domains?.review?.model;
-                const supEff = typeof supObj === 'object' && supObj !== null ? supObj.reasoningEffort : undefined;
-                const supFlat = j?.domains?.supervisor?.reasoningEffort;
-                const revEff = typeof revObj === 'object' && revObj !== null ? revObj.reasoningEffort : undefined;
-                const revFlat = j?.domains?.review?.reasoningEffort;
-                const candidate = supEff ?? supFlat ?? revEff ?? revFlat;
-                if (typeof candidate === 'string' && candidate.trim() !== '')
-                    reasoningEffort = candidate.trim();
-            }
-        }
-        catch { }
-    }
-    if (!model)
-        model = 'deepseek-chat';
-    // Also try settings.yaml for reasoningEffort if still missing (e.g., llm-pi-ai default reasoning)
-    if (!reasoningEffort) {
-        try {
-            const { readFileSync } = await import('node:fs');
-            const { homedir } = await import('node:os');
-            const yamlPath = `${homedir()}/.dsh/settings.yaml`;
-            const yaml = readFileSync(yamlPath, 'utf-8');
-            // Look for reasoningEffort near the model id in provider blocks (future-proof; currently not in yaml)
-            const re = new RegExp(`id:\\s*${model}[\\s\\S]{0,200}reasoningEffort:\\s*(\\S+)`, 'm');
-            const m = yaml.match(re);
-            if (m) {
-                const v = m[1].trim().replace(/^["']|["']$/g, '');
-                if (v)
-                    reasoningEffort = v;
-            }
-        }
-        catch { }
-    }
-    // If url not set via env, try to resolve from ~/.dsh/settings.yaml llm-pi-ai providers (DeepSeek suggested setup)
-    if (!url) {
-        try {
-            const { readFileSync } = await import('node:fs');
-            const { homedir } = await import('node:os');
-            const yamlPath = `${homedir()}/.dsh/settings.yaml`;
-            const yaml = readFileSync(yamlPath, 'utf-8');
-            // Find provider that owns the current model (e.g. muse-spark -> opencode-go)
-            // settings.yaml structure: llm-pi-ai: providers: <provider>: { baseURL, models: [{id}] }
-            // Use regex to extract provider blocks
-            const providerBlocks = [...yaml.matchAll(/^ {4}(\S+):\s*\n([\s\S]*?)(?=^ {4}\S+:|\n\S)/gm)];
-            for (const [, provider, block] of providerBlocks) {
-                if (block.includes(`id: ${model}`)) {
-                    const m = block.match(/baseURL:\s*(\S+)/);
-                    if (m) {
-                        url = m[1].trim();
-                        break;
-                    }
-                }
-            }
-            // Also check agent-default-model provider
-            if (!url) {
-                const defM = yaml.match(/agent-default-model:\s*\n\s*provider:\s*(\S+)/);
-                if (defM) {
-                    const prov = defM[1].trim();
-                    const provBlock = yaml.match(new RegExp(`^ {4}${prov}:\\s*\\n([\\s\\S]*?)(?=^ {4}\\S+:|\\n\\S)`, 'm'));
-                    if (provBlock) {
-                        const m = provBlock[1].match(/baseURL:\s*(\S+)/);
-                        if (m)
-                            url = m[1].trim();
-                    }
-                }
-            }
-        }
-        catch { }
-    }
-    if (!url)
-        url = 'https://api.deepseek.com/v1/chat/completions';
-    // Key: AI_API_KEY / DEEPSEEK_API_KEY / OMNI_ROUTE_API_KEY / OPENCODE_GO_API_KEY / OPENAI_API_KEY
-    let key = process.env.AI_API_KEY ??
-        process.env.DEEPSEEK_API_KEY ??
-        process.env.OMNI_ROUTE_API_KEY ??
-        process.env.OPENCODE_GO_API_KEY ??
-        process.env.OPENAI_API_KEY ??
-        null;
-    if (!key) {
-        try {
-            const { readFileSync } = await import('node:fs');
-            const { homedir } = await import('node:os');
-            const p = `${homedir()}/.dsh/.credentials.yaml`;
-            const content = readFileSync(p, 'utf-8');
-            const keys = ['AI_API_KEY', 'DEEPSEEK_API_KEY', 'OMNI_ROUTE_API_KEY', 'OPENCODE_GO_API_KEY', 'OPENAI_API_KEY'];
-            for (const k of keys) {
-                const m = content.match(new RegExp(`${k}:\\s*["']?([^"'\\n]+)["']?`));
-                if (m) {
-                    key = m[1].trim();
-                    break;
-                }
-            }
-        }
-        catch { }
-    }
-    // If url is base without /v1/chat/completions, append
-    let finalUrl = url;
-    if (!url.includes('/v1/') && !url.includes('/chat/completions')) {
-        finalUrl = url.replace(/\/$/, '') + '/v1/chat/completions';
-    }
-    return { key, url: finalUrl, model, ...(reasoningEffort ? { reasoningEffort } : {}) };
-}
-async function resolveApiKey() {
-    const cfg = await resolveLLMConfig();
-    return cfg.key;
-}
 export function _resetDebugAgentForTest() {
     lastRun = 0;
     attempts = 0;

package/lib/plugin.d.ts

@@ -7,11 +7,64 @@
  */
 import { findInterrupted as defaultFindInterrupted, findDanglingOpenTurns as defaultFindDanglingOpenTurns } from './resume.js';
 import type { RestartIntent } from './intents.js';
+import { runSessionHealthCheck } from './session-health.js';
+export * from './resume-tools.js';
 export declare const inject: readonly ["sessions", "agents", "connection", "tools", "skills"];
 export interface SupervisorPluginConfig {
     autoResumeWithin?: number | string;
     autoResumeEnabled?: boolean;
+    sessionLogRoot?: string;
+    resumeCoreToolPolicy?: ResumeCoreToolPolicy;
 }
+/**
+ * C2 — mitigation policy when a resumed session's post-resume probe (C1)
+ * reports a core tool (bash) missing from its SCOPED tool view:
+ *  - 'warn': notify the operator once + inject a "System:" inventory message
+ *    into the session telling the model which tools it CAN still call
+ *    (default — the loss is real, but the session may still be usable).
+ *  - 'park': additionally record the session id in the park set (exposed via
+ *    maestro_resume_tool_health / /dsh-maestro-supervisor-resume-tool-health)
+ *    and flag the notify with "(manual reopen required)" — the operator must
+ *    reopen the session fresh because the core-tool surface is not guaranteed.
+ */
+export type ResumeCoreToolPolicy = 'warn' | 'park';
+/**
+ * Core tools that must be visible on a resumed session. Part C targets the
+ * post-restart bash loss (`Error: unknown tool "bash"`); extend this list to
+ * widen the probe (e.g. 'cordis_inspect_query').
+ */
+export declare const CRITICAL_TOOLS: readonly ["bash"];
+/** Minimal ToolRegistry surface the resume tool-view probe reads. */
+export interface ToolsLike {
+    get?(name: string, scope?: unknown): unknown;
+    schemas?(scope?: unknown): {
+        name?: string;
+    }[];
+}
+/** Caller-visible result of the post-resume tool-view probe. */
+export interface ToolViewProbe {
+    missing: string[];
+    visible: number;
+}
+export type ToolViewProbeFn = (tools: ToolsLike | undefined, scope: string, logger?: {
+    info?: (msg: string) => void;
+}) => ToolViewProbe;
+export type ToolScopeResolver = (ctx: any, sessionId: string) => string;
+/** Default: the resumed agent's tool scope is its top-level session id. */
+export declare const defaultResolveToolScope: ToolScopeResolver;
+/**
+ * Snapshot one session's visible tool view for the journal: which CRITICAL_TOOLS
+ * are missing from the SCOPED registry (not the global view) and how many tools
+ * are visible. When the tools service is absent or lacks `get`, the probe is
+ * skipped and reports no missing tools. The log line is the Part D trigger —
+ * `bash=false` at resume marks the loss the moment it happens.
+ * @param tools - the harness ToolRegistry service, or undefined when unavailable.
+ * @param scope - the session's tool scope (defaults to the top-level session id).
+ * @param logger - optional ctx logger; the probe writes its line when present.
+ */
+export declare function probeToolView(tools: ToolsLike | undefined, scope: string, logger?: {
+    info?: (msg: string) => void;
+}): ToolViewProbe;
 export declare function runAutoResume(ctx: any, opts?: {
     findInterrupted?: typeof defaultFindInterrupted;
     findDanglingOpenTurns?: typeof defaultFindDanglingOpenTurns;
@@ -21,10 +74,17 @@ export declare function runAutoResume(ctx: any, opts?: {
 export declare function resumeInterrupted(ctx: any, ids: string[], deps?: {
     readIntent?: (id: string) => RestartIntent | undefined;
     consumeIntent?: (id: string) => void;
+    probeToolView?: ToolViewProbeFn;
+    resolveToolScope?: ToolScopeResolver;
+    notify?: (line: string) => Promise<void>;
+    injectSessionMessage?: (sessionId: string, content: string) => unknown;
+    config?: SupervisorPluginConfig;
 }): Promise<string[]>;
 export declare function createResumeRpcHandler(ctx: any, opts?: {
     resumeInterrupted?: typeof resumeInterrupted;
     config?: SupervisorPluginConfig;
+    notify?: (line: string) => Promise<void>;
+    injectSessionMessage?: (sessionId: string, content: string) => unknown;
 }): (endpoint: string, payload: unknown, _signal: AbortSignal) => Promise<{
     ok: boolean;
     value: import("./resume.js").ResumeResult;
@@ -43,4 +103,37 @@ export declare function createResumeRpcHandler(ctx: any, opts?: {
     };
     error?: undefined;
 }>;
+/**
+ * Loopback RPC handler for /dsh-maestro-supervisor-session-health. Runs the
+ * A1 session-log health check over the resolved root with repair on and
+ * quarantine off (mirrors the safe-restart pre-flight — single-frame logs get
+ * re-encoded, corrupt logs stay in place and are only counted). Same
+ * `{ ok, value | error }` envelope shape as the resume handler.
+ */
+export declare function createSessionHealthRpcHandler(ctx: any, deps?: {
+    run?: typeof runSessionHealthCheck;
+    config?: SupervisorPluginConfig;
+}): (_endpoint: string, payload: unknown, _signal: AbortSignal) => Promise<{
+    ok: boolean;
+    value: {
+        fixed: number;
+        quarantined: number;
+        remaining: number;
+    };
+    error?: undefined;
+} | {
+    ok: boolean;
+    error: {
+        code: string;
+        message: any;
+    };
+    value?: undefined;
+}>;
+/**
+ * Register the session-health RPC handle (loopback authority) and the
+ * maestro_session_health host tool. Fail-safe like the other registrations:
+ * any registration error is logged, never thrown, and the returned disposer
+ * unregisters everything that did succeed.
+ */
+export declare function registerSessionHealthService(ctx: any, config?: SupervisorPluginConfig): () => void;
 export declare function apply(ctx: any, config?: SupervisorPluginConfig): void;