discoclaw 0.1.0

package/dist/discord/file-download.test.js

@@ -0,0 +1,303 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveTextType, isTextType, classifyAttachments, downloadTextAttachments } from './file-download.js';
+function makeAtt(name, contentType, size = 100) {
+    return { url: `https://cdn.discordapp.com/attachments/1/2/${name}`, name, contentType, size };
+}
+describe('resolveTextType', () => {
+    it('returns MIME for text/plain', () => {
+        expect(resolveTextType(makeAtt('a.txt', 'text/plain'))).toBe('text/plain');
+    });
+    it('returns MIME for application/json', () => {
+        expect(resolveTextType(makeAtt('a.json', 'application/json'))).toBe('application/json');
+    });
+    it('returns MIME for text/csv', () => {
+        expect(resolveTextType(makeAtt('a.csv', 'text/csv'))).toBe('text/csv');
+    });
+    it('strips charset from contentType', () => {
+        expect(resolveTextType(makeAtt('a.txt', 'text/plain; charset=utf-8'))).toBe('text/plain');
+    });
+    it('falls back to extension for .json', () => {
+        expect(resolveTextType(makeAtt('config.json', null))).toBe('application/json');
+    });
+    it('falls back to extension for .md', () => {
+        expect(resolveTextType(makeAtt('README.md', null))).toBe('text/markdown');
+    });
+    it('falls back to extension for .py', () => {
+        expect(resolveTextType(makeAtt('script.py', null))).toBe('text/x-script');
+    });
+    it('falls back to extension for .yml', () => {
+        expect(resolveTextType(makeAtt('config.yml', null))).toBe('text/yaml');
+    });
+    it('falls back to extension for .yaml', () => {
+        expect(resolveTextType(makeAtt('config.yaml', null))).toBe('text/yaml');
+    });
+    it('falls back to extension for .sh', () => {
+        expect(resolveTextType(makeAtt('build.sh', null))).toBe('text/x-script');
+    });
+    it('returns null for image types', () => {
+        expect(resolveTextType(makeAtt('photo.png', 'image/png'))).toBeNull();
+    });
+    it('returns null for PDF', () => {
+        expect(resolveTextType(makeAtt('doc.pdf', 'application/pdf'))).toBeNull();
+    });
+    it('returns null for unknown extension and no contentType', () => {
+        expect(resolveTextType(makeAtt('data.xyz', null))).toBeNull();
+    });
+    // --- New extension tests ---
+    it('falls back to extension for .go', () => {
+        expect(resolveTextType(makeAtt('main.go', null))).toBe('text/x-script');
+    });
+    it('falls back to extension for .rs', () => {
+        expect(resolveTextType(makeAtt('lib.rs', null))).toBe('text/x-script');
+    });
+    it('falls back to extension for .css', () => {
+        expect(resolveTextType(makeAtt('styles.css', null))).toBe('text/css');
+    });
+    it('falls back to extension for .jsx', () => {
+        expect(resolveTextType(makeAtt('App.jsx', null))).toBe('application/javascript');
+    });
+    it('falls back to extension for .tsx', () => {
+        expect(resolveTextType(makeAtt('App.tsx', null))).toBe('application/typescript');
+    });
+    it('falls back to extension for .mjs', () => {
+        expect(resolveTextType(makeAtt('index.mjs', null))).toBe('application/javascript');
+    });
+    it('falls back to extension for .mts', () => {
+        expect(resolveTextType(makeAtt('index.mts', null))).toBe('application/typescript');
+    });
+    it('falls back to extension for .toml', () => {
+        expect(resolveTextType(makeAtt('config.toml', null))).toBe('application/toml');
+    });
+    it('falls back to extension for .env', () => {
+        expect(resolveTextType(makeAtt('app.env', null))).toBe('text/plain');
+    });
+    it('falls back to extension for .sql', () => {
+        expect(resolveTextType(makeAtt('schema.sql', null))).toBe('application/sql');
+    });
+    it('falls back to extension for .tf', () => {
+        expect(resolveTextType(makeAtt('main.tf', null))).toBe('text/plain');
+    });
+    it('falls back to extension for .proto', () => {
+        expect(resolveTextType(makeAtt('service.proto', null))).toBe('text/plain');
+    });
+    it('falls back to extension for .jsonc', () => {
+        expect(resolveTextType(makeAtt('tsconfig.jsonc', null))).toBe('application/json');
+    });
+    it('falls back to extension for .dockerfile', () => {
+        expect(resolveTextType(makeAtt('app.dockerfile', null))).toBe('text/plain');
+    });
+    it('falls back to extension for .log', () => {
+        expect(resolveTextType(makeAtt('error.log', null))).toBe('text/plain');
+    });
+    it('falls back to extension for .svg', () => {
+        expect(resolveTextType(makeAtt('icon.svg', null))).toBe('text/xml');
+    });
+    it('falls back to extension for .astro', () => {
+        expect(resolveTextType(makeAtt('Page.astro', null))).toBe('text/html');
+    });
+    it('falls back to extension for .bat', () => {
+        expect(resolveTextType(makeAtt('build.bat', null))).toBe('text/x-script');
+    });
+    it('falls back to extension for .gd (GDScript)', () => {
+        expect(resolveTextType(makeAtt('player.gd', null))).toBe('text/x-script');
+    });
+    // --- Bare dotfile tests (dotIdx === 0 path) ---
+    it('resolves bare .env dotfile', () => {
+        expect(resolveTextType(makeAtt('.env', null))).toBe('text/plain');
+    });
+    it('resolves bare .gitignore dotfile', () => {
+        expect(resolveTextType(makeAtt('.gitignore', null))).toBe('text/plain');
+    });
+    it('resolves bare .prettierrc dotfile', () => {
+        expect(resolveTextType(makeAtt('.prettierrc', null))).toBe('text/plain');
+    });
+    // --- Negative cases ---
+    it('returns null for .exe (binary)', () => {
+        expect(resolveTextType(makeAtt('app.exe', null))).toBeNull();
+    });
+    it('returns null for .dll (binary)', () => {
+        expect(resolveTextType(makeAtt('lib.dll', null))).toBeNull();
+    });
+});
+describe('isTextType', () => {
+    it('returns true for text/* types', () => {
+        expect(isTextType('text/plain')).toBe(true);
+        expect(isTextType('text/x-script')).toBe(true);
+        expect(isTextType('text/csv')).toBe(true);
+    });
+    it('returns true for application text types', () => {
+        expect(isTextType('application/json')).toBe(true);
+        expect(isTextType('application/javascript')).toBe(true);
+    });
+    it('returns true for application/toml', () => {
+        expect(isTextType('application/toml')).toBe(true);
+    });
+    it('returns true for application/sql', () => {
+        expect(isTextType('application/sql')).toBe(true);
+    });
+    it('returns true for application/graphql', () => {
+        expect(isTextType('application/graphql')).toBe(true);
+    });
+    it('returns true for text/css', () => {
+        expect(isTextType('text/css')).toBe(true);
+    });
+    it('returns false for non-text types', () => {
+        expect(isTextType('application/pdf')).toBe(false);
+        expect(isTextType('image/png')).toBe(false);
+    });
+});
+describe('classifyAttachments', () => {
+    it('separates text from unsupported', () => {
+        const atts = [
+            makeAtt('code.js', 'application/javascript'),
+            makeAtt('doc.pdf', 'application/pdf'),
+            makeAtt('notes.txt', 'text/plain'),
+        ];
+        const { text, unsupported } = classifyAttachments(atts);
+        expect(text).toHaveLength(2);
+        expect(unsupported).toHaveLength(1);
+        expect(unsupported[0].name).toBe('doc.pdf');
+    });
+    it('handles empty input', () => {
+        const { text, unsupported } = classifyAttachments([]);
+        expect(text).toHaveLength(0);
+        expect(unsupported).toHaveLength(0);
+    });
+});
+describe('downloadTextAttachments', () => {
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        globalThis.fetch = vi.fn();
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('downloads text file content', async () => {
+        const content = 'hello world';
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(Buffer.from(content)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('hello.txt', 'text/plain', 11),
+        ]);
+        expect(result.texts).toHaveLength(1);
+        expect(result.texts[0].name).toBe('hello.txt');
+        expect(result.texts[0].content).toBe('hello world');
+        expect(result.errors).toHaveLength(0);
+    });
+    it('notes unsupported attachment types', async () => {
+        const result = await downloadTextAttachments([
+            makeAtt('doc.pdf', 'application/pdf', 100),
+        ]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('Unsupported attachment');
+        expect(result.errors[0]).toContain('doc.pdf');
+        expect(result.errors[0]).toContain('application/pdf');
+    });
+    it('blocks non-Discord CDN URLs (SSRF)', async () => {
+        const att = {
+            url: 'https://evil.com/secret.txt',
+            name: 'secret.txt',
+            contentType: 'text/plain',
+            size: 10,
+        };
+        const result = await downloadTextAttachments([att]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('blocked');
+        expect(globalThis.fetch).not.toHaveBeenCalled();
+    });
+    it('truncates files exceeding per-file size limit', async () => {
+        const bigContent = 'A'.repeat(150 * 1024); // 150KB
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(Buffer.from(bigContent)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('big.txt', 'text/plain', 150 * 1024),
+        ]);
+        expect(result.texts).toHaveLength(1);
+        expect(result.texts[0].content).toContain('[truncated at 100KB]');
+        expect(result.texts[0].content.length).toBeLessThan(bigContent.length);
+    });
+    it('skips files when total budget is exceeded', async () => {
+        const content = 'A'.repeat(150 * 1024); // 150KB each
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(Buffer.from(content)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('a.txt', 'text/plain', 150 * 1024),
+            makeAtt('b.txt', 'text/plain', 150 * 1024), // would exceed 200KB total
+        ]);
+        expect(result.texts).toHaveLength(1);
+        expect(result.errors.some(e => e.includes('total size limit'))).toBe(true);
+    });
+    it('handles HTTP errors', async () => {
+        globalThis.fetch.mockResolvedValue({ ok: false, status: 404 });
+        const result = await downloadTextAttachments([
+            makeAtt('missing.txt', 'text/plain', 10),
+        ]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('HTTP 404');
+    });
+    it('handles download timeout', async () => {
+        const timeoutErr = new DOMException('signal timed out', 'TimeoutError');
+        globalThis.fetch.mockRejectedValue(timeoutErr);
+        const result = await downloadTextAttachments([
+            makeAtt('slow.txt', 'text/plain', 10),
+        ]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('timed out');
+    });
+    it('rejects non-UTF8 content', async () => {
+        // Create a buffer with invalid UTF-8 bytes
+        const badBuffer = Buffer.from([0xff, 0xfe, 0x80, 0x81]);
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(badBuffer.buffer.slice(badBuffer.byteOffset, badBuffer.byteOffset + badBuffer.byteLength)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('binary.txt', 'text/plain', 4),
+        ]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('not valid UTF-8');
+    });
+    it('handles empty input', async () => {
+        const result = await downloadTextAttachments([]);
+        expect(result.texts).toHaveLength(0);
+        expect(result.errors).toHaveLength(0);
+    });
+    it('handles mix of text and unsupported files', async () => {
+        const content = 'data';
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(Buffer.from(content)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('code.js', 'application/javascript', 4),
+            makeAtt('archive.zip', 'application/zip', 1000),
+            makeAtt('notes.md', null, 4), // extension fallback
+        ]);
+        expect(result.texts).toHaveLength(2); // code.js + notes.md
+        expect(result.errors).toHaveLength(1); // archive.zip unsupported
+        expect(result.errors[0]).toContain('archive.zip');
+    });
+    it('uses extension fallback when contentType is missing', async () => {
+        const content = '{"key":"value"}';
+        globalThis.fetch.mockResolvedValue({
+            ok: true,
+            arrayBuffer: () => Promise.resolve(Buffer.from(content)),
+        });
+        const result = await downloadTextAttachments([
+            makeAtt('config.json', null, 15),
+        ]);
+        expect(result.texts).toHaveLength(1);
+        expect(result.texts[0].content).toBe('{"key":"value"}');
+    });
+});

