@renseiai/agentfactory 0.8.12 → 0.8.14

package/dist/src/config/repository-config.d.ts

@@ -127,6 +127,30 @@ export declare const RepositoryConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         autoMerge: z.ZodDefault<z.ZodBoolean>;
         requiredChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        strategy: z.ZodDefault<z.ZodEnum<{
+            merge: "merge";
+            rebase: "rebase";
+            squash: "squash";
+        }>>;
+        testCommand: z.ZodDefault<z.ZodString>;
+        testTimeout: z.ZodDefault<z.ZodNumber>;
+        lockFileRegenerate: z.ZodDefault<z.ZodBoolean>;
+        mergiraf: z.ZodDefault<z.ZodBoolean>;
+        pollInterval: z.ZodDefault<z.ZodNumber>;
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        escalation: z.ZodOptional<z.ZodObject<{
+            onConflict: z.ZodDefault<z.ZodEnum<{
+                reassign: "reassign";
+                notify: "notify";
+                park: "park";
+            }>>;
+            onTestFailure: z.ZodDefault<z.ZodEnum<{
+                notify: "notify";
+                park: "park";
+                retry: "retry";
+            }>>;
+        }, z.core.$strip>>;
+        deleteBranchOnMerge: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     worktree: z.ZodOptional<z.ZodObject<{
         directory: z.ZodDefault<z.ZodString>;

package/dist/src/config/repository-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repository-config.d.ts","sourceRoot":"","sources":["../../../src/config/repository-config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAMxD,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAW9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAW/D,uCAAuC;AACvC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;iBAOhC,CAAA;AAEF,6DAA6D;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;iBAarC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyFlC,CAAA;AAMD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAMrE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,GAAG,SAAS,CAK1F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAepG;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKhG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAExF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa,GAAG,SAAS,CAEpF;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAQ7E"}
+{"version":3,"file":"repository-config.d.ts","sourceRoot":"","sources":["../../../src/config/repository-config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAMxD,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAW9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAW/D,uCAAuC;AACvC,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;iBAOhC,CAAA;AAEF,6DAA6D;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;iBAarC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8GlC,CAAA;AAMD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAMrE;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,EAAE,GAAG,SAAS,CAK1F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAepG;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKhG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe,GAAG,SAAS,CAExF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa,GAAG,SAAS,CAEpF;AAMD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAQ7E"}

package/dist/src/config/repository-config.js

@@ -123,6 +123,27 @@ export const RepositoryConfigSchema = z.object({
         autoMerge: z.boolean().default(true),
         /** Required CI checks that must pass before merge (provider-specific) */
         requiredChecks: z.array(z.string()).optional(),
+        /** Merge strategy: rebase, merge, or squash */
+        strategy: z.enum(['rebase', 'merge', 'squash']).default('rebase'),
+        /** Command to run after rebase (e.g., test suite) */
+        testCommand: z.string().default('pnpm test'),
+        /** Timeout for test command in milliseconds */
+        testTimeout: z.number().default(300_000),
+        /** Regenerate lock files after rebase */
+        lockFileRegenerate: z.boolean().default(true),
+        /** Use mergiraf for syntax-aware conflict resolution */
+        mergiraf: z.boolean().default(true),
+        /** Queue polling interval in milliseconds */
+        pollInterval: z.number().default(10_000),
+        /** Maximum retries for failed merges */
+        maxRetries: z.number().default(2),
+        /** Escalation policy for conflicts and test failures */
+        escalation: z.object({
+            onConflict: z.enum(['reassign', 'notify', 'park']).default('reassign'),
+            onTestFailure: z.enum(['notify', 'park', 'retry']).default('notify'),
+        }).optional(),
+        /** Delete PR branch after successful merge */
+        deleteBranchOnMerge: z.boolean().default(true),
     }).optional(),
     /**
      * Worktree configuration.

package/dist/src/config/repository-config.test.js

@@ -687,3 +687,205 @@ describe('getRoutingConfig', () => {
         expect(getRoutingConfig(config)).toBeUndefined();
     });
 });
+describe('RepositoryConfigSchema mergeQueue — Refinery fields', () => {
+    const base = { apiVersion: 'v1', kind: 'RepositoryConfig' };
+    it('applies default values when new fields are absent (backward compat)', () => {
+        const result = RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: { enabled: true },
+        });
+        expect(result.mergeQueue).toBeDefined();
+        expect(result.mergeQueue.provider).toBe('github-native');
+        expect(result.mergeQueue.enabled).toBe(true);
+        expect(result.mergeQueue.autoMerge).toBe(true);
+        expect(result.mergeQueue.requiredChecks).toBeUndefined();
+        expect(result.mergeQueue.strategy).toBe('rebase');
+        expect(result.mergeQueue.testCommand).toBe('pnpm test');
+        expect(result.mergeQueue.testTimeout).toBe(300_000);
+        expect(result.mergeQueue.lockFileRegenerate).toBe(true);
+        expect(result.mergeQueue.mergiraf).toBe(true);
+        expect(result.mergeQueue.pollInterval).toBe(10_000);
+        expect(result.mergeQueue.maxRetries).toBe(2);
+        expect(result.mergeQueue.escalation).toBeUndefined();
+        expect(result.mergeQueue.deleteBranchOnMerge).toBe(true);
+    });
+    it('accepts an empty mergeQueue object and applies all defaults', () => {
+        const result = RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: {},
+        });
+        expect(result.mergeQueue.enabled).toBe(false);
+        expect(result.mergeQueue.strategy).toBe('rebase');
+        expect(result.mergeQueue.testCommand).toBe('pnpm test');
+        expect(result.mergeQueue.testTimeout).toBe(300_000);
+        expect(result.mergeQueue.lockFileRegenerate).toBe(true);
+        expect(result.mergeQueue.mergiraf).toBe(true);
+        expect(result.mergeQueue.pollInterval).toBe(10_000);
+        expect(result.mergeQueue.maxRetries).toBe(2);
+        expect(result.mergeQueue.deleteBranchOnMerge).toBe(true);
+    });
+    it('validates strategy enum values', () => {
+        for (const strategy of ['rebase', 'merge', 'squash']) {
+            const result = RepositoryConfigSchema.parse({
+                ...base,
+                mergeQueue: { strategy },
+            });
+            expect(result.mergeQueue.strategy).toBe(strategy);
+        }
+    });
+    it('rejects invalid strategy enum value', () => {
+        expect(() => RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: { strategy: 'cherry-pick' },
+        })).toThrow();
+    });
+    it('validates escalation onConflict enum values', () => {
+        for (const onConflict of ['reassign', 'notify', 'park']) {
+            const result = RepositoryConfigSchema.parse({
+                ...base,
+                mergeQueue: { escalation: { onConflict } },
+            });
+            expect(result.mergeQueue.escalation.onConflict).toBe(onConflict);
+        }
+    });
+    it('validates escalation onTestFailure enum values', () => {
+        for (const onTestFailure of ['notify', 'park', 'retry']) {
+            const result = RepositoryConfigSchema.parse({
+                ...base,
+                mergeQueue: { escalation: { onTestFailure } },
+            });
+            expect(result.mergeQueue.escalation.onTestFailure).toBe(onTestFailure);
+        }
+    });
+    it('rejects invalid escalation onConflict value', () => {
+        expect(() => RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: { escalation: { onConflict: 'ignore' } },
+        })).toThrow();
+    });
+    it('rejects invalid escalation onTestFailure value', () => {
+        expect(() => RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: { escalation: { onTestFailure: 'ignore' } },
+        })).toThrow();
+    });
+    it('applies escalation defaults when escalation is provided as empty object', () => {
+        const result = RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: { escalation: {} },
+        });
+        expect(result.mergeQueue.escalation.onConflict).toBe('reassign');
+        expect(result.mergeQueue.escalation.onTestFailure).toBe('notify');
+    });
+    it('validates full config with all new fields', () => {
+        const result = RepositoryConfigSchema.parse({
+            ...base,
+            mergeQueue: {
+                provider: 'mergify',
+                enabled: true,
+                autoMerge: false,
+                requiredChecks: ['ci/build', 'ci/test'],
+                strategy: 'squash',
+                testCommand: 'npm run test:ci',
+                testTimeout: 600_000,
+                lockFileRegenerate: false,
+                mergiraf: false,
+                pollInterval: 30_000,
+                maxRetries: 5,
+                escalation: {
+                    onConflict: 'park',
+                    onTestFailure: 'retry',
+                },
+                deleteBranchOnMerge: false,
+            },
+        });
+        expect(result.mergeQueue.provider).toBe('mergify');
+        expect(result.mergeQueue.enabled).toBe(true);
+        expect(result.mergeQueue.autoMerge).toBe(false);
+        expect(result.mergeQueue.requiredChecks).toEqual(['ci/build', 'ci/test']);
+        expect(result.mergeQueue.strategy).toBe('squash');
+        expect(result.mergeQueue.testCommand).toBe('npm run test:ci');
+        expect(result.mergeQueue.testTimeout).toBe(600_000);
+        expect(result.mergeQueue.lockFileRegenerate).toBe(false);
+        expect(result.mergeQueue.mergiraf).toBe(false);
+        expect(result.mergeQueue.pollInterval).toBe(30_000);
+        expect(result.mergeQueue.maxRetries).toBe(5);
+        expect(result.mergeQueue.escalation).toEqual({
+            onConflict: 'park',
+            onTestFailure: 'retry',
+        });
+        expect(result.mergeQueue.deleteBranchOnMerge).toBe(false);
+    });
+    it('mergeQueue remains optional on the top-level schema', () => {
+        const result = RepositoryConfigSchema.parse(base);
+        expect(result.mergeQueue).toBeUndefined();
+    });
+});
+describe('loadRepositoryConfig with mergeQueue Refinery fields', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('parses YAML with all mergeQueue Refinery fields', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(`apiVersion: v1
+kind: RepositoryConfig
+mergeQueue:
+  provider: trunk
+  enabled: true
+  autoMerge: true
+  requiredChecks:
+    - ci/build
+  strategy: merge
+  testCommand: "yarn test"
+  testTimeout: 120000
+  lockFileRegenerate: false
+  mergiraf: false
+  pollInterval: 5000
+  maxRetries: 3
+  escalation:
+    onConflict: notify
+    onTestFailure: park
+  deleteBranchOnMerge: false
+`);
+        const result = loadRepositoryConfig('/some/repo');
+        expect(result?.mergeQueue).toBeDefined();
+        expect(result.mergeQueue.provider).toBe('trunk');
+        expect(result.mergeQueue.strategy).toBe('merge');
+        expect(result.mergeQueue.testCommand).toBe('yarn test');
+        expect(result.mergeQueue.testTimeout).toBe(120_000);
+        expect(result.mergeQueue.lockFileRegenerate).toBe(false);
+        expect(result.mergeQueue.mergiraf).toBe(false);
+        expect(result.mergeQueue.pollInterval).toBe(5_000);
+        expect(result.mergeQueue.maxRetries).toBe(3);
+        expect(result.mergeQueue.escalation).toEqual({
+            onConflict: 'notify',
+            onTestFailure: 'park',
+        });
+        expect(result.mergeQueue.deleteBranchOnMerge).toBe(false);
+    });
+    it('parses YAML with only existing mergeQueue fields — new fields get defaults', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(`apiVersion: v1
+kind: RepositoryConfig
+mergeQueue:
+  enabled: true
+  provider: github-native
+`);
+        const result = loadRepositoryConfig('/some/repo');
+        expect(result?.mergeQueue).toBeDefined();
+        expect(result.mergeQueue.enabled).toBe(true);
+        expect(result.mergeQueue.provider).toBe('github-native');
+        expect(result.mergeQueue.strategy).toBe('rebase');
+        expect(result.mergeQueue.testCommand).toBe('pnpm test');
+        expect(result.mergeQueue.testTimeout).toBe(300_000);
+        expect(result.mergeQueue.lockFileRegenerate).toBe(true);
+        expect(result.mergeQueue.mergiraf).toBe(true);
+        expect(result.mergeQueue.pollInterval).toBe(10_000);
+        expect(result.mergeQueue.maxRetries).toBe(2);
+        expect(result.mergeQueue.escalation).toBeUndefined();
+        expect(result.mergeQueue.deleteBranchOnMerge).toBe(true);
+    });
+});

package/dist/src/governor/decision-engine.d.ts

@@ -35,6 +35,8 @@ export interface DecisionContext {
     workflowRegistry?: WorkflowRegistry;
     /** Gate evaluation result from the gate system (Phase 4) */
     gateEvaluation?: GateEvaluationResult;
+    /** Whether the merge queue is enabled for this repository */
+    mergeQueueEnabled?: boolean;
 }
 /** Max agent sessions before the circuit breaker trips and the issue is held */
 export declare const MAX_SESSION_ATTEMPTS = 3;

package/dist/src/governor/decision-engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decision-engine.d.ts","sourceRoot":"","sources":["../../../src/governor/decision-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAMxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAM/E;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,cAAc,CAAA;IACtB,gBAAgB,EAAE,OAAO,CAAA;IACzB,MAAM,EAAE,OAAO,CAAA;IACf,gBAAgB,EAAE,OAAO,CAAA;IACzB,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,wBAAwB,EAAE,OAAO,CAAA;IACjC,8EAA8E;IAC9E,qBAAqB,EAAE,MAAM,CAAA;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,oBAAoB,CAAA;CACtC;AAED,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAMrC,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,cAAc,CAkHjE"}
+{"version":3,"file":"decision-engine.d.ts","sourceRoot":"","sources":["../../../src/governor/decision-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAMxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AAExE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAA;AAM/E;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,cAAc,CAAA;IACtB,gBAAgB,EAAE,OAAO,CAAA;IACzB,MAAM,EAAE,OAAO,CAAA;IACf,gBAAgB,EAAE,OAAO,CAAA;IACzB,aAAa,EAAE,OAAO,CAAA;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,wBAAwB,EAAE,OAAO,CAAA;IACjC,8EAA8E;IAC9E,qBAAqB,EAAE,MAAM,CAAA;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,oBAAoB,CAAA;IACrC,6DAA6D;IAC7D,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,IAAI,CAAA;AAMrC,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,cAAc,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;CACf;AAaD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,GAAG,cAAc,CAkHjE"}

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

@@ -244,6 +244,13 @@ 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`,
+        };
+    }
     return {
         action: 'trigger-qa',
         reason: `Issue ${issue.identifier} is in Finished — triggering QA`,

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

@@ -406,6 +406,69 @@ describe('decideAction — Finished (QA)', () => {
     });
 });
 // ---------------------------------------------------------------------------
+// Finished (merge queue)
+// ---------------------------------------------------------------------------
+describe('decideAction — Finished (merge queue)', () => {
+    it('triggers trigger-merge 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');
+    });
+    it('triggers QA when mergeQueueEnabled is false', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            mergeQueueEnabled: false,
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+        expect(result.reason).toContain('triggering QA');
+    });
+    it('triggers QA when mergeQueueEnabled is not configured (undefined)', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('trigger-qa');
+        expect(result.reason).toContain('triggering QA');
+    });
+    it('escalation strategy takes precedence over merge queue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            mergeQueueEnabled: true,
+            workflowStrategy: 'escalate-human',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('escalate-human');
+    });
+    it('decompose strategy takes precedence over merge queue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            mergeQueueEnabled: true,
+            workflowStrategy: 'decompose',
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('decompose');
+    });
+    it('auto-QA disabled takes precedence over merge queue', () => {
+        const ctx = makeContext({
+            issue: makeIssue({ status: 'Finished' }),
+            mergeQueueEnabled: true,
+            config: {
+                ...DEFAULT_GOVERNOR_CONFIG,
+                projects: ['TestProject'],
+                enableAutoQA: false,
+            },
+        });
+        const result = decideAction(ctx);
+        expect(result.action).toBe('none');
+        expect(result.reason).toContain('disabled');
+    });
+});
+// ---------------------------------------------------------------------------
 // Delivered (acceptance)
 // ---------------------------------------------------------------------------
 describe('decideAction — Delivered (acceptance)', () => {

package/dist/src/governor/governor-types.d.ts

@@ -15,12 +15,13 @@ import type { TopOfFunnelConfig } from './top-of-funnel.js';
  * - trigger-development: Dispatch a development agent (Backlog)
  * - trigger-qa: Dispatch a QA agent (Finished)
  * - trigger-acceptance: Dispatch an acceptance agent (Delivered)
+ * - trigger-merge: Dispatch a merge queue agent (Finished, merge queue enabled)
  * - trigger-refinement: Dispatch a refinement agent (Rejected)
  * - decompose: Trigger task decomposition (escalation strategy)
  * - escalate-human: Create a human escalation touchpoint
  * - none: No action needed
  */
-export type GovernorAction = 'trigger-research' | 'trigger-backlog-creation' | 'trigger-development' | 'trigger-qa' | 'trigger-acceptance' | 'trigger-refinement' | 'trigger-parallel-group' | 'decompose' | 'escalate-human' | 'none';
+export type GovernorAction = 'trigger-research' | 'trigger-backlog-creation' | 'trigger-development' | 'trigger-qa' | 'trigger-acceptance' | 'trigger-merge' | 'trigger-refinement' | 'trigger-parallel-group' | 'decompose' | 'escalate-human' | 'none';
 /**
  * Configuration for the Workflow Governor scan loop.
  */

package/dist/src/governor/governor-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"governor-types.d.ts","sourceRoot":"","sources":["../../../src/governor/governor-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAM3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,0BAA0B,GAC1B,qBAAqB,GACrB,YAAY,GACZ,oBAAoB,GACpB,oBAAoB,GACpB,wBAAwB,GACxB,WAAW,GACX,gBAAgB,GAChB,MAAM,CAAA;AAMV;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,qDAAqD;IACrD,cAAc,EAAE,MAAM,CAAA;IACtB,0DAA0D;IAC1D,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uDAAuD;IACvD,kBAAkB,EAAE,OAAO,CAAA;IAC3B,+DAA+D;IAC/D,yBAAyB,EAAE,OAAO,CAAA;IAClC,2DAA2D;IAC3D,qBAAqB,EAAE,OAAO,CAAA;IAC9B,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,oBAAoB,EAAE,OAAO,CAAA;IAC7B,gEAAgE;IAChE,sBAAsB,EAAE,MAAM,CAAA;IAC9B,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAA;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAUrC,CAAA;AAMD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,MAAM,CAAA;IACrB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAClD;AAMD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB"}
+{"version":3,"file":"governor-types.d.ts","sourceRoot":"","sources":["../../../src/governor/governor-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAM3D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,0BAA0B,GAC1B,qBAAqB,GACrB,YAAY,GACZ,oBAAoB,GACpB,eAAe,GACf,oBAAoB,GACpB,wBAAwB,GACxB,WAAW,GACX,gBAAgB,GAChB,MAAM,CAAA;AAMV;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,qDAAqD;IACrD,cAAc,EAAE,MAAM,CAAA;IACtB,0DAA0D;IAC1D,uBAAuB,EAAE,MAAM,CAAA;IAC/B,uDAAuD;IACvD,kBAAkB,EAAE,OAAO,CAAA;IAC3B,+DAA+D;IAC/D,yBAAyB,EAAE,OAAO,CAAA;IAClC,2DAA2D;IAC3D,qBAAqB,EAAE,OAAO,CAAA;IAC9B,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAA;IACrB,4DAA4D;IAC5D,oBAAoB,EAAE,OAAO,CAAA;IAC7B,gEAAgE;IAChE,sBAAsB,EAAE,MAAM,CAAA;IAC9B,4CAA4C;IAC5C,WAAW,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAA;CACzC;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAUrC,CAAA;AAMD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,MAAM,CAAA;IACrB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAClD;AAMD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB"}

package/dist/src/index.d.ts

@@ -10,4 +10,5 @@ export * from './manifest/index.js';
 export * from './tools/index.js';
 export * from './workflow/index.js';
 export * from './routing/index.js';
+export * from './registry/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"}
+{"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"}

package/dist/src/index.js

@@ -10,3 +10,4 @@ export * from './manifest/index.js';
 export * from './tools/index.js';
 export * from './workflow/index.js';
 export * from './routing/index.js';
+export * from './registry/index.js';

package/dist/src/merge-queue/conflict-resolver.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Conflict Resolver
+ *
+ * Attempts automatic conflict resolution via mergiraf merge driver,
+ * then escalates remaining conflicts using the configured strategy.
+ *
+ * Lifecycle:
+ *   1. If mergiraf is enabled, check each conflict file for remaining
+ *      conflict markers (mergiraf runs as a git merge driver during rebase).
+ *   2. Stage any files that mergiraf resolved (no conflict markers).
+ *   3. If all files resolved, run `git rebase --continue`.
+ *   4. If any files remain unresolved, escalate per the configured strategy.
+ */
+export interface ConflictContext {
+    repoPath: string;
+    worktreePath: string;
+    sourceBranch: string;
+    targetBranch: string;
+    prNumber: number;
+    issueIdentifier: string;
+    conflictFiles: string[];
+    conflictDetails?: string;
+}
+export type EscalationStrategy = 'reassign' | 'notify' | 'park';
+export interface ResolutionResult {
+    status: 'resolved' | 'escalated' | 'parked';
+    method: 'mergiraf' | 'escalation';
+    resolvedFiles?: string[];
+    unresolvedFiles?: string[];
+    escalationAction?: EscalationStrategy;
+    message?: string;
+}
+export interface ConflictResolverConfig {
+    mergirafEnabled: boolean;
+    escalationStrategy: EscalationStrategy;
+}
+export declare class ConflictResolver {
+    private config;
+    constructor(config: ConflictResolverConfig);
+    /**
+     * Resolve merge conflicts using mergiraf (if enabled), then escalate
+     * any remaining unresolved files using the configured strategy.
+     */
+    resolve(ctx: ConflictContext): Promise<ResolutionResult>;
+    /**
+     * Check each conflict file for remaining conflict markers.
+     * Mergiraf runs as a git merge driver during rebase, so by the time we
+     * inspect the files, successfully resolved ones will have no markers.
+     */
+    private attemptMergiraf;
+    /**
+     * Check whether a file contains git conflict markers.
+     * grep returns exit code 1 when no matches are found.
+     */
+    private fileHasConflictMarkers;
+    private escalate;
+    private escalateReassign;
+    private escalateNotify;
+    private escalatePark;
+    private getConflictDiff;
+}
+//# sourceMappingURL=conflict-resolver.d.ts.map

package/dist/src/merge-queue/conflict-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-resolver.d.ts","sourceRoot":"","sources":["../../../src/merge-queue/conflict-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAWH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE/D,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,QAAQ,CAAA;IAC3C,MAAM,EAAE,UAAU,GAAG,YAAY,CAAA;IACjC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,gBAAgB,CAAC,EAAE,kBAAkB,CAAA;IACrC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,eAAe,EAAE,OAAO,CAAA;IACxB,kBAAkB,EAAE,kBAAkB,CAAA;CACvC;AAMD,qBAAa,gBAAgB;IACf,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,sBAAsB;IAElD;;;OAGG;IACG,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAmB9D;;;;OAIG;YACW,eAAe;IAgD7B;;;OAGG;YACW,sBAAsB;YAiBtB,QAAQ;YAaR,gBAAgB;YAWhB,cAAc;YAUd,YAAY;YAcZ,eAAe;CAc9B"}

package/dist/src/merge-queue/conflict-resolver.js

@@ -0,0 +1,168 @@
+/**
+ * Conflict Resolver
+ *
+ * Attempts automatic conflict resolution via mergiraf merge driver,
+ * then escalates remaining conflicts using the configured strategy.
+ *
+ * Lifecycle:
+ *   1. If mergiraf is enabled, check each conflict file for remaining
+ *      conflict markers (mergiraf runs as a git merge driver during rebase).
+ *   2. Stage any files that mergiraf resolved (no conflict markers).
+ *   3. If all files resolved, run `git rebase --continue`.
+ *   4. If any files remain unresolved, escalate per the configured strategy.
+ */
+import { exec as execCb } from 'child_process';
+import { promisify } from 'util';
+const exec = promisify(execCb);
+// ---------------------------------------------------------------------------
+// ConflictResolver
+// ---------------------------------------------------------------------------
+export class ConflictResolver {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Resolve merge conflicts using mergiraf (if enabled), then escalate
+     * any remaining unresolved files using the configured strategy.
+     */
+    async resolve(ctx) {
+        // 1. If mergiraf enabled, attempt auto-resolution
+        if (this.config.mergirafEnabled) {
+            const mergirafResult = await this.attemptMergiraf(ctx);
+            if (mergirafResult.status === 'resolved') {
+                return mergirafResult;
+            }
+            // Partial resolution — update context with remaining files
+            ctx = { ...ctx, conflictFiles: mergirafResult.unresolvedFiles ?? ctx.conflictFiles };
+        }
+        // 2. Escalate remaining conflicts
+        return this.escalate(ctx);
+    }
+    // ---------------------------------------------------------------------------
+    // Mergiraf auto-resolution
+    // ---------------------------------------------------------------------------
+    /**
+     * Check each conflict file for remaining conflict markers.
+     * Mergiraf runs as a git merge driver during rebase, so by the time we
+     * inspect the files, successfully resolved ones will have no markers.
+     */
+    async attemptMergiraf(ctx) {
+        const resolvedFiles = [];
+        const unresolvedFiles = [];
+        for (const file of ctx.conflictFiles) {
+            const hasConflict = await this.fileHasConflictMarkers(ctx.worktreePath, file);
+            if (!hasConflict) {
+                // Mergiraf resolved this file — stage it
+                await exec(`git add "${file}"`, { cwd: ctx.worktreePath });
+                resolvedFiles.push(file);
+            }
+            else {
+                unresolvedFiles.push(file);
+            }
+        }
+        if (unresolvedFiles.length === 0) {
+            // All resolved — continue rebase
+            try {
+                await exec('git rebase --continue', {
+                    cwd: ctx.worktreePath,
+                    env: { ...process.env, GIT_EDITOR: 'true' },
+                });
+                return {
+                    status: 'resolved',
+                    method: 'mergiraf',
+                    resolvedFiles,
+                };
+            }
+            catch {
+                // Rebase continue failed — may need more resolution rounds
+                return {
+                    status: 'escalated',
+                    method: 'mergiraf',
+                    resolvedFiles,
+                    unresolvedFiles: ctx.conflictFiles,
+                    message: 'Mergiraf resolved conflict files but rebase --continue failed',
+                };
+            }
+        }
+        return {
+            status: 'escalated',
+            method: 'mergiraf',
+            resolvedFiles,
+            unresolvedFiles,
+            message: `Mergiraf resolved ${resolvedFiles.length}/${ctx.conflictFiles.length} files`,
+        };
+    }
+    /**
+     * Check whether a file contains git conflict markers.
+     * grep returns exit code 1 when no matches are found.
+     */
+    async fileHasConflictMarkers(worktreePath, file) {
+        try {
+            const { stdout } = await exec(`grep -c "^<<<<<<<\\|^=======\\|^>>>>>>>" "${file}"`, { cwd: worktreePath });
+            return parseInt(stdout.trim(), 10) > 0;
+        }
+        catch {
+            // grep returns exit code 1 when no matches — no conflict markers
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Escalation strategies
+    // ---------------------------------------------------------------------------
+    async escalate(ctx) {
+        switch (this.config.escalationStrategy) {
+            case 'reassign':
+                return this.escalateReassign(ctx);
+            case 'notify':
+                return this.escalateNotify(ctx);
+            case 'park':
+                return this.escalatePark(ctx);
+            default:
+                return this.escalateNotify(ctx);
+        }
+    }
+    async escalateReassign(ctx) {
+        const diffOutput = await this.getConflictDiff(ctx);
+        return {
+            status: 'escalated',
+            method: 'escalation',
+            unresolvedFiles: ctx.conflictFiles,
+            escalationAction: 'reassign',
+            message: `Conflict on ${ctx.issueIdentifier} PR #${ctx.prNumber}. Files: ${ctx.conflictFiles.join(', ')}. Agent should resolve and re-submit.\n\nDiff:\n${diffOutput}`,
+        };
+    }
+    async escalateNotify(ctx) {
+        return {
+            status: 'escalated',
+            method: 'escalation',
+            unresolvedFiles: ctx.conflictFiles,
+            escalationAction: 'notify',
+            message: `Merge conflict on ${ctx.issueIdentifier} PR #${ctx.prNumber} requires resolution. Files: ${ctx.conflictFiles.join(', ')}`,
+        };
+    }
+    async escalatePark(ctx) {
+        return {
+            status: 'parked',
+            method: 'escalation',
+            unresolvedFiles: ctx.conflictFiles,
+            escalationAction: 'park',
+            message: `PR #${ctx.prNumber} parked due to conflicts in: ${ctx.conflictFiles.join(', ')}. Will auto-retry after other merges complete.`,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    async getConflictDiff(ctx) {
+        try {
+            const { stdout } = await exec(`git diff ${ctx.conflictFiles.map(f => `"${f}"`).join(' ')}`, {
+                cwd: ctx.worktreePath,
+                maxBuffer: 1024 * 1024, // 1MB
+            });
+            return stdout.slice(0, 5000); // Truncate for readability
+        }
+        catch {
+            return '(unable to generate diff)';
+        }
+    }
+}

package/dist/src/merge-queue/conflict-resolver.test.d.ts

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