@renseiai/agentfactory 0.8.19 → 0.8.21

package/dist/src/orchestrator/orchestrator.js

@@ -18,10 +18,11 @@ import { isSessionLoggingEnabled, getLogAnalysisConfig } from './log-config.js';
 import { parseWorkResult } from './parse-work-result.js';
 import { parseSecurityScanOutput } from './security-scan-event.js';
 import { runBackstop, formatBackstopComment } from './session-backstop.js';
+import { captureQualityBaseline, computeQualityDelta, formatQualityReport, saveBaseline, loadBaseline, } from './quality-baseline.js';
 import { createActivityEmitter } from './activity-emitter.js';
 import { createApiActivityEmitter } from './api-activity-emitter.js';
 import { createLogger } from '../logger.js';
-import { TemplateRegistry, createToolPermissionAdapter } from '../templates/index.js';
+import { TemplateRegistry, CodexToolPermissionAdapter, createToolPermissionAdapter } from '../templates/index.js';
 import { loadRepositoryConfig, getProjectConfig, getProvidersConfig } from '../config/index.js';
 import { ToolRegistry } from '../tools/index.js';
 import { createMergeQueueAdapter } from '../merge-queue/index.js';
@@ -1009,8 +1010,11 @@ export class AgentOrchestrator {
                     // Initialize merge queue adapter from repository config
                     if (repoConfig.mergeQueue?.enabled && !config.mergeQueueAdapter) {
                         try {
-                            this.mergeQueueAdapter = createMergeQueueAdapter(repoConfig.mergeQueue.provider ?? 'github-native');
-                            console.log(`[orchestrator] Merge queue adapter initialized: ${repoConfig.mergeQueue.provider ?? 'github-native'}`);
+                            const provider = repoConfig.mergeQueue.provider ?? 'local';
+                            this.mergeQueueAdapter = createMergeQueueAdapter(provider, {
+                                storage: config.mergeQueueStorage,
+                            });
+                            console.log(`[orchestrator] Merge queue adapter initialized: ${provider}`);
                         }
                         catch (error) {
                             console.warn(`[orchestrator] Failed to initialize merge queue adapter: ${error instanceof Error ? error.message : String(error)}`);
@@ -1610,6 +1614,19 @@ export class AgentOrchestrator {
         this.writeWorktreeHelpers(worktreePath);
         // Configure mergiraf merge driver if enabled
         this.configureMergiraf(worktreePath);
+        // Capture quality baseline for delta checking (runs test/typecheck on main)
+        if (this.isQualityBaselineEnabled()) {
+            try {
+                const qualityConfig = this.buildQualityConfig();
+                const baseline = captureQualityBaseline(worktreePath, qualityConfig);
+                saveBaseline(worktreePath, baseline);
+                console.log(`Quality baseline captured: ${baseline.tests.total} tests, ${baseline.typecheck.errorCount} type errors, ${baseline.lint.errorCount} lint errors`);
+            }
+            catch (baselineError) {
+                // Log but don't fail worktree creation — quality gate is advisory
+                console.warn(`Failed to capture quality baseline: ${baselineError instanceof Error ? baselineError.message : String(baselineError)}`);
+            }
+        }
         return { worktreePath, worktreeIdentifier };
     }
     /**
@@ -1770,6 +1787,48 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
             console.warn(`Failed to configure mergiraf in worktree: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * Check if quality baseline capture is enabled via repository config.
+     */
+    isQualityBaselineEnabled() {
+        const quality = this.repoConfig?.quality;
+        return quality?.baselineEnabled ?? false;
+    }
+    /**
+     * Build quality config from orchestrator settings.
+     */
+    buildQualityConfig() {
+        return {
+            testCommand: this.testCommand,
+            validateCommand: this.validateCommand,
+            packageManager: this.packageManager ?? 'pnpm',
+            timeoutMs: 120_000,
+        };
+    }
+    /**
+     * Load quality baseline from a worktree and convert to TemplateContext shape.
+     */
+    loadQualityBaselineForContext(worktreePath) {
+        if (!worktreePath || !this.isQualityBaselineEnabled())
+            return undefined;
+        try {
+            const baseline = loadBaseline(worktreePath);
+            if (!baseline)
+                return undefined;
+            return {
+                tests: {
+                    total: baseline.tests.total,
+                    passed: baseline.tests.passed,
+                    failed: baseline.tests.failed,
+                },
+                typecheckErrors: baseline.typecheck.errorCount,
+                lintErrors: baseline.lint.errorCount,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Link dependencies from the main repo into a worktree via symlinks.
      *
@@ -2108,6 +2167,61 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
      * Resolve the provider for a specific spawn, using the full priority cascade.
      * Returns a cached provider instance (creating one if needed) and the resolved name.
      */
+    /**
+     * Build base instructions for Codex App Server agents (SUP-1746).
+     *
+     * Assembles safety rules and project-specific instructions (AGENTS.md / CLAUDE.md)
+     * into a persistent system prompt passed via `instructions` on `thread/start`.
+     */
+    buildCodexBaseInstructions(workType, worktreePath) {
+        const sections = [];
+        // Safety rules — mirrors autonomousCanUseTool deny patterns as natural-language rules
+        sections.push(`# Safety Rules
+
+You are running in an AgentFactory-managed worktree. Follow these rules strictly:
+
+1. NEVER run: rm -rf / (or any rm of the filesystem root)
+2. NEVER run: git worktree remove, git worktree prune
+3. NEVER run: git reset --hard
+4. NEVER run: git push --force (use --force-with-lease on feature branches if needed)
+5. NEVER run: git checkout <branch>, git switch <branch> (do not change the checked-out branch)
+6. NEVER modify files in the .git directory
+7. Commit changes with descriptive messages before reporting completion`);
+        // Project-specific instructions — load AGENTS.md or CLAUDE.md from worktree root
+        if (worktreePath) {
+            for (const filename of ['AGENTS.md', 'CLAUDE.md']) {
+                const instrPath = resolve(worktreePath, filename);
+                if (existsSync(instrPath)) {
+                    try {
+                        const content = readFileSync(instrPath, 'utf-8');
+                        if (content.trim()) {
+                            sections.push(`# Project Instructions (${filename})\n\n${content.trim()}`);
+                            break; // Only load one: AGENTS.md takes priority
+                        }
+                    }
+                    catch {
+                        // Ignore read errors — project instructions are optional
+                    }
+                }
+            }
+        }
+        return sections.join('\n\n');
+    }
+    /**
+     * Build Codex permission config from template permissions (SUP-1748).
+     *
+     * Translates abstract template `tools.allow` / `tools.disallow` into
+     * structured regex patterns for the Codex approval bridge.
+     */
+    buildCodexPermissionConfig(workType) {
+        if (!this.templateRegistry || !workType)
+            return undefined;
+        const { allow, disallow } = this.templateRegistry.getRawToolPermissions(workType);
+        if (allow.length === 0 && disallow.length === 0)
+            return undefined;
+        const adapter = new CodexToolPermissionAdapter();
+        return adapter.buildPermissionConfig(allow, disallow);
+    }
     resolveProviderForSpawn(context) {
         const { name, source } = resolveProviderWithSource({
             project: context.projectName,
@@ -2154,6 +2268,8 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
                 testCommand: perProject?.testCommand ?? this.testCommand,
                 validateCommand: perProject?.validateCommand ?? this.validateCommand,
                 agentBugBacklog: process.env.AGENT_BUG_BACKLOG || undefined,
+                mergeQueueEnabled: !!this.mergeQueueAdapter,
+                qualityBaseline: this.loadQualityBaselineForContext(worktreePath),
             };
             const rendered = this.templateRegistry.renderPrompt(workType, context);
             prompt = rendered ?? generatePromptForWorkType(identifier, workType);
@@ -2334,15 +2450,27 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
             env.LINEAR_TEAM_NAME = teamName;
         }
         log.info('Starting agent via provider', { provider: spawnProviderName, source: providerSource, cwd: worktreePath ?? 'repo-root', workType, promptPreview: prompt.substring(0, 50) });
-        // Create in-process tool servers from registered plugins
+        // Create tool servers from registered plugins
+        const toolPluginContext = { env, cwd: worktreePath ?? process.cwd() };
         const toolServers = spawnProviderName === 'claude'
-            ? this.toolRegistry.createServers({ env, cwd: worktreePath ?? process.cwd() })
+            ? this.toolRegistry.createServers(toolPluginContext)
+            : undefined;
+        // Create stdio MCP server configs for Codex provider (SUP-1744)
+        const stdioServers = spawnProviderName === 'codex'
+            ? this.toolRegistry.createStdioServerConfigs(toolPluginContext)
             : undefined;
         // Coordinators need significantly more turns than standard agents
         // since they spawn sub-agents and poll their status repeatedly.
         // Inflight also gets the bump — it may be resuming coordination work.
         const needsMoreTurns = workType === 'coordination' || workType === 'inflight-coordination' || workType === 'qa-coordination' || workType === 'acceptance-coordination' || workType === 'refinement-coordination' || workType === 'inflight';
         const maxTurns = needsMoreTurns ? 200 : undefined;
+        // SUP-1746/SUP-1748: Build Codex-specific base instructions and permission config
+        const codexBaseInstructions = spawnProviderName === 'codex'
+            ? this.buildCodexBaseInstructions(workType, worktreePath)
+            : undefined;
+        const codexPermissionConfig = spawnProviderName === 'codex' && this.templateRegistry
+            ? this.buildCodexPermissionConfig(workType)
+            : undefined;
         // Spawn agent via provider interface
         const spawnConfig = {
             prompt,
@@ -2353,7 +2481,10 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
             sandboxEnabled: this.config.sandboxEnabled,
             mcpServers: toolServers?.servers,
             mcpToolNames: toolServers?.toolNames,
+            mcpStdioServers: stdioServers?.servers,
             maxTurns,
+            baseInstructions: codexBaseInstructions,
+            permissionConfig: codexPermissionConfig,
             onProcessSpawned: (pid) => {
                 agent.pid = pid;
                 log.info('Agent process spawned', { pid });
@@ -2525,10 +2656,66 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
                     }
                 }
             }
+            // --- Quality Gate: Check quality delta for code-producing work types ---
+            if (agent.status === 'completed' && agent.worktreePath && this.isQualityBaselineEnabled()) {
+                const codeProducingTypes = ['development', 'inflight', 'coordination', 'inflight-coordination'];
+                const agentWorkType = agent.workType ?? 'development';
+                if (codeProducingTypes.includes(agentWorkType)) {
+                    try {
+                        const baseline = loadBaseline(agent.worktreePath);
+                        if (baseline) {
+                            const qualityConfig = this.buildQualityConfig();
+                            const current = captureQualityBaseline(agent.worktreePath, qualityConfig);
+                            const delta = computeQualityDelta(baseline, current);
+                            if (!delta.passed) {
+                                const report = formatQualityReport(baseline, current, delta);
+                                log?.warn('Quality gate FAILED — agent worsened quality metrics', {
+                                    testFailuresDelta: delta.testFailuresDelta,
+                                    typeErrorsDelta: delta.typeErrorsDelta,
+                                    lintErrorsDelta: delta.lintErrorsDelta,
+                                });
+                                // Post quality gate failure comment
+                                try {
+                                    await this.client.createComment(issueId, `## Quality Gate Failed\n\n` +
+                                        `The agent's changes worsened quality metrics compared to the baseline (main).\n\n` +
+                                        report +
+                                        `\n\n**Status promotion blocked.** The agent must fix quality regressions before this work can advance to QA.`);
+                                }
+                                catch {
+                                    // Best-effort comment
+                                }
+                                // Block status promotion by marking agent as failed
+                                agent.status = 'failed';
+                                agent.workResult = 'failed';
+                            }
+                            else {
+                                log?.info('Quality gate passed', {
+                                    testFailuresDelta: delta.testFailuresDelta,
+                                    typeErrorsDelta: delta.typeErrorsDelta,
+                                    testCountDelta: delta.testCountDelta,
+                                });
+                                if (delta.testFailuresDelta < 0 || delta.typeErrorsDelta < 0 || delta.lintErrorsDelta < 0) {
+                                    log?.info('Boy scout rule: agent improved quality metrics', {
+                                        testFailuresDelta: delta.testFailuresDelta,
+                                        typeErrorsDelta: delta.typeErrorsDelta,
+                                        lintErrorsDelta: delta.lintErrorsDelta,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    catch (qualityError) {
+                        log?.warn('Quality gate check failed (non-fatal)', {
+                            error: qualityError instanceof Error ? qualityError.message : String(qualityError),
+                        });
+                        // Quality gate check failure should not block the session — degrade gracefully
+                    }
+                }
+            }
             // Update Linear status based on work type if auto-transition is enabled
             if ((agent.status === 'completed' || agent.status === 'failed') && this.config.autoTransition) {
                 const workType = agent.workType ?? 'development';
-                const isResultSensitive = workType === 'qa' || workType === 'acceptance' || workType === 'coordination' || workType === 'qa-coordination' || workType === 'acceptance-coordination';
+                const isResultSensitive = workType === 'qa' || workType === 'acceptance' || workType === 'coordination' || workType === 'qa-coordination' || workType === 'acceptance-coordination' || workType === 'inflight-coordination' || workType === 'merge';
                 let targetStatus = null;
                 if (isResultSensitive) {
                     if (agent.status === 'failed') {
@@ -3529,10 +3716,20 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
                 });
                 // Build recovery prompt
                 const recoveryPrompt = prompt ?? buildRecoveryPrompt(recoveryCheck.state, recoveryCheck.todos);
-                // Use existing provider session ID for resume if available
-                const providerSessionId = recoveryCheck.state.providerSessionId ?? undefined;
                 // Inherit work type from previous state if not provided
                 const recoveryWorkType = workType ?? recoveryCheck.state.workType ?? effectiveWorkType;
+                // Use existing provider session ID for resume if available,
+                // but clear it when the work type has changed (e.g., dev → QA).
+                // A session from a different work type cannot be resumed — attempting
+                // it produces "No conversation found" and wastes the recovery attempt.
+                const workTypeChanged = recoveryWorkType !== recoveryCheck.state.workType;
+                const providerSessionId = workTypeChanged
+                    ? undefined
+                    : (recoveryCheck.state.providerSessionId ?? undefined);
+                if (workTypeChanged && recoveryCheck.state.providerSessionId) {
+                    console.log(`Clearing stale providerSessionId — work type changed from ${recoveryCheck.state.workType} to ${recoveryWorkType}`);
+                    updateState(worktreePath, { providerSessionId: null });
+                }
                 const effectiveSessionId = sessionId ?? recoveryCheck.state.linearSessionId ?? randomUUID();
                 console.log(`Resuming work on ${identifier} (recovery attempt ${updatedState?.recoveryAttempts ?? 1})`);
                 // Update status based on work type if auto-transition is enabled
@@ -4065,14 +4262,26 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
             resuming: !!providerSessionId,
             workType: workType ?? 'development',
         });
-        // Create in-process tool servers from registered plugins
+        // Create tool servers from registered plugins
+        const toolPluginContext = { env, cwd: worktreePath ?? process.cwd() };
         const toolServers = spawnProviderName === 'claude'
-            ? this.toolRegistry.createServers({ env, cwd: worktreePath ?? process.cwd() })
+            ? this.toolRegistry.createServers(toolPluginContext)
+            : undefined;
+        // Create stdio MCP server configs for Codex provider (SUP-1744)
+        const stdioServers = spawnProviderName === 'codex'
+            ? this.toolRegistry.createStdioServerConfigs(toolPluginContext)
             : undefined;
         // Coordinators need significantly more turns than standard agents
         const resolvedWorkType = workType ?? 'development';
         const needsMoreTurns = resolvedWorkType === 'coordination' || resolvedWorkType === 'qa-coordination' || resolvedWorkType === 'acceptance-coordination' || resolvedWorkType === 'refinement-coordination' || resolvedWorkType === 'inflight';
         const maxTurns = needsMoreTurns ? 200 : undefined;
+        // SUP-1746/SUP-1748: Build Codex-specific base instructions and permission config
+        const codexBaseInstructions = spawnProviderName === 'codex'
+            ? this.buildCodexBaseInstructions(workType, worktreePath)
+            : undefined;
+        const codexPermissionConfig = spawnProviderName === 'codex' && this.templateRegistry
+            ? this.buildCodexPermissionConfig(workType)
+            : undefined;
         // Spawn agent via provider interface (with resume if session ID available)
         const spawnConfig = {
             prompt,
@@ -4083,14 +4292,17 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
             sandboxEnabled: this.config.sandboxEnabled,
             mcpServers: toolServers?.servers,
             mcpToolNames: toolServers?.toolNames,
+            mcpStdioServers: stdioServers?.servers,
             maxTurns,
+            baseInstructions: codexBaseInstructions,
+            permissionConfig: codexPermissionConfig,
             onProcessSpawned: (pid) => {
                 agent.pid = pid;
                 log.info('Agent process spawned', { pid });
             },
         };
         const handle = providerSessionId
-            ? spawnProvider.resume(providerSessionId, spawnConfig)
+            ? this.createResumeWithFallbackHandle(spawnProvider, providerSessionId, spawnConfig, agent, log)
             : spawnProvider.spawn(spawnConfig);
         this.agentHandles.set(issueId, handle);
         agent.status = 'running';
@@ -4098,6 +4310,46 @@ ORCHESTRATOR_INSTALL=1 exec pnpm add "$@"
         this.processEventStream(issueId, identifier, sessionId, handle, emitter, agent);
         return agent;
     }
+    /**
+     * Create a resume handle that falls back to a fresh spawn if the session is stale.
+     * This avoids wasting a recovery attempt when the Claude Code session has expired.
+     */
+    createResumeWithFallbackHandle(provider, providerSessionId, spawnConfig, agent, log) {
+        let currentHandle = provider.resume(providerSessionId, spawnConfig);
+        const fallbackStream = async function* () {
+            for await (const event of currentHandle.stream) {
+                // Detect stale session error: the resume failed because the session no longer exists
+                if (event.type === 'result' &&
+                    !event.success &&
+                    event.errors?.some(e => e.includes('No conversation found with session ID'))) {
+                    log?.warn('Stale session detected during resume — falling back to fresh spawn', {
+                        staleSessionId: providerSessionId,
+                    });
+                    // Clear stale session from worktree state
+                    if (agent.worktreePath) {
+                        try {
+                            updateState(agent.worktreePath, { providerSessionId: null });
+                        }
+                        catch {
+                            // Ignore state update errors
+                        }
+                    }
+                    agent.providerSessionId = undefined;
+                    // Spawn fresh and yield all its events instead
+                    currentHandle = provider.spawn(spawnConfig);
+                    yield* currentHandle.stream;
+                    return;
+                }
+                yield event;
+            }
+        };
+        return {
+            get sessionId() { return currentHandle.sessionId; },
+            stream: fallbackStream(),
+            injectMessage: (text) => currentHandle.injectMessage(text),
+            stop: () => currentHandle.stop(),
+        };
+    }
     /**
      * Stop all running agents
      */

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

@@ -1 +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,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AA6HjD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,QAAQ,EAAE,aAAa,GACtB,eAAe,CAkDjB"}
+{"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,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AA+HjD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,QAAQ,EAAE,aAAa,GACtB,eAAe,CAkDjB"}

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

@@ -71,8 +71,10 @@ const ACCEPTANCE_FAIL_PATTERNS = [
  * These apply to the 'coordination' work type (development coordination).
  */
 const COORDINATION_PASS_PATTERNS = [
-    // "all 8/8 sub-issues completed" or "all sub-issues completed"
+    // "all 8/8 sub-issues completed" or "all sub-issues completed/finished"
     /\ball\s+(?:\d+\/\d+\s+)?sub-issues?\s+(?:completed|finished)/i,
+    // "All N sub-issues: Finished" / "All 6 sub-issues: Finished" (colon-separated format)
+    /\ball\s+\d+\s+sub-issues?[:\s—–-]+\s*finished/i,
     // "8/8 sub-issues completed/finished" (without leading "all")
     /\b(\d+)\/\1\b.*\bsub-issues?\s+(?:completed|finished)/i,
     // Explicit result labels

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

@@ -185,6 +185,12 @@ describe('parseWorkResult', () => {
         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('detects "All 6 sub-issues: Finished" (colon format)', () => {
+            expect(parseWorkResult('### All 6 sub-issues: Finished\n\n| SUP-1607 | SubscriptionProvider | Finished |', 'coordination')).toBe('passed');
+        });
+        it('detects "All 3 sub-issues — Finished" (dash format)', () => {
+            expect(parseWorkResult('All 3 sub-issues — Finished. PR created.', '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');

package/dist/src/orchestrator/quality-baseline.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Quality Baseline — Capture & Compare
+ *
+ * Captures quality metrics (test counts, typecheck errors, lint errors) from a
+ * worktree at a point in time. The orchestrator captures a baseline on main
+ * before the agent starts, then compares after the agent finishes. If the agent
+ * made quality worse (delta > 0 for any failure metric), promotion is blocked.
+ *
+ * This module is standalone — no orchestrator or template dependencies.
+ */
+export interface QualityBaseline {
+    timestamp: string;
+    commitSha: string;
+    tests: {
+        total: number;
+        passed: number;
+        failed: number;
+        skipped: number;
+    };
+    typecheck: {
+        errorCount: number;
+        exitCode: number;
+    };
+    lint: {
+        errorCount: number;
+        warningCount: number;
+    };
+}
+export interface QualityDelta {
+    /** Positive = worse (more failures) */
+    testFailuresDelta: number;
+    /** Positive = worse (more errors) */
+    typeErrorsDelta: number;
+    /** Positive = worse (more errors) */
+    lintErrorsDelta: number;
+    /** Negative = tests removed (warning, not a gate failure) */
+    testCountDelta: number;
+    /** True if no metric got worse */
+    passed: boolean;
+}
+export interface QualityConfig {
+    testCommand?: string;
+    validateCommand?: string;
+    lintCommand?: string;
+    packageManager?: string;
+    timeoutMs?: number;
+}
+/**
+ * Capture quality metrics from a worktree. Runs test, typecheck, and lint
+ * commands, parsing their output for structured counts.
+ *
+ * Each command is independent — a failure in one does not prevent capturing the others.
+ */
+export declare function captureQualityBaseline(worktreePath: string, config?: QualityConfig): QualityBaseline;
+/**
+ * Compute the quality delta between a baseline and current snapshot.
+ * Pure arithmetic — no side effects.
+ */
+export declare function computeQualityDelta(baseline: QualityBaseline, current: QualityBaseline): QualityDelta;
+/**
+ * Format a quality comparison into a markdown table for diagnostic comments.
+ */
+export declare function formatQualityReport(baseline: QualityBaseline, current: QualityBaseline, delta: QualityDelta): string;
+/**
+ * Save a quality baseline to the worktree's .agent/ directory.
+ */
+export declare function saveBaseline(worktreePath: string, baseline: QualityBaseline): void;
+/**
+ * Load a previously saved quality baseline from the worktree's .agent/ directory.
+ * Returns null if no baseline exists.
+ */
+export declare function loadBaseline(worktreePath: string): QualityBaseline | null;
+/**
+ * Parse vitest JSON reporter output.
+ * Expected fields: numTotalTests, numPassedTests, numFailedTests
+ */
+export declare function parseVitestJson(output: string): QualityBaseline['tests'] | null;
+/**
+ * Count TypeScript errors in tsc output.
+ * Matches lines like: "src/foo.ts(10,5): error TS2304: ..."
+ */
+export declare function countTypescriptErrors(output: string): number;
+//# sourceMappingURL=quality-baseline.d.ts.map

package/dist/src/orchestrator/quality-baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-baseline.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/quality-baseline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAUH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE;QACL,KAAK,EAAE,MAAM,CAAA;QACb,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,EAAE,MAAM,CAAA;QACd,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;IACD,SAAS,EAAE;QACT,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAA;IACD,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAA;QAClB,YAAY,EAAE,MAAM,CAAA;KACrB,CAAA;CACF;AAED,MAAM,WAAW,YAAY;IAC3B,uCAAuC;IACvC,iBAAiB,EAAE,MAAM,CAAA;IACzB,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAA;IACvB,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,kCAAkC;IAClC,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAMD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,MAAM,GAAE,aAAkB,GACzB,eAAe,CAiBjB;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,eAAe,GACvB,YAAY,CAad;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,YAAY,GAClB,MAAM,CAmBR;AAMD;;GAEG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAMlF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAQzE;AA0HD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,IAAI,CAmC/E;AAoCD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAI5D"}