package/dist/discord/forge-audit-verdict.js

@@ -0,0 +1,140 @@
+import { extractFirstJsonValue } from './json-extract.js';
+const SEVERITY_RANK = {
+    none: 0,
+    suggestion: 1,
+    minor: 2,
+    medium: 3,
+    blocking: 4,
+};
+function normalizeSeverity(raw) {
+    if (!raw)
+        return null;
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'high')
+        return 'blocking';
+    if (normalized === 'low')
+        return 'minor';
+    if (normalized === 'blocking' ||
+        normalized === 'medium' ||
+        normalized === 'minor' ||
+        normalized === 'suggestion' ||
+        normalized === 'none') {
+        return normalized;
+    }
+    return null;
+}
+function maxSeverityFromList(severities) {
+    let max = 'none';
+    for (const sev of severities) {
+        if (SEVERITY_RANK[sev] > SEVERITY_RANK[max]) {
+            max = sev;
+        }
+    }
+    return max;
+}
+function tryParseJsonVerdict(auditText) {
+    const jsonCandidate = extractFirstJsonValue(auditText, { objectOnly: true });
+    if (!jsonCandidate)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonCandidate);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const payload = parsed;
+    const verdictPayload = payload.verdict && typeof payload.verdict === 'object'
+        ? payload.verdict
+        : payload;
+    const topSeverity = normalizeSeverity(verdictPayload.maxSeverity);
+    const concernSeverities = [];
+    for (const concern of verdictPayload.concerns ?? []) {
+        const severity = normalizeSeverity(concern?.severity);
+        if (severity)
+            concernSeverities.push(severity);
+    }
+    const hasStructuredVerdict = topSeverity !== null ||
+        typeof verdictPayload.shouldLoop === 'boolean' ||
+        concernSeverities.length > 0;
+    if (!hasStructuredVerdict)
+        return null;
+    const concernMax = maxSeverityFromList(concernSeverities);
+    let maxSeverity = topSeverity ?? concernMax;
+    const shouldLoop = typeof verdictPayload.shouldLoop === 'boolean'
+        ? verdictPayload.shouldLoop
+        : maxSeverity === 'blocking';
+    if (shouldLoop && maxSeverity === 'none') {
+        maxSeverity = 'blocking';
+    }
+    return { maxSeverity, shouldLoop };
+}
+function parseAuditVerdictLegacy(auditText) {
+    const lower = auditText.toLowerCase();
+    // --- Severity detection ---
+    // Primary: "Severity: blocking" or "Severity: **high**" (structured format we ask for)
+    // Secondary: table cells like "| **blocking** |" or "| medium |".
+    // Tertiary: parenthesized severity like "Concern 1 (high)" or "(medium)".
+    // We intentionally avoid matching free-form bold words in prose to prevent
+    // false positives like "the impact is **high**" in a description paragraph.
+    const severityLabel = /\bseverity\b[:\s]*\**\s*(blocking|high|medium|minor|low|suggestion)\b/gi;
+    const tableCellSeverity = /\|\s*\**\s*(blocking|high|medium|minor|low|suggestion)\s*\**\s*\|/gi;
+    const bareSeverity = /\((blocking|high|medium|minor|low|suggestion)\)/gi;
+    // Collect all severity mentions from all patterns
+    const found = new Set();
+    for (const re of [severityLabel, tableCellSeverity, bareSeverity]) {
+        let m;
+        while ((m = re.exec(auditText)) !== null) {
+            found.add(m[1].toLowerCase());
+        }
+    }
+    // Normalize backward-compat aliases: high -> blocking, low -> minor
+    if (found.has('high')) {
+        found.delete('high');
+        found.add('blocking');
+    }
+    if (found.has('low')) {
+        found.delete('low');
+        found.add('minor');
+    }
+    // Determine max severity from markers (blocking > medium > minor > suggestion)
+    const markerSeverity = found.has('blocking')
+        ? 'blocking'
+        : found.has('medium')
+            ? 'medium'
+            : found.has('minor')
+                ? 'minor'
+                : found.has('suggestion')
+                    ? 'suggestion'
+                    : 'none';
+    // Determine verdict from text
+    const needsRevision = lower.includes('needs revision');
+    const readyToApprove = lower.includes('ready to approve');
+    // Severity markers win over verdict text when they disagree.
+    // A "Ready to approve" verdict with blocking-severity findings is contradictory —
+    // trust the severity markers.
+    if (markerSeverity !== 'none') {
+        const shouldLoop = markerSeverity === 'blocking';
+        return { maxSeverity: markerSeverity, shouldLoop };
+    }
+    // No severity markers found — fall back to verdict text
+    if (needsRevision) {
+        return { maxSeverity: 'blocking', shouldLoop: true };
+    }
+    if (readyToApprove) {
+        return { maxSeverity: 'minor', shouldLoop: false };
+    }
+    // Malformed output — stop and let the human review
+    return { maxSeverity: 'none', shouldLoop: false };
+}
+export function parseAuditVerdict(auditText) {
+    if (!auditText || !auditText.trim()) {
+        return { maxSeverity: 'none', shouldLoop: false };
+    }
+    const parsedJson = tryParseJsonVerdict(auditText);
+    if (parsedJson)
+        return parsedJson;
+    return parseAuditVerdictLegacy(auditText);
+}

