@renseiai/agentfactory 0.8.0

package/dist/src/orchestrator/parse-work-result.d.ts

@@ -0,0 +1,16 @@
+import type { AgentWorkType } from '@renseiai/agentfactory-linear';
+import type { AgentWorkResult } from './types.js';
+/**
+ * Parse the agent's result message to determine whether the work passed or failed.
+ *
+ * Detection priority:
+ * 1. Structured marker: `<!-- WORK_RESULT:passed/failed -->`
+ * 2. Heuristic heading/pattern matching scoped to the work type
+ * 3. Returns 'unknown' if nothing matches (safe default: no transition)
+ *
+ * @param resultMessage - The agent's final output message
+ * @param workType - The type of work performed (qa, acceptance, etc.)
+ * @returns 'passed', 'failed', or 'unknown'
+ */
+export declare function parseWorkResult(resultMessage: string | undefined, workType: AgentWorkType): AgentWorkResult;
+//# sourceMappingURL=parse-work-result.d.ts.map

package/dist/src/orchestrator/parse-work-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-work-result.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/parse-work-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AA+FjD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,QAAQ,EAAE,aAAa,GACtB,eAAe,CAyCjB"}

package/dist/src/orchestrator/parse-work-result.js

@@ -0,0 +1,135 @@
+/**
+ * Structured marker pattern embedded in agent output.
+ * Agents are instructed to include this marker in their final output.
+ *
+ * Format: <!-- WORK_RESULT:passed --> or <!-- WORK_RESULT:failed -->
+ */
+const STRUCTURED_MARKER_RE = /<!--\s*WORK_RESULT:(passed|failed)\s*-->/i;
+/**
+ * Heuristic patterns for detecting QA pass/fail when structured marker is absent.
+ * Patterns are checked case-insensitively against the result message.
+ */
+const QA_PASS_PATTERNS = [
+    // Heading patterns
+    /##\s*QA\s+Passed/i,
+    /##\s*QA\s+Complete[^]*?\bPASS/i,
+    // Explicit label patterns (with optional "QA" prefix, word-bounded to avoid WORK_RESULT)
+    /\b(?:QA\s+)?Result:\s*\*{0,2}Pass(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?Status:\s*\*{0,2}Pass(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?Verdict:\s*\*{0,2}Pass(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?(?:Result|Status|Verdict):\s*✅/i,
+    /Overall\s+(?:QA\s+)?Result:\s*PASS/i,
+    /Roll-?Up\s+Verdict:\s*PASS/i,
+    // Bold standalone PASS (agents commonly output **PASS** or **PASS.**)
+    /\*\*PASS\.?\*\*/,
+];
+const QA_FAIL_PATTERNS = [
+    // Heading patterns
+    /##\s*QA\s+Failed/i,
+    /##\s*QA\s+Complete[^]*?\bFAIL/i,
+    // Explicit label patterns (with optional "QA" prefix, word-bounded to avoid WORK_RESULT)
+    /\b(?:QA\s+)?Result:\s*\*{0,2}Fail(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?Status:\s*\*{0,2}Fail(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?Verdict:\s*\*{0,2}Fail(?:ed)?\*{0,2}/i,
+    /\b(?:QA\s+)?(?:Result|Status|Verdict):\s*❌/i,
+    /Overall\s+(?:QA\s+)?Result:\s*FAIL/i,
+    /Roll-?Up\s+Verdict:\s*FAIL/i,
+    /Parent\s+QA\s+verdict:\s*FAIL/i,
+    // Bold standalone FAIL
+    /\*\*FAIL\.?\*\*/,
+    // QA coordination report with issues found (agents output "Status: N Issues Found")
+    /\bStatus:\s*\d+\s+Issues?\s+Found\b/i,
+    // "Must Fix Before Merge" — agents use this heading for blocking findings
+    /\bMust\s+Fix\s+Before\s+Merge\b/i,
+    // "N Critical Issues (Block Merge)" — coordination QA summary format
+    /\d+\s+Critical\s+Issues?\s*\(Block\s+Merge\)/i,
+];
+const ACCEPTANCE_PASS_PATTERNS = [
+    /##\s*Acceptance\s+Complete/i,
+    /Acceptance\s+Result:\s*Pass/i,
+    /PR\s+has\s+been\s+merged\s+successfully/i,
+];
+const ACCEPTANCE_FAIL_PATTERNS = [
+    /##\s*Acceptance\s+(?:Processing\s+)?Failed/i,
+    /Acceptance\s+(?:Processing\s+)?Blocked/i,
+    /Acceptance\s+Result:\s*Fail/i,
+    /Cannot\s+merge\s+PR/i,
+    // Coordination-style patterns (agents output reports with "Must Fix" / "Critical Issues")
+    /\bMust\s+Fix\s+Before\s+Merge\b/i,
+    /\d+\s+Critical\s+Issues?\s*\(Block\s+Merge\)/i,
+];
+/**
+ * Heuristic patterns for detecting coordination pass/fail.
+ * These apply to the 'coordination' work type (development coordination).
+ */
+const COORDINATION_PASS_PATTERNS = [
+    // "all 8/8 sub-issues completed" or "all sub-issues completed"
+    /\ball\s+(?:\d+\/\d+\s+)?sub-issues?\s+(?:completed|finished)/i,
+    // "8/8 sub-issues completed/finished" (without leading "all")
+    /\b(\d+)\/\1\b.*\bsub-issues?\s+(?:completed|finished)/i,
+    // Explicit result labels
+    /\bCoordination\s+(?:Result|Status|Verdict):\s*\*{0,2}Pass(?:ed)?\*{0,2}/i,
+    /\bCoordination\s+Complete/i,
+    // "Parent issue marked Finished" — coordinator confirms parent status update
+    /\bParent\s+issue\s+marked\s+Finished/i,
+];
+const COORDINATION_FAIL_PATTERNS = [
+    // "Must Fix Before Merge" — agents use this heading for blocking issues
+    /\bMust\s+Fix\s+Before\s+Merge\b/i,
+    // "N Critical Issues (Block Merge)"
+    /\d+\s+Critical\s+Issues?\s*\(Block\s+Merge\)/i,
+    // "sub-issues need work/attention/fixes"
+    /\bsub-issues?\s+(?:need|require)[s]?\s+(?:work|attention|fixes?)\b/i,
+    // Explicit result labels
+    /\bCoordination\s+(?:Result|Status|Verdict):\s*\*{0,2}Fail(?:ed)?\*{0,2}/i,
+    /\bCoordination\s+Failed/i,
+];
+/**
+ * Parse the agent's result message to determine whether the work passed or failed.
+ *
+ * Detection priority:
+ * 1. Structured marker: `<!-- WORK_RESULT:passed/failed -->`
+ * 2. Heuristic heading/pattern matching scoped to the work type
+ * 3. Returns 'unknown' if nothing matches (safe default: no transition)
+ *
+ * @param resultMessage - The agent's final output message
+ * @param workType - The type of work performed (qa, acceptance, etc.)
+ * @returns 'passed', 'failed', or 'unknown'
+ */
+export function parseWorkResult(resultMessage, workType) {
+    if (!resultMessage) {
+        return 'unknown';
+    }
+    // 1. Check for structured marker (highest priority, work-type agnostic)
+    const markerMatch = resultMessage.match(STRUCTURED_MARKER_RE);
+    if (markerMatch) {
+        return markerMatch[1].toLowerCase();
+    }
+    // 2. Fall back to heuristic patterns scoped by work type
+    if (workType === 'qa' || workType === 'qa-coordination') {
+        if (QA_FAIL_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'failed';
+        }
+        if (QA_PASS_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'passed';
+        }
+    }
+    if (workType === 'acceptance' || workType === 'acceptance-coordination') {
+        if (ACCEPTANCE_FAIL_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'failed';
+        }
+        if (ACCEPTANCE_PASS_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'passed';
+        }
+    }
+    if (workType === 'coordination') {
+        if (COORDINATION_FAIL_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'failed';
+        }
+        if (COORDINATION_PASS_PATTERNS.some((p) => p.test(resultMessage))) {
+            return 'passed';
+        }
+    }
+    // 3. Unknown — safe default
+    return 'unknown';
+}

package/dist/src/orchestrator/parse-work-result.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse-work-result.test.d.ts.map

package/dist/src/orchestrator/parse-work-result.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-work-result.test.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/parse-work-result.test.ts"],"names":[],"mappings":""}

package/dist/src/orchestrator/parse-work-result.test.js

@@ -0,0 +1,234 @@
+import { describe, it, expect } from 'vitest';
+import { parseWorkResult } from './parse-work-result.js';
+describe('parseWorkResult', () => {
+    // Structured marker tests
+    describe('structured markers', () => {
+        it('detects <!-- WORK_RESULT:passed --> marker', () => {
+            expect(parseWorkResult('Some text <!-- WORK_RESULT:passed --> more text', 'qa')).toBe('passed');
+        });
+        it('detects <!-- WORK_RESULT:failed --> marker', () => {
+            expect(parseWorkResult('<!-- WORK_RESULT:failed -->', 'qa')).toBe('failed');
+        });
+        it('is case-insensitive for marker value', () => {
+            expect(parseWorkResult('<!-- WORK_RESULT:PASSED -->', 'qa')).toBe('passed');
+            expect(parseWorkResult('<!-- WORK_RESULT:Failed -->', 'acceptance')).toBe('failed');
+        });
+        it('handles extra whitespace in marker', () => {
+            expect(parseWorkResult('<!--  WORK_RESULT:passed  -->', 'qa')).toBe('passed');
+        });
+        it('finds marker anywhere in the message', () => {
+            const msg = 'Here is my QA report\n\nEverything looks good\n\n<!-- WORK_RESULT:passed -->\n\nEnd of report';
+            expect(parseWorkResult(msg, 'qa')).toBe('passed');
+        });
+        it('works for any work type (not just qa/acceptance)', () => {
+            expect(parseWorkResult('<!-- WORK_RESULT:passed -->', 'development')).toBe('passed');
+            expect(parseWorkResult('<!-- WORK_RESULT:failed -->', 'coordination')).toBe('failed');
+        });
+    });
+    // QA heuristic pattern tests
+    describe('QA heuristic patterns', () => {
+        it('detects "## QA Passed" heading', () => {
+            expect(parseWorkResult('## QA Passed\nAll tests pass.', 'qa')).toBe('passed');
+        });
+        it('detects "QA Result: Pass"', () => {
+            expect(parseWorkResult('QA Result: Pass', 'qa')).toBe('passed');
+        });
+        it('detects "QA Status: Passed"', () => {
+            expect(parseWorkResult('QA Status: Passed', 'qa')).toBe('passed');
+        });
+        it('detects "## QA Failed" heading', () => {
+            expect(parseWorkResult('## QA Failed\nTests are broken.', 'qa')).toBe('failed');
+        });
+        it('detects "QA Result: Fail"', () => {
+            expect(parseWorkResult('QA Result: Fail', 'qa')).toBe('failed');
+        });
+        it('does not match QA patterns for non-qa work types', () => {
+            expect(parseWorkResult('## QA Passed', 'development')).toBe('unknown');
+            expect(parseWorkResult('QA Result: Pass', 'acceptance')).toBe('unknown');
+        });
+        it('matches QA patterns for qa-coordination work type', () => {
+            expect(parseWorkResult('## QA Passed\nAll sub-issues pass.', 'qa-coordination')).toBe('passed');
+            expect(parseWorkResult('## QA Failed\nSUP-712 needs work.', 'qa-coordination')).toBe('failed');
+            expect(parseWorkResult('QA Result: Pass', 'qa-coordination')).toBe('passed');
+            expect(parseWorkResult('QA Result: Fail', 'qa-coordination')).toBe('failed');
+        });
+        it('checks fail patterns before pass patterns', () => {
+            // Both present - fail takes precedence since it's checked first
+            expect(parseWorkResult('## QA Failed\n## QA Passed', 'qa')).toBe('failed');
+        });
+        it('detects "Overall Result: FAIL" (coordination style)', () => {
+            expect(parseWorkResult('**Overall Result: FAIL** — 4 of 6 phases failed', 'qa-coordination')).toBe('failed');
+        });
+        it('detects "Overall QA Result: FAIL" (coordination style)', () => {
+            expect(parseWorkResult('**Overall QA Result: FAIL (0/6 sub-issues pass)**', 'qa-coordination')).toBe('failed');
+        });
+        it('detects "Roll-Up Verdict: FAIL"', () => {
+            expect(parseWorkResult('### Roll-Up Verdict: FAIL (0/6 sub-issues pass)', 'qa-coordination')).toBe('failed');
+        });
+        it('detects "Parent QA verdict: FAIL"', () => {
+            expect(parseWorkResult('**Parent QA verdict: FAIL — requires fixes**', 'qa-coordination')).toBe('failed');
+        });
+        it('detects "Overall Result: PASS" (coordination style)', () => {
+            expect(parseWorkResult('**Overall Result: PASS** — all phases passed', 'qa-coordination')).toBe('passed');
+        });
+        it('detects "Roll-Up Verdict: PASS"', () => {
+            expect(parseWorkResult('### Roll-Up Verdict: PASS (6/6 sub-issues pass)', 'qa-coordination')).toBe('passed');
+        });
+        // Real agent output patterns (SUP-867 regression)
+        it('detects bold **PASS**', () => {
+            expect(parseWorkResult('Branch unchanged — `4383c3e`. **PASS.** No new findings.', 'qa')).toBe('passed');
+        });
+        it('detects bold **PASS** without period', () => {
+            expect(parseWorkResult('All tests pass. **PASS**', 'qa')).toBe('passed');
+        });
+        it('detects "Verdict: PASS" without QA prefix', () => {
+            expect(parseWorkResult('**Verdict: PASS** — all criteria met', 'qa')).toBe('passed');
+        });
+        it('detects "Verdict: **PASS**" with bold', () => {
+            expect(parseWorkResult('Verdict: **PASS**', 'qa')).toBe('passed');
+        });
+        it('detects "Status: **PASS**" without QA prefix', () => {
+            expect(parseWorkResult('### Status: **PASS** — same as prior two passes', 'qa')).toBe('passed');
+        });
+        it('detects "Result: Pass" without QA prefix', () => {
+            expect(parseWorkResult('Result: Pass — no issues found', 'qa')).toBe('passed');
+        });
+        it('detects bold **FAIL**', () => {
+            expect(parseWorkResult('Build failed. **FAIL.**', 'qa')).toBe('failed');
+        });
+        it('detects "Verdict: FAIL" without QA prefix', () => {
+            expect(parseWorkResult('Verdict: FAIL — build errors detected', 'qa')).toBe('failed');
+        });
+        it('detects "Status: **FAIL**" without QA prefix', () => {
+            expect(parseWorkResult('Status: **FAIL**', 'qa')).toBe('failed');
+        });
+        it('does not false-positive on "tests pass" (no bold)', () => {
+            expect(parseWorkResult('All tests pass and everything looks good.', 'qa')).toBe('unknown');
+        });
+    });
+    // Acceptance heuristic pattern tests
+    describe('acceptance heuristic patterns', () => {
+        it('detects "## Acceptance Complete"', () => {
+            expect(parseWorkResult('## Acceptance Complete', 'acceptance')).toBe('passed');
+        });
+        it('detects "Acceptance Result: Pass"', () => {
+            expect(parseWorkResult('Acceptance Result: Pass', 'acceptance')).toBe('passed');
+        });
+        it('detects "PR has been merged successfully"', () => {
+            expect(parseWorkResult('PR has been merged successfully', 'acceptance')).toBe('passed');
+        });
+        it('detects "## Acceptance Failed"', () => {
+            expect(parseWorkResult('## Acceptance Failed', 'acceptance')).toBe('failed');
+        });
+        it('detects "Acceptance Processing Blocked"', () => {
+            expect(parseWorkResult('Acceptance Processing Blocked', 'acceptance')).toBe('failed');
+        });
+        it('detects "Cannot merge PR"', () => {
+            expect(parseWorkResult('Cannot merge PR', 'acceptance')).toBe('failed');
+        });
+        it('does not match acceptance patterns for non-acceptance work types', () => {
+            expect(parseWorkResult('## Acceptance Complete', 'qa')).toBe('unknown');
+            expect(parseWorkResult('PR has been merged successfully', 'development')).toBe('unknown');
+        });
+        it('matches acceptance patterns for acceptance-coordination work type', () => {
+            expect(parseWorkResult('## Acceptance Complete', 'acceptance-coordination')).toBe('passed');
+            expect(parseWorkResult('PR has been merged successfully', 'acceptance-coordination')).toBe('passed');
+            expect(parseWorkResult('## Acceptance Failed', 'acceptance-coordination')).toBe('failed');
+            expect(parseWorkResult('Cannot merge PR', 'acceptance-coordination')).toBe('failed');
+        });
+    });
+    // Coordination heuristic pattern tests
+    describe('coordination heuristic patterns', () => {
+        it('detects "all 8/8 sub-issues completed"', () => {
+            expect(parseWorkResult('all 8/8 sub-issues completed and marked Finished in Linear.', 'coordination')).toBe('passed');
+        });
+        it('detects "all sub-issues completed" without count', () => {
+            expect(parseWorkResult('All sub-issues completed successfully.', 'coordination')).toBe('passed');
+        });
+        it('detects "all sub-issues finished"', () => {
+            expect(parseWorkResult('All 3/3 sub-issues finished.', 'coordination')).toBe('passed');
+        });
+        it('detects "Coordination Complete"', () => {
+            expect(parseWorkResult('## Coordination Complete\nAll work done.', 'coordination')).toBe('passed');
+        });
+        it('detects "Must Fix Before Merge" as fail', () => {
+            expect(parseWorkResult('### CRITICAL — Must Fix Before Merge\n1. provision-trial.ts uses removed fields', 'coordination')).toBe('failed');
+        });
+        it('detects "N Critical Issues (Block Merge)" as fail', () => {
+            expect(parseWorkResult('### 3 Critical Issues (Block Merge)\n1. Bad migration', 'coordination')).toBe('failed');
+        });
+        it('detects "sub-issues need work" as fail', () => {
+            expect(parseWorkResult('2 sub-issues need work before this can proceed.', 'coordination')).toBe('failed');
+        });
+        it('detects "Parent issue marked Finished"', () => {
+            expect(parseWorkResult('Execution: Wave 1...Wave 2...Wave 3. Parent issue marked Finished in Linear.', 'coordination')).toBe('passed');
+        });
+        it('does not match coordination patterns for non-coordination work types', () => {
+            expect(parseWorkResult('All sub-issues completed.', 'development')).toBe('unknown');
+            expect(parseWorkResult('All sub-issues completed.', 'qa')).toBe('unknown');
+        });
+        it('checks fail patterns before pass patterns', () => {
+            expect(parseWorkResult('All 8/8 sub-issues completed.\n### Must Fix Before Merge\n1. Bad code', 'coordination')).toBe('failed');
+        });
+    });
+    // QA coordination with real agent output formats
+    describe('QA coordination real-world patterns', () => {
+        it('detects "Status: N Issues Found" as fail', () => {
+            expect(parseWorkResult('### Status: 3 Issues Found (1 Critical, 2 Minor)', 'qa-coordination')).toBe('failed');
+        });
+        it('detects "Must Fix Before Merge" in QA context as fail', () => {
+            expect(parseWorkResult('## QA Report\n### CRITICAL — Must Fix Before Merge\n1. Bad migration', 'qa')).toBe('failed');
+        });
+        it('detects "N Critical Issues (Block Merge)" in QA context as fail', () => {
+            expect(parseWorkResult('### 3 Critical Issues (Block Merge)\n1. Bad code', 'qa-coordination')).toBe('failed');
+        });
+    });
+    // Acceptance coordination with real agent output formats
+    describe('acceptance coordination real-world patterns', () => {
+        it('detects "Must Fix Before Merge" in acceptance context as fail', () => {
+            expect(parseWorkResult('## Acceptance Coordination Report\n### CRITICAL — Must Fix Before Merge', 'acceptance-coordination')).toBe('failed');
+        });
+        it('detects "N Critical Issues (Block Merge)" in acceptance context as fail', () => {
+            expect(parseWorkResult('### 3 Critical Issues (Block Merge)\n1. provision-trial.ts uses removed fields', 'acceptance-coordination')).toBe('failed');
+        });
+    });
+    // Unknown result tests
+    describe('unknown results', () => {
+        it('returns unknown for undefined message', () => {
+            expect(parseWorkResult(undefined, 'qa')).toBe('unknown');
+        });
+        it('returns unknown for empty string', () => {
+            expect(parseWorkResult('', 'qa')).toBe('unknown');
+        });
+        it('returns unknown for message without any markers or patterns', () => {
+            expect(parseWorkResult('Work completed successfully. All looks good.', 'qa')).toBe('unknown');
+        });
+        it('returns unknown for generic success messages without structured marker', () => {
+            expect(parseWorkResult('Everything passed! Great work.', 'qa')).toBe('unknown');
+        });
+        it('returns unknown for message with only whitespace', () => {
+            expect(parseWorkResult('   \n\n  \t  ', 'qa')).toBe('unknown');
+        });
+    });
+    // Priority / edge cases
+    describe('edge cases', () => {
+        it('prefers structured marker over heuristic patterns', () => {
+            const msg = '## QA Failed\n\nActually wait, it passed.\n\n<!-- WORK_RESULT:passed -->';
+            expect(parseWorkResult(msg, 'qa')).toBe('passed');
+        });
+        it('handles messages with multiple structured markers (takes first)', () => {
+            const msg = '<!-- WORK_RESULT:passed -->\nOops\n<!-- WORK_RESULT:failed -->';
+            expect(parseWorkResult(msg, 'qa')).toBe('passed');
+        });
+        it('handles very long messages', () => {
+            const long = 'x'.repeat(100000) +
+                '<!-- WORK_RESULT:passed -->' +
+                'y'.repeat(100000);
+            expect(parseWorkResult(long, 'qa')).toBe('passed');
+        });
+        it('does not match partial markers', () => {
+            expect(parseWorkResult('WORK_RESULT:passed', 'qa')).toBe('unknown');
+            expect(parseWorkResult('<!-- WORK_RESULT:maybe -->', 'qa')).toBe('unknown');
+        });
+    });
+});

package/dist/src/orchestrator/progress-logger.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Progress Logger
+ *
+ * Append-only log for debugging agent activity.
+ * Format: timestamp|event_type|details
+ */
+import type { ProgressLoggerConfig, ProgressEventType } from './state-types.js';
+/**
+ * ProgressLogger appends events to a log file for debugging
+ */
+export declare class ProgressLogger {
+    private readonly config;
+    private readonly logPath;
+    private stopped;
+    constructor(config: ProgressLoggerConfig);
+    /**
+     * Initialize the logger (create directory if needed)
+     */
+    init(): void;
+    /**
+     * Stop the logger
+     */
+    stop(): void;
+    /**
+     * Log an event
+     */
+    log(eventType: ProgressEventType, details: string | object): void;
+    /**
+     * Log agent start
+     */
+    logStart(details: {
+        issueId: string;
+        workType: string;
+        prompt: string;
+    }): void;
+    /**
+     * Log phase change
+     */
+    logPhase(phase: string): void;
+    /**
+     * Log tool call
+     */
+    logTool(toolName: string, input?: object): void;
+    /**
+     * Log error
+     */
+    logError(message: string, error?: Error | unknown): void;
+    /**
+     * Log recovery attempt
+     */
+    logRecovery(attempt: number, reason?: string): void;
+    /**
+     * Log completion
+     */
+    logComplete(details?: {
+        prUrl?: string;
+        message?: string;
+    }): void;
+    /**
+     * Log stop
+     */
+    logStop(reason: 'user_request' | 'timeout' | 'error'): void;
+    /**
+     * Rotate log file if it exceeds max size
+     */
+    private maybeRotate;
+}
+/**
+ * Create a progress logger for an agent
+ */
+export declare function createProgressLogger(config: ProgressLoggerConfig): ProgressLogger;
+//# sourceMappingURL=progress-logger.d.ts.map

package/dist/src/orchestrator/progress-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-logger.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/progress-logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAK/E;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,OAAO,CAAQ;gBAEX,MAAM,EAAE,oBAAoB;IAQxC;;OAEG;IACH,IAAI,IAAI,IAAI;IAOZ;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAkBjE;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAI9E;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI7B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAI/C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI;IAOxD;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAInD;;OAEG;IACH,WAAW,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAIjE;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,OAAO,GAAG,IAAI;IAI3D;;OAEG;IACH,OAAO,CAAC,WAAW;CAkBpB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAIjF"}

package/dist/src/orchestrator/progress-logger.js

@@ -0,0 +1,135 @@
+/**
+ * Progress Logger
+ *
+ * Append-only log for debugging agent activity.
+ * Format: timestamp|event_type|details
+ */
+import { appendFileSync, existsSync, mkdirSync, statSync, renameSync } from 'fs';
+import { resolve, dirname } from 'path';
+// Default max log size: 1MB
+const DEFAULT_MAX_SIZE_BYTES = 1024 * 1024;
+/**
+ * ProgressLogger appends events to a log file for debugging
+ */
+export class ProgressLogger {
+    config;
+    logPath;
+    stopped = false;
+    constructor(config) {
+        this.config = {
+            ...config,
+            maxSizeBytes: config.maxSizeBytes ?? DEFAULT_MAX_SIZE_BYTES,
+        };
+        this.logPath = resolve(this.config.agentDir, 'progress.log');
+    }
+    /**
+     * Initialize the logger (create directory if needed)
+     */
+    init() {
+        const dir = dirname(this.logPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    /**
+     * Stop the logger
+     */
+    stop() {
+        this.stopped = true;
+    }
+    /**
+     * Log an event
+     */
+    log(eventType, details) {
+        if (this.stopped)
+            return;
+        const timestamp = Date.now();
+        const detailsStr = typeof details === 'object' ? JSON.stringify(details) : details;
+        const line = `${timestamp}|${eventType}|${detailsStr}\n`;
+        try {
+            // Check if rotation is needed
+            this.maybeRotate();
+            // Append to log
+            appendFileSync(this.logPath, line);
+        }
+        catch (error) {
+            // Silently ignore errors - progress logging is best-effort
+        }
+    }
+    /**
+     * Log agent start
+     */
+    logStart(details) {
+        this.log('start', details);
+    }
+    /**
+     * Log phase change
+     */
+    logPhase(phase) {
+        this.log('phase', { phase });
+    }
+    /**
+     * Log tool call
+     */
+    logTool(toolName, input) {
+        this.log('tool', { toolName, input: input ? JSON.stringify(input).substring(0, 200) : undefined });
+    }
+    /**
+     * Log error
+     */
+    logError(message, error) {
+        this.log('error', {
+            message,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+    /**
+     * Log recovery attempt
+     */
+    logRecovery(attempt, reason) {
+        this.log('recovery', { attempt, reason });
+    }
+    /**
+     * Log completion
+     */
+    logComplete(details) {
+        this.log('complete', details ?? {});
+    }
+    /**
+     * Log stop
+     */
+    logStop(reason) {
+        this.log('stop', { reason });
+    }
+    /**
+     * Rotate log file if it exceeds max size
+     */
+    maybeRotate() {
+        try {
+            if (!existsSync(this.logPath))
+                return;
+            const stats = statSync(this.logPath);
+            if (stats.size >= this.config.maxSizeBytes) {
+                // Rotate: rename current to .old
+                const oldPath = `${this.logPath}.old`;
+                try {
+                    renameSync(this.logPath, oldPath);
+                }
+                catch {
+                    // Ignore rotation errors
+                }
+            }
+        }
+        catch {
+            // Ignore stat errors
+        }
+    }
+}
+/**
+ * Create a progress logger for an agent
+ */
+export function createProgressLogger(config) {
+    const logger = new ProgressLogger(config);
+    logger.init();
+    return logger;
+}