@renseiai/agentfactory 0.8.18 → 0.8.20

package/dist/src/governor/decision-engine-adapter.test.js

@@ -0,0 +1,362 @@
+import { describe, it, expect } from 'vitest';
+import { DecisionEngineAdapter } from './decision-engine-adapter.js';
+import { decideAction, MAX_SESSION_ATTEMPTS } from './decision-engine.js';
+import { DEFAULT_GOVERNOR_CONFIG } from './governor-types.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeIssue(overrides = {}) {
+    return {
+        id: 'issue-1',
+        identifier: 'SUP-100',
+        title: 'Test Issue',
+        description: undefined,
+        status: 'Backlog',
+        labels: [],
+        createdAt: Date.now() - 2 * 60 * 60 * 1000,
+        ...overrides,
+    };
+}
+function makeContext(overrides = {}) {
+    return {
+        issue: makeIssue(),
+        config: { ...DEFAULT_GOVERNOR_CONFIG, projects: ['TestProject'] },
+        hasActiveSession: false,
+        isHeld: false,
+        isWithinCooldown: false,
+        isParentIssue: false,
+        workflowStrategy: undefined,
+        researchCompleted: false,
+        backlogCreationCompleted: false,
+        completedSessionCount: 0,
+        ...overrides,
+    };
+}
+function findNode(workflow, name) {
+    return workflow.nodes?.find(n => n.name === name);
+}
+// ---------------------------------------------------------------------------
+// Basic structure tests
+// ---------------------------------------------------------------------------
+describe('DecisionEngineAdapter', () => {
+    describe('toWorkflowDefinition', () => {
+        it('generates a valid WorkflowDefinition v2', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            expect(workflow.apiVersion).toBe('v2');
+            expect(workflow.kind).toBe('WorkflowDefinition');
+            expect(workflow.metadata.name).toBe('governor-decision-engine');
+        });
+        it('uses custom workflow name when provided', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition({
+                workflowName: 'custom-workflow',
+            });
+            expect(workflow.metadata.name).toBe('custom-workflow');
+        });
+        it('includes triggers for Linear events and governor scan', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            expect(workflow.triggers).toHaveLength(2);
+            expect(workflow.triggers?.[0].name).toBe('issue-status-change');
+            expect(workflow.triggers?.[0].source).toBe('linear');
+            expect(workflow.triggers?.[1].name).toBe('governor-scan');
+            expect(workflow.triggers?.[1].type).toBe('schedule');
+        });
+        it('includes agent and linear providers', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            expect(workflow.providers).toHaveLength(2);
+            const names = workflow.providers?.map(p => p.name);
+            expect(names).toContain('linear');
+            expect(names).toContain('agent');
+        });
+        it('stores governor config values in workflow config', () => {
+            const config = {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                enableAutoDevelopment: false,
+                enableAutoQA: false,
+            };
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition({ governorConfig: config });
+            expect(workflow.config?.enableAutoDevelopment).toBe(false);
+            expect(workflow.config?.enableAutoQA).toBe(false);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Guard nodes
+    // ---------------------------------------------------------------------------
+    describe('guard nodes', () => {
+        const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+        it('includes active-session guard', () => {
+            const node = findNode(workflow, 'guard-active-session');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('hasActiveSession');
+        });
+        it('includes cooldown guard', () => {
+            const node = findNode(workflow, 'guard-cooldown');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('isWithinCooldown');
+        });
+        it('includes hold guard', () => {
+            const node = findNode(workflow, 'guard-hold');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('isHeld');
+        });
+        it('includes gate guard', () => {
+            const node = findNode(workflow, 'guard-gates');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('gateEvaluation');
+        });
+        it('includes circuit breaker guard', () => {
+            const node = findNode(workflow, 'guard-circuit-breaker');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain(`${MAX_SESSION_ATTEMPTS}`);
+        });
+        it('includes terminal status guard', () => {
+            const node = findNode(workflow, 'guard-terminal-status');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Accepted');
+            expect(node?.when).toContain('Canceled');
+            expect(node?.when).toContain('Duplicate');
+        });
+        it('includes sub-issue guard', () => {
+            const node = findNode(workflow, 'guard-sub-issue');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('parentId');
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Routing nodes
+    // ---------------------------------------------------------------------------
+    describe('routing nodes', () => {
+        it('includes Backlog routing node', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'route-backlog');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Backlog');
+            const actions = node?.steps?.map(s => s.action);
+            expect(actions).toContain('trigger-development');
+        });
+        it('includes Started routing node', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'route-started');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Started');
+        });
+        it('includes Finished routing node with QA', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'route-finished');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Finished');
+            const actions = node?.steps?.map(s => s.action);
+            expect(actions).toContain('trigger-qa');
+            expect(actions).toContain('escalate-human');
+            expect(actions).toContain('decompose');
+        });
+        it('never includes merge queue step in Finished (merge queue does not bypass QA)', () => {
+            const workflowEnabled = DecisionEngineAdapter.toWorkflowDefinition({
+                includeMergeQueue: true,
+            });
+            const nodeEnabled = findNode(workflowEnabled, 'route-finished');
+            const actionsEnabled = nodeEnabled?.steps?.map(s => s.action);
+            expect(actionsEnabled).not.toContain('trigger-merge');
+            const workflowDisabled = DecisionEngineAdapter.toWorkflowDefinition({
+                includeMergeQueue: false,
+            });
+            const nodeDisabled = findNode(workflowDisabled, 'route-finished');
+            const actionsDisabled = nodeDisabled?.steps?.map(s => s.action);
+            expect(actionsDisabled).not.toContain('trigger-merge');
+        });
+        it('includes Delivered routing node', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'route-delivered');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Delivered');
+            const actions = node?.steps?.map(s => s.action);
+            expect(actions).toContain('trigger-acceptance');
+        });
+        it('includes Rejected routing node with escalation', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'route-rejected');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Rejected');
+            const actions = node?.steps?.map(s => s.action);
+            expect(actions).toContain('trigger-refinement');
+            expect(actions).toContain('escalate-human');
+            expect(actions).toContain('decompose');
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Top-of-funnel (Icebox) nodes
+    // ---------------------------------------------------------------------------
+    describe('top-of-funnel nodes', () => {
+        it('includes Icebox research node by default', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'icebox-research');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Icebox');
+            expect(node?.when).toContain('enableAutoResearch');
+        });
+        it('includes Icebox backlog-creation node by default', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition();
+            const node = findNode(workflow, 'icebox-backlog-creation');
+            expect(node).toBeDefined();
+            expect(node?.when).toContain('Icebox');
+            expect(node?.when).toContain('enableAutoBacklogCreation');
+        });
+        it('excludes top-of-funnel nodes when disabled', () => {
+            const workflow = DecisionEngineAdapter.toWorkflowDefinition({
+                includeTopOfFunnel: false,
+            });
+            expect(findNode(workflow, 'icebox-research')).toBeUndefined();
+            expect(findNode(workflow, 'icebox-backlog-creation')).toBeUndefined();
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Decision parity: verify the adapter covers all decision paths
+    // ---------------------------------------------------------------------------
+    describe('decision parity with decideAction()', () => {
+        const workflow = DecisionEngineAdapter.toWorkflowDefinition({
+            includeMergeQueue: true,
+            includeTopOfFunnel: true,
+        });
+        it('covers active session skip → guard-active-session node exists', () => {
+            const ctx = makeContext({ hasActiveSession: true });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'guard-active-session')).toBeDefined();
+        });
+        it('covers cooldown skip → guard-cooldown node exists', () => {
+            const ctx = makeContext({ isWithinCooldown: true });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'guard-cooldown')).toBeDefined();
+        });
+        it('covers hold skip → guard-hold node exists', () => {
+            const ctx = makeContext({ isHeld: true });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'guard-hold')).toBeDefined();
+        });
+        it('covers circuit breaker → guard-circuit-breaker node exists', () => {
+            const ctx = makeContext({ completedSessionCount: MAX_SESSION_ATTEMPTS });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'guard-circuit-breaker')).toBeDefined();
+        });
+        it('covers terminal status → guard-terminal-status node exists', () => {
+            for (const status of ['Accepted', 'Canceled', 'Duplicate']) {
+                const ctx = makeContext({ issue: makeIssue({ status }) });
+                const result = decideAction(ctx);
+                expect(result.action).toBe('none');
+            }
+            expect(findNode(workflow, 'guard-terminal-status')).toBeDefined();
+        });
+        it('covers sub-issue guard → guard-sub-issue node exists', () => {
+            const ctx = makeContext({ issue: makeIssue({ parentId: 'parent-1' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'guard-sub-issue')).toBeDefined();
+        });
+        it('covers Backlog → trigger-development', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Backlog' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('trigger-development');
+            const node = findNode(workflow, 'route-backlog');
+            const dispatchStep = node?.steps?.find(s => s.action === 'trigger-development');
+            expect(dispatchStep).toBeDefined();
+        });
+        it('covers Finished → trigger-qa', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Finished' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('trigger-qa');
+            const node = findNode(workflow, 'route-finished');
+            const qaStep = node?.steps?.find(s => s.action === 'trigger-qa');
+            expect(qaStep).toBeDefined();
+        });
+        it('covers Finished + escalate-human → escalate-human', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Finished' }),
+                workflowStrategy: 'escalate-human',
+            });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('escalate-human');
+            const node = findNode(workflow, 'route-finished');
+            const escalateStep = node?.steps?.find(s => s.action === 'escalate-human');
+            expect(escalateStep).toBeDefined();
+        });
+        it('covers Finished + decompose → decompose', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Finished' }),
+                workflowStrategy: 'decompose',
+            });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('decompose');
+            const node = findNode(workflow, 'route-finished');
+            const decomposeStep = node?.steps?.find(s => s.action === 'decompose');
+            expect(decomposeStep).toBeDefined();
+        });
+        it('Finished always triggers QA even with merge queue enabled (merge queue does not bypass QA)', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Finished' }),
+                mergeQueueEnabled: true,
+            });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('trigger-qa');
+            const node = findNode(workflow, 'route-finished');
+            // No trigger-merge step should exist in the Finished node
+            const mergeStep = node?.steps?.find(s => s.action === 'trigger-merge');
+            expect(mergeStep).toBeUndefined();
+        });
+        it('covers Delivered → trigger-acceptance', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Delivered' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('trigger-acceptance');
+            const node = findNode(workflow, 'route-delivered');
+            const acceptStep = node?.steps?.find(s => s.action === 'trigger-acceptance');
+            expect(acceptStep).toBeDefined();
+        });
+        it('covers Rejected → trigger-refinement', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Rejected' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('trigger-refinement');
+            const node = findNode(workflow, 'route-rejected');
+            const refineStep = node?.steps?.find(s => s.action === 'trigger-refinement');
+            expect(refineStep).toBeDefined();
+        });
+        it('covers Rejected + escalate-human → escalate-human', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Rejected' }),
+                workflowStrategy: 'escalate-human',
+            });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('escalate-human');
+            const node = findNode(workflow, 'route-rejected');
+            const escalateStep = node?.steps?.find(s => s.action === 'escalate-human');
+            expect(escalateStep).toBeDefined();
+        });
+        it('covers Started → none', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Started' }) });
+            const result = decideAction(ctx);
+            expect(result.action).toBe('none');
+            expect(findNode(workflow, 'route-started')).toBeDefined();
+        });
+        it('all decideAction decision points have corresponding workflow nodes', () => {
+            // Comprehensive check: every decision path in decideAction has a matching node
+            const nodeNames = workflow.nodes?.map(n => n.name) ?? [];
+            // Guard nodes
+            expect(nodeNames).toContain('guard-active-session');
+            expect(nodeNames).toContain('guard-cooldown');
+            expect(nodeNames).toContain('guard-hold');
+            expect(nodeNames).toContain('guard-gates');
+            expect(nodeNames).toContain('guard-circuit-breaker');
+            expect(nodeNames).toContain('guard-terminal-status');
+            expect(nodeNames).toContain('guard-sub-issue');
+            // Routing nodes
+            expect(nodeNames).toContain('route-backlog');
+            expect(nodeNames).toContain('route-started');
+            expect(nodeNames).toContain('route-finished');
+            expect(nodeNames).toContain('route-delivered');
+            expect(nodeNames).toContain('route-rejected');
+            // Top-of-funnel
+            expect(nodeNames).toContain('icebox-research');
+            expect(nodeNames).toContain('icebox-backlog-creation');
+        });
+    });
+});