package/dist/discord/forge-auto-implement.js

@@ -0,0 +1,80 @@
+const SEVERITY_LABELS = {
+    blocking: 'blocking severity',
+    medium: 'medium severity',
+    minor: 'minor severity',
+    suggestion: 'suggestion-level',
+};
+export async function autoImplementForgePlan(opts, deps) {
+    const { planId, result } = opts;
+    const { planApprove, planRun, isPlanRunning, log } = deps;
+    const verdict = result.finalVerdict;
+    const normalizedVerdict = typeof verdict === 'string' ? verdict.toLowerCase() : '';
+    const severity = normalizedVerdict && normalizedVerdict !== 'none' ? normalizedVerdict : undefined;
+    if (!planId) {
+        return manualOutcome('', 'Plan ID missing from the forge output.');
+    }
+    if (result.error) {
+        return manualOutcome(planId, `Forge failed: ${result.error}`);
+    }
+    if (result.reachedMaxRounds) {
+        return manualOutcome(planId, 'Forge reached the audit cap (CAP_REACHED) and left concerns unresolved. Manual review is required.');
+    }
+    if (!verdict || verdict === 'CANCELLED' || verdict === 'error') {
+        return manualOutcome(planId, 'Forge did not emit a ready verdict. Please inspect the plan before proceeding.');
+    }
+    if (normalizedVerdict === 'blocking') {
+        return manualOutcome(planId, 'Review the flagged concerns before implementing.', normalizedVerdict);
+    }
+    if (isPlanRunning(planId)) {
+        return manualOutcome(planId, 'A plan run is already in progress for this plan.');
+    }
+    try {
+        await planApprove(planId);
+        log?.info({ planId }, 'forge:auto-implement: plan auto-approved');
+    }
+    catch (err) {
+        const reason = `Auto-approval failed: ${String(err)}`;
+        log?.error({ err, planId }, 'forge:auto-implement: approval failed');
+        return manualOutcome(planId, reason);
+    }
+    let runSummary;
+    try {
+        ({ summary: runSummary } = await planRun(planId));
+        log?.info({ planId }, 'forge:auto-implement: implementation run completed');
+    }
+    catch (err) {
+        const reason = `Auto-run failed: ${String(err)}`;
+        log?.error({ err, planId }, 'forge:auto-implement: run failed');
+        return manualOutcome(planId, reason);
+    }
+    const warningMessage = severity ? `Forge reported ${severityLabel(severity)} concerns.` : undefined;
+    const summaryParts = [];
+    if (warningMessage)
+        summaryParts.push(warningMessage);
+    if (runSummary)
+        summaryParts.push(runSummary);
+    const summary = summaryParts.join('\n\n');
+    return { status: 'auto', planId, summary };
+}
+function manualOutcome(planId, reason, severity) {
+    const messageParts = [];
+    if (severity && severity !== 'none') {
+        messageParts.push(`Forge reported ${severityLabel(severity)} concerns.`);
+    }
+    if (reason) {
+        messageParts.push(reason);
+    }
+    if (planId) {
+        messageParts.push(`Reply \`!plan approve ${planId}\` to approve, then \`!plan run ${planId}\` to start implementation. Or \`!plan show ${planId}\` to review first.`);
+    }
+    else {
+        messageParts.push('Review the plan manually, then use `!plan approve <id>` and `!plan run <id>` to continue.');
+    }
+    return { status: 'manual', message: messageParts.join(' ') };
+}
+function severityLabel(value) {
+    if (value in SEVERITY_LABELS) {
+        return SEVERITY_LABELS[value];
+    }
+    return `${value} severity`;
+}

