@ddtcorex/dsh-maestro-supervisor 0.5.2 → 0.5.4

package/lib/cli.js

@@ -44,9 +44,40 @@ Commands:
             pollHealth: () => pollHealth(),
             writeLKG: () => writeLKG(dshHome, lkgRoot),
             writeFailed: () => writeLKG(dshHome, failedRoot),
-            writeReport: async ({ ts, health, action }) => {
-                const { writeReport } = await import('./report.js');
-                return writeReport({ reportsRoot, ts, health, gitDiff: '', logTail: '', action });
+            writeReport: async ({ ts, health, action, logTail, gitDiff }) => {
+                const { writeReport, collectGitDiff } = await import('./report.js');
+                const { collectLogTail } = await import('./health-poller.js');
+                // Prefer supervisor-provided tail/diff (from health.logTail); fallback to live collect
+                let tail = logTail ?? health.logTail ?? '';
+                if (!tail) {
+                    try {
+                        tail = await collectLogTail();
+                    }
+                    catch {
+                        tail = '';
+                    }
+                }
+                let diff = gitDiff ?? '';
+                if (!diff) {
+                    try {
+                        const harnessRoot = process.env.MAESTRO_HARNESS_ROOT ?? path.join(os.homedir(), 'Work/htdocs/maestro-harness');
+                        diff = await collectGitDiff(harnessRoot).catch(() => '');
+                        if (!diff) {
+                            // fallback: try git diff in cwd
+                            const { execSync } = await import('node:child_process');
+                            try {
+                                diff = execSync('git diff 2>/dev/null | head -n 200', { encoding: 'utf-8', timeout: 2000 });
+                            }
+                            catch {
+                                diff = '';
+                            }
+                        }
+                    }
+                    catch {
+                        diff = '';
+                    }
+                }
+                return writeReport({ reportsRoot, ts, health, gitDiff: diff, logTail: tail, action });
             },
             rollback: async () => {
                 // Find latest LKG and restore

package/lib/debug-agent.js

@@ -143,8 +143,22 @@ function buildPrompt(ctx) {
 }
 function tryApplyLLMFix(response, writeFile, exec) {
     try {
-        // Try to parse JSON block from response
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        // 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]);
@@ -163,7 +177,19 @@ function tryApplyLLMFix(response, writeFile, exec) {
 }
 function extractSummary(response) {
     try {
-        const m = response.match(/\{[\s\S]*\}/);
+        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)
@@ -206,51 +232,144 @@ 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');
-    const res = await fetch(cfg.url, {
+    // 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,
+                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}`,
-        },
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${cfg.key}` },
         body: JSON.stringify({
             model: cfg.model,
-            temperature: 0.2,
-            messages: [
+            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,
+            reasoning: { effort: 'low' },
         }),
     });
-    if (!res.ok)
-        throw new Error(`LLM ${res.status} ${await res.text().catch(() => '')}`);
-    const j = await res.json();
-    return j.choices?.[0]?.message?.content ?? JSON.stringify(j);
+    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 credentials.yaml, then settings.json, then defaults
-    // Url: AI_API_URL / DEEPSEEK_API_URL / OPENAI_API_BASE / OMNI_ROUTE_API_URL -> default deepseek
-    const url = process.env.AI_API_URL ??
+    // 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 ??
-        'https://api.deepseek.com/v1/chat/completions';
-    // Model: AI_MODEL / DEEPSEEK_MODEL / settings.json domains.review.model
-    let model = process.env.AI_MODEL ?? process.env.DEEPSEEK_MODEL ?? process.env.OPENAI_MODEL ?? 'deepseek-chat';
-    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);
-        const m = j?.domains?.review?.model?.model ?? j?.domains?.review?.model;
-        if (typeof m === 'string' && !process.env.AI_MODEL && !process.env.DEEPSEEK_MODEL)
-            model = m;
-        else if (m?.model && typeof m.model === 'string' && !process.env.AI_MODEL)
-            model = m.model;
+        null;
+    // Model: AI_MODEL / DEEPSEEK_MODEL / settings.json domains.review.model / default
+    let model = process.env.AI_MODEL ?? process.env.DEEPSEEK_MODEL ?? process.env.OPENAI_MODEL ?? null;
+    // Try settings.json first (review model is the user's current default model)
+    if (!model) {
+        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);
+            const m = j?.domains?.review?.model?.model ?? j?.domains?.review?.model;
+            if (typeof m === 'string')
+                model = m;
+            else if (m?.model && typeof m.model === 'string')
+                model = m.model;
+        }
+        catch { }
     }
-    catch { }
+    if (!model)
+        model = 'deepseek-chat';
+    // 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 ??

package/lib/health-poller.d.ts

@@ -3,6 +3,7 @@ export interface HealthState {
     httpCode?: number;
     error?: string;
     degraded?: boolean;
+    logTail?: string;
 }
 export interface PollHealthOpts {
     fetch?: () => Promise<{
@@ -15,3 +16,4 @@ export interface PollHealthOpts {
     timeoutMs?: number;
 }
 export declare function pollHealth(opts?: PollHealthOpts): Promise<HealthState>;
+export declare function collectLogTail(): Promise<string>;

package/lib/health-poller.js

@@ -53,6 +53,7 @@ export async function pollHealth(opts = {}) {
             httpCode,
             error: logError ? `${fetchError} + ${logError}` : fetchError,
             degraded: false,
+            logTail: logContent.slice(-5000),
         };
     }
     if (logError) {
@@ -63,6 +64,7 @@ export async function pollHealth(opts = {}) {
                 httpCode,
                 error: logError,
                 degraded: true,
+                logTail: logContent.slice(-5000),
             };
         }
         return {
@@ -70,6 +72,7 @@ export async function pollHealth(opts = {}) {
             httpCode,
             error: logError,
             degraded: false,
+            logTail: logContent.slice(-5000),
         };
     }
     // Also check psAlive as secondary signal — if fetch ok but ps dead, still down
@@ -82,7 +85,7 @@ export async function pollHealth(opts = {}) {
     catch {
         // ignore
     }
-    return { up: httpCode === 200, httpCode };
+    return { up: httpCode === 200, httpCode, logTail: logContent.slice(-5000) };
 }
 function defaultFetch(url, timeoutMs) {
     return async () => {
@@ -108,22 +111,50 @@ async function defaultPsAlive() {
         return true;
     }
 }
-async function defaultLogTail() {
+export async function collectLogTail() {
     try {
-        const { readFileSync } = await import('node:fs');
+        const { readFileSync, existsSync, statSync } = await import('node:fs');
         const { homedir } = await import('node:os');
-        const candidates = [`${homedir()}/.dsh/dsh-web.log`, `${homedir()}/.dsh.log`];
+        const candidates = [
+            `${homedir()}/.dsh/dsh-web.log`,
+            `${homedir()}/.dsh/.supervisor/supervisor.log`,
+            `${homedir()}/.dsh.log`,
+        ];
         for (const logPath of candidates) {
             try {
+                if (!existsSync(logPath))
+                    continue;
+                // avoid reading huge files fully — if >1MB, read tail via shell
+                try {
+                    const sz = statSync(logPath).size;
+                    if (sz > 1024 * 1024) {
+                        const { execSync } = await import('node:child_process');
+                        const out = execSync(`tail -c 5000 ${JSON.stringify(logPath)} 2>/dev/null || cat ${JSON.stringify(logPath)} 2>/dev/null | tail -c 5000`, { encoding: 'utf-8', timeout: 2000 });
+                        if (out)
+                            return out.slice(-5000);
+                    }
+                }
+                catch { }
                 const content = readFileSync(logPath, 'utf-8');
-                if (content)
+                if (content && content.trim())
                     return content.slice(-5000);
             }
             catch { }
         }
+        // fallback: try journalctl for the dsh-web or supervisor units (if running via systemd)
+        try {
+            const { execSync } = await import('node:child_process');
+            const journal = execSync('journalctl --user -u dsh-web-supervisor --no-pager -n 100 2>/dev/null | tail -c 5000 || journalctl --user --no-pager -n 100 2>/dev/null | tail -c 5000 || true', { encoding: 'utf-8', timeout: 2000 });
+            if (journal && journal.trim())
+                return journal.slice(-5000);
+        }
+        catch { }
         return '';
     }
     catch {
         return '';
     }
 }
+async function defaultLogTail() {
+    return collectLogTail();
+}

package/lib/snapshot.d.ts

@@ -10,6 +10,9 @@ export declare function writeLKG(dshHome: string, lkgRoot: string): Promise<{
     ts: string;
     manifest: Manifest;
 }>;
+export declare function pruneByAge(root: string, maxAgeMs: number): Promise<void>;
+export declare function pruneBySize(root: string, maxBytes: number): Promise<void>;
+export declare function isDuplicateLKG(dshHome: string, lkgRoot: string): Promise<boolean>;
 export declare function verifyLKG(lkgPath: string): Promise<boolean>;
 export declare function rotateLKG(lkgRoot: string, keep?: number): Promise<void>;
 export declare function writeFailed(dshHome: string, failedRoot: string): Promise<{

package/lib/snapshot.js

@@ -17,12 +17,29 @@ function walkFiles(dir, base = dir) {
     return out;
 }
 export async function writeLKG(dshHome, lkgRoot) {
+    // Dedupe: skip snapshot if current state identical to latest LKG (prevents 5-min unconditional growth)
+    try {
+        if (await isDuplicateLKG(dshHome, lkgRoot)) {
+            const entries = fs.readdirSync(lkgRoot).filter((n) => {
+                try {
+                    return fs.statSync(path.join(lkgRoot, n)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            }).sort();
+            const latest = entries[entries.length - 1];
+            const manifestPath = path.join(lkgRoot, latest, 'manifest.json');
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            return { ts: latest, manifest };
+        }
+    }
+    catch { }
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     const dest = path.join(lkgRoot, ts);
     fs.mkdirSync(dest, { recursive: true });
-    // Copy DSH home contents (if exists, copy recursively)
+    // Copy DSH home contents (if exists, copy recursively) — skip .supervisor to avoid recursion
     if (fs.existsSync(dshHome)) {
-        // Use cpSync if available
         for (const entry of fs.readdirSync(dshHome)) {
             if (entry === '.supervisor')
                 continue;
@@ -39,8 +56,117 @@ export async function writeLKG(dshHome, lkgRoot) {
             .map(f => ({ path: f, sha256: sha256File(path.join(dest, f)) })),
     };
     fs.writeFileSync(path.join(dest, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    // Retention: keep only 3 most recent, plus age (7d) and size (5GB) caps — prevents unbounded 40GB+ growth
+    await rotateLKG(lkgRoot, 3).catch(() => { });
+    await pruneByAge(lkgRoot, 7 * 24 * 60 * 60 * 1000).catch(() => { });
+    await pruneBySize(lkgRoot, 5 * 1024 * 1024 * 1024).catch(() => { });
     return { ts, manifest };
 }
+export async function pruneByAge(root, maxAgeMs) {
+    if (!fs.existsSync(root))
+        return;
+    const now = Date.now();
+    const entries = fs.readdirSync(root).filter((n) => {
+        try {
+            return fs.statSync(path.join(root, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    for (const name of entries) {
+        try {
+            const tsStr = name.replace(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d+)Z$/, '$1-$2-$3T$4:$5:$6.$7Z');
+            const ts = Date.parse(tsStr);
+            if (!isNaN(ts) && now - ts > maxAgeMs) {
+                fs.rmSync(path.join(root, name), { recursive: true, force: true });
+            }
+        }
+        catch { }
+    }
+}
+export async function pruneBySize(root, maxBytes) {
+    if (!fs.existsSync(root))
+        return;
+    const entries = fs.readdirSync(root).filter((n) => {
+        try {
+            return fs.statSync(path.join(root, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).sort();
+    let total = 0;
+    const sizes = [];
+    for (const name of entries) {
+        try {
+            const p = path.join(root, name);
+            let size = 0;
+            for (const f of walkFiles(p)) {
+                try {
+                    size += fs.statSync(path.join(p, f)).size;
+                }
+                catch { }
+            }
+            sizes.push({ name, size });
+            total += size;
+        }
+        catch { }
+    }
+    for (const { name, size } of sizes) {
+        if (total <= maxBytes)
+            break;
+        try {
+            fs.rmSync(path.join(root, name), { recursive: true, force: true });
+            total -= size;
+        }
+        catch { }
+    }
+}
+export async function isDuplicateLKG(dshHome, lkgRoot) {
+    // Lightweight dedupe: if latest snapshot is <5 minutes old, skip (prevents 5-min unconditional growth)
+    // Full hash check is too heavy (would read 500MB+ each tick) and caused status timeouts
+    if (!fs.existsSync(lkgRoot))
+        return false;
+    const entries = fs.readdirSync(lkgRoot).filter((n) => {
+        try {
+            return fs.statSync(path.join(lkgRoot, n)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }).sort();
+    if (!entries.length)
+        return false;
+    const latestName = entries[entries.length - 1];
+    try {
+        const tsStr = latestName.replace(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d+)Z$/, '$1-$2-$3T$4:$5:$6.$7Z');
+        const ts = Date.parse(tsStr);
+        if (!isNaN(ts) && Date.now() - ts < 5 * 60 * 1000) {
+            // If latest is recent and DSH home hasn't changed in mtime, consider duplicate
+            // Quick check: compare latest snapshot's mtime vs DSH home's newest file mtime
+            const latestPath = path.join(lkgRoot, latestName);
+            const latestMtime = fs.statSync(latestPath).mtimeMs;
+            let newestFileMtime = 0;
+            if (fs.existsSync(dshHome)) {
+                for (const entry of fs.readdirSync(dshHome)) {
+                    if (entry === '.supervisor')
+                        continue;
+                    try {
+                        const s = fs.statSync(path.join(dshHome, entry));
+                        if (s.mtimeMs > newestFileMtime)
+                            newestFileMtime = s.mtimeMs;
+                    }
+                    catch { }
+                }
+            }
+            if (newestFileMtime > 0 && newestFileMtime < latestMtime)
+                return true;
+        }
+    }
+    catch { }
+    return false;
+}
 export async function verifyLKG(lkgPath) {
     const manifestPath = path.join(lkgPath, 'manifest.json');
     if (!fs.existsSync(manifestPath))

package/lib/supervisor.d.ts

@@ -13,6 +13,8 @@ export interface SupervisorDeps {
         ts: string;
         health: HealthState;
         action: string;
+        logTail?: string;
+        gitDiff?: string;
     }) => Promise<string>;
     rollback: (ts?: string) => Promise<void>;
     notify: (msg: string) => Promise<void>;
@@ -41,6 +43,7 @@ export declare class Supervisor {
     constructor(deps: SupervisorDeps);
     private getRunDebugAgent;
     private getFindInterrupted;
+    private collectGitDiff;
     private handleDebugResult;
     tick(): Promise<void>;
     start(): void;

package/lib/supervisor.js

@@ -16,6 +16,25 @@ export class Supervisor {
     getFindInterrupted() {
         return this.deps.findInterrupted ?? defaultFindInterrupted;
     }
+    async collectGitDiff() {
+        try {
+            const { execSync } = await import('node:child_process');
+            const ws = process.env.MAESTRO_HARNESS_ROOT ?? '/home/kai/Work/htdocs/maestro-harness';
+            try {
+                const out = execSync(`git -C ${JSON.stringify(ws)} status --porcelain 2>/dev/null | head -n 50`, { encoding: 'utf-8', timeout: 2000 });
+                if (out.trim()) {
+                    const diff = execSync(`git -C ${JSON.stringify(ws)} diff 2>/dev/null | head -n 200`, { encoding: 'utf-8', timeout: 2000 });
+                    return diff || out;
+                }
+            }
+            catch { }
+            const diff = execSync('git diff 2>/dev/null | head -n 200', { encoding: 'utf-8', timeout: 2000 });
+            return diff.trim() ? diff : '';
+        }
+        catch {
+            return '';
+        }
+    }
     handleDebugResult(reportPath, res) {
         if (res.fixed) {
             void this.deps.notify(`FIXED: debug-agent fixed ${reportPath} — ${res.reason}`).catch(() => { });
@@ -46,7 +65,9 @@ export class Supervisor {
             this.lastDegradedNotify = now;
             try {
                 const ts = new Date().toISOString().replace(/[:.]/g, '-');
-                const reportPath = await this.deps.writeReport({ ts, health, action: `degraded — ${health.error ?? 'plugin'}` }).catch(() => '');
+                const logTail = health.logTail ?? '';
+                const gitDiff = await this.collectGitDiff().catch(() => '');
+                const reportPath = await this.deps.writeReport({ ts, health, action: `degraded — ${health.error ?? 'plugin'}`, logTail, gitDiff }).catch(() => '');
                 await this.deps.notify(`DEGRADED: ${health.error ?? 'plugin'} (report: ${reportPath})`).catch(() => { });
                 // Phase 3: debug + resume — use injected fn if provided (even in VITEST), otherwise fire-and-forget real impl (skip in VITEST)
                 const runner = this.getRunDebugAgent();
@@ -100,7 +121,9 @@ export class Supervisor {
         try {
             const failed = await this.deps.writeFailed().catch(() => ({ ts: new Date().toISOString().replace(/[:.]/g, '-'), manifest: null }));
             const ts = failed?.ts ?? new Date().toISOString().replace(/[:.]/g, '-');
-            const reportPath = await this.deps.writeReport({ ts, health, action: `rollback — ${health.error ?? 'down'}` }).catch(() => '');
+            const logTail = health.logTail ?? '';
+            const gitDiff = await this.collectGitDiff().catch(() => '');
+            const reportPath = await this.deps.writeReport({ ts, health, action: `rollback — ${health.error ?? 'down'}`, logTail, gitDiff }).catch(() => '');
             await this.deps.rollback();
             await this.deps.notify(`CRASH detected → rollback (report: ${reportPath}, error: ${health.error ?? 'down'})`).catch(() => { });
             const runner = this.getRunDebugAgent();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddtcorex/dsh-maestro-supervisor",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Supervisor daemon for DSH Web resilience — auto-detect crashes, rollback to LKG, report",
   "type": "module",
   "bin": {