package/dist/src/governor/decision-engine.js

@@ -244,13 +244,9 @@ function decideFinished(ctx) {
             reason: `Issue ${issue.identifier} is in Finished with decompose strategy — triggering decomposition`,
         };
     }
-    // When merge queue is enabled, enqueue to merge queue instead of QA
-    if (ctx.mergeQueueEnabled) {
-        return {
-            action: 'trigger-merge',
-            reason: `Issue ${issue.identifier} is in Finished — enqueuing to merge queue`,
-        };
-    }
+    // Always run QA to validate functional correctness, even when merge queue is
+    // enabled. The merge queue handles git mechanics (rebase, conflict resolution)
+    // at merge time — it should not bypass implementation validation.
     return {
         action: 'trigger-qa',
         reason: `Issue ${issue.identifier} is in Finished — triggering QA`,

package/dist/src/governor/decision-engine.test.js

@@ -408,15 +408,15 @@ describe('decideAction — Finished (QA)', () => {
 // ---------------------------------------------------------------------------
 // Finished (merge queue)
 // ---------------------------------------------------------------------------
-describe('decideAction — Finished (merge queue)', () => {
-    it('triggers trigger-merge when mergeQueueEnabled is true', () => {
+describe('decideAction — Finished (merge queue does not bypass QA)', () => {
+    it('triggers QA even when mergeQueueEnabled is true', () => {
         const ctx = makeContext({
             issue: makeIssue({ status: 'Finished' }),
             mergeQueueEnabled: true,
         });
         const result = decideAction(ctx);
-        expect(result.action).toBe('trigger-merge');
-        expect(result.reason).toContain('merge queue');
+        expect(result.action).toBe('trigger-qa');
+        expect(result.reason).toContain('triggering QA');
     });
     it('triggers QA when mergeQueueEnabled is false', () => {
         const ctx = makeContext({
@@ -453,7 +453,7 @@ describe('decideAction — Finished (merge queue)', () => {
         const result = decideAction(ctx);
         expect(result.action).toBe('decompose');
     });
-    it('auto-QA disabled takes precedence over merge queue', () => {
+    it('auto-QA disabled takes precedence even with merge queue', () => {
         const ctx = makeContext({
             issue: makeIssue({ status: 'Finished' }),
             mergeQueueEnabled: true,

package/dist/src/governor/index.d.ts

@@ -11,4 +11,5 @@ export * from './in-memory-event-bus.js';
 export * from './event-deduplicator.js';
 export * from './event-driven-governor.js';
 export * from './platform-adapter.js';
+export * from './decision-engine-adapter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/governor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/governor/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/governor/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,yBAAyB,CAAA;AACvC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uBAAuB,CAAA;AACrC,cAAc,8BAA8B,CAAA"}

package/dist/src/governor/index.js

@@ -11,3 +11,4 @@ export * from './in-memory-event-bus.js';
 export * from './event-deduplicator.js';
 export * from './event-driven-governor.js';
 export * from './platform-adapter.js';
+export * from './decision-engine-adapter.js';

package/dist/src/index.d.ts

@@ -11,4 +11,5 @@ export * from './tools/index.js';
 export * from './workflow/index.js';
 export * from './routing/index.js';
 export * from './registry/index.js';
+export * from './merge-queue/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA"}

package/dist/src/index.js

@@ -11,3 +11,4 @@ export * from './tools/index.js';
 export * from './workflow/index.js';
 export * from './routing/index.js';
 export * from './registry/index.js';
+export * from './merge-queue/index.js';

package/dist/src/manifest/route-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-manifest.d.ts","sourceRoot":"","sources":["../../../src/manifest/route-manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAElD,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAA;IAClB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,KAAK,EAAE,SAAS,EAAE,CAAA;CACnB;AAED,eAAO,MAAM,cAAc,EAAE,aAmJ5B,CAAA"}
+{"version":3,"file":"route-manifest.d.ts","sourceRoot":"","sources":["../../../src/manifest/route-manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAA;AAElD,MAAM,WAAW,UAAU;IACzB,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;CAC7C;AAED,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAA;IAClB,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,UAAU,EAAE,CAAA;IACpB,KAAK,EAAE,SAAS,EAAE,CAAA;CACnB;AAED,eAAO,MAAM,cAAc,EAAE,aAuJ5B,CAAA"}

package/dist/src/manifest/route-manifest.js

@@ -99,6 +99,10 @@ export const ROUTE_MANIFEST = {
             path: 'src/app/api/public/sessions/[id]/route.ts',
             methods: { GET: 'routes.public.sessionDetail.GET' },
         },
+        {
+            path: 'src/app/api/public/phase-metrics/route.ts',
+            methods: { GET: 'routes.public.phaseMetrics.GET' },
+        },
         // Config route
         {
             path: 'src/app/api/config/route.ts',

package/dist/src/merge-queue/adapters/local.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Local Merge Queue Adapter
+ *
+ * Self-hosted merge queue that uses the built-in merge worker + Redis storage
+ * instead of an external service like GitHub's merge queue. This is the default
+ * provider — it works with any GitHub repository without requiring GitHub's
+ * paid merge queue feature.
+ *
+ * The adapter handles queue management (enqueue/dequeue/status). The merge worker
+ * (merge-worker.ts) handles the actual rebase → resolve → test → merge pipeline.
+ *
+ * PR eligibility is checked via `gh pr view` CLI (no GraphQL needed).
+ */
+import type { MergeQueueAdapter, MergeQueueStatus } from '../types.js';
+export interface LocalMergeQueueStorage {
+    enqueue(entry: {
+        repoId: string;
+        prNumber: number;
+        prUrl: string;
+        issueIdentifier: string;
+        priority: number;
+        sourceBranch: string;
+        targetBranch: string;
+    }): Promise<void>;
+    dequeue(repoId: string): Promise<{
+        prNumber: number;
+    } | null>;
+    /** Get queue depth for a repo */
+    getQueueDepth(repoId: string): Promise<number>;
+    /** Check if a PR is already in the queue */
+    isEnqueued(repoId: string, prNumber: number): Promise<boolean>;
+    /** Get position of a PR in the queue (1-based), or null if not queued */
+    getPosition(repoId: string, prNumber: number): Promise<number | null>;
+    /** Remove a specific PR from the queue */
+    remove(repoId: string, prNumber: number): Promise<void>;
+    /** Get failed/blocked status for a PR */
+    getFailedReason(repoId: string, prNumber: number): Promise<string | null>;
+    getBlockedReason(repoId: string, prNumber: number): Promise<string | null>;
+}
+export declare class LocalMergeQueueAdapter implements MergeQueueAdapter {
+    private storage;
+    readonly name: "local";
+    constructor(storage: LocalMergeQueueStorage);
+    /**
+     * Check if a PR is eligible for the local merge queue.
+     * Uses `gh pr view` to verify PR is open. Does NOT require the PR to be
+     * conflict-free — the merge worker handles rebasing.
+     */
+    canEnqueue(owner: string, repo: string, prNumber: number): Promise<boolean>;
+    /**
+     * Add a PR to the local merge queue.
+     * The merge worker will pick it up and process it (rebase, test, merge).
+     */
+    enqueue(owner: string, repo: string, prNumber: number): Promise<MergeQueueStatus>;
+    /**
+     * Get the status of a PR in the local merge queue.
+     */
+    getStatus(owner: string, repo: string, prNumber: number): Promise<MergeQueueStatus>;
+    /**
+     * Remove a PR from the local merge queue.
+     */
+    dequeue(owner: string, repo: string, prNumber: number): Promise<void>;
+    /**
+     * Local merge queue is always available (no external service dependency).
+     */
+    isEnabled(_owner: string, _repo: string): Promise<boolean>;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/src/merge-queue/adapters/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/adapters/local.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAWtE,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,KAAK,EAAE;QACb,MAAM,EAAE,MAAM,CAAA;QACd,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,MAAM,CAAA;QACb,eAAe,EAAE,MAAM,CAAA;QACvB,QAAQ,EAAE,MAAM,CAAA;QAChB,YAAY,EAAE,MAAM,CAAA;QACpB,YAAY,EAAE,MAAM,CAAA;KACrB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;IAE7D,iCAAiC;IACjC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAE9C,4CAA4C;IAC5C,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE9D,yEAAyE;IACzE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IAErE,0CAA0C;IAC1C,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEvD,yCAAyC;IACzC,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACzE,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;CAC3E;AAMD,qBAAa,sBAAuB,YAAW,iBAAiB;IAGlD,OAAO,CAAC,OAAO;IAF3B,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;gBAEZ,OAAO,EAAE,sBAAsB;IAEnD;;;;OAIG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAcjF;;;OAGG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqCvF;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkDzF;;OAEG;IACG,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3E;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGjE"}