package/dist/discord/forge-auto-implement.test.js

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from 'vitest';
+import { autoImplementForgePlan } from './forge-auto-implement.js';
+const baseResult = {
+    planId: 'plan-001',
+    filePath: 'plans/plan-001.md',
+    finalVerdict: 'none',
+    rounds: 1,
+    reachedMaxRounds: false,
+};
+const createDeps = (overrides = {}) => {
+    const log = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    };
+    const base = {
+        planApprove: vi.fn(() => Promise.resolve()),
+        planRun: vi.fn(() => Promise.resolve({ summary: 'Plan run started' })),
+        isPlanRunning: vi.fn(() => false),
+        log,
+    };
+    return { ...base, ...overrides };
+};
+const buildResult = (overrides = {}) => ({
+    ...baseResult,
+    ...overrides,
+});
+describe('autoImplementForgePlan', () => {
+    it('auto approves and runs a clean plan', async () => {
+        const result = buildResult();
+        const deps = createDeps();
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome).toEqual({ status: 'auto', planId: result.planId, summary: 'Plan run started' });
+        expect(deps.planApprove).toHaveBeenCalledWith(result.planId);
+        expect(deps.planRun).toHaveBeenCalledWith(result.planId);
+        expect(deps.log?.info).toHaveBeenCalled();
+    });
+    it('auto approves and runs a plan with non-blocking severity warnings', async () => {
+        const result = buildResult({ finalVerdict: 'medium' });
+        const deps = createDeps();
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('auto');
+        if (outcome.status !== 'auto')
+            throw new Error('expected auto');
+        expect(outcome.planId).toBe(result.planId);
+        expect(outcome.summary).toBe('Forge reported medium severity concerns.\n\nPlan run started');
+        expect(deps.planApprove).toHaveBeenCalledWith(result.planId);
+        expect(deps.planRun).toHaveBeenCalledWith(result.planId);
+        expect(deps.log?.info).toHaveBeenCalled();
+    });
+    it('warns when a plan run is already in progress', async () => {
+        const result = buildResult();
+        const deps = createDeps({ isPlanRunning: () => true });
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('A plan run is already in progress for this plan.');
+    });
+    it('notifies when the audit cap was reached', async () => {
+        const result = buildResult({ reachedMaxRounds: true });
+        const deps = createDeps();
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('CAP_REACHED');
+    });
+    it('propagates forge errors into the fallback message', async () => {
+        const result = buildResult({ error: 'timeout' });
+        const deps = createDeps();
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('Forge failed: timeout');
+    });
+    it('falls back when auto-approval throws', async () => {
+        const result = buildResult();
+        const planApprove = vi.fn(() => Promise.reject(new Error('boom')));
+        const deps = createDeps({ planApprove });
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('Auto-approval failed: Error: boom');
+        expect(deps.planRun).not.toHaveBeenCalled();
+        expect(deps.log?.error).toHaveBeenCalled();
+    });
+    it('logs and reports when the plan run fails', async () => {
+        const result = buildResult();
+        const planRun = vi.fn(() => Promise.reject(new Error('run fail')));
+        const deps = createDeps({ planRun });
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('Auto-run failed: Error: run fail');
+        expect(deps.log?.error).toHaveBeenCalled();
+    });
+    it('includes blocking severity labels in the fallback message', async () => {
+        const result = buildResult({ finalVerdict: 'blocking' });
+        const deps = createDeps();
+        const outcome = await autoImplementForgePlan({ planId: result.planId, result }, deps);
+        expect(outcome.status).toBe('manual');
+        if (outcome.status !== 'manual')
+            throw new Error('expected manual');
+        expect(outcome.message).toContain('blocking severity concerns');
+    });
+});