@renseiai/agentfactory 0.8.19 → 0.8.20

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

@@ -121,6 +121,7 @@ export declare const RepositoryConfigSchema: z.ZodObject<{
     mergeQueue: z.ZodOptional<z.ZodObject<{
         provider: z.ZodDefault<z.ZodEnum<{
             "github-native": "github-native";
+            local: "local";
             mergify: "mergify";
             trunk: "trunk";
         }>>;
@@ -159,6 +160,12 @@ export declare const RepositoryConfigSchema: z.ZodObject<{
         default: "default";
         mergiraf: "mergiraf";
     }>>;
+    quality: z.ZodOptional<z.ZodObject<{
+        baselineEnabled: z.ZodDefault<z.ZodBoolean>;
+        ratchetEnabled: z.ZodDefault<z.ZodBoolean>;
+        boyscoutRule: z.ZodDefault<z.ZodBoolean>;
+        tddWorkflow: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type RepositoryConfig = z.infer<typeof RepositoryConfigSchema>;
 /**

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4HlC,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

@@ -116,7 +116,7 @@ export const RepositoryConfigSchema = z.object({
      */
     mergeQueue: z.object({
         /** Merge queue provider to use */
-        provider: z.enum(['github-native', 'mergify', 'trunk']).default('github-native'),
+        provider: z.enum(['github-native', 'local', 'mergify', 'trunk']).default('local'),
         /** Whether merge queue integration is enabled */
         enabled: z.boolean().default(false),
         /** Automatically add approved PRs to merge queue */
@@ -164,6 +164,20 @@ export const RepositoryConfigSchema = z.object({
      * Defaults to 'default' (standard git line-based merge).
      */
     mergeDriver: z.enum(['mergiraf', 'default']).optional(),
+    /**
+     * Quality gate configuration.
+     * Controls baseline-diff quality checks and ratchet enforcement.
+     */
+    quality: z.object({
+        /** Enable quality baseline capture at worktree creation and post-session delta check */
+        baselineEnabled: z.boolean().default(false),
+        /** Enable quality ratchet enforcement in merge queue and CI */
+        ratchetEnabled: z.boolean().default(false),
+        /** Include boy scout rule instructions in agent prompts */
+        boyscoutRule: z.boolean().default(true),
+        /** Include TDD workflow instructions in agent prompts */
+        tddWorkflow: z.boolean().default(true),
+    }).optional(),
 }).refine((data) => !(data.allowedProjects && data.projectPaths), { message: 'allowedProjects and projectPaths are mutually exclusive — use one or the other' });
 // ---------------------------------------------------------------------------
 // Helpers

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

@@ -695,7 +695,7 @@ describe('RepositoryConfigSchema mergeQueue — Refinery fields', () => {
             mergeQueue: { enabled: true },
         });
         expect(result.mergeQueue).toBeDefined();
-        expect(result.mergeQueue.provider).toBe('github-native');
+        expect(result.mergeQueue.provider).toBe('local');
         expect(result.mergeQueue.enabled).toBe(true);
         expect(result.mergeQueue.autoMerge).toBe(true);
         expect(result.mergeQueue.requiredChecks).toBeUndefined();

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

@@ -335,16 +335,11 @@ function buildFinishedNode(config, includeMergeQueue) {
             },
         },
     ];
-    if (includeMergeQueue) {
-        steps.push({
-            id: 'check-merge-queue',
-            action: 'trigger-merge',
-            when: '{{ mergeQueueEnabled }}',
-            with: {
-                reason: 'Issue {{ issue.identifier }} is in Finished — enqueuing to merge queue',
-            },
-        });
-    }
+    // Always trigger QA for functional validation — merge queue handles git
+    // mechanics at merge time, not as a QA bypass.
+    // The includeMergeQueue flag is preserved for the adapter signature but the
+    // Finished node no longer short-circuits to trigger-merge.
+    void includeMergeQueue;
     steps.push({
         id: 'dispatch-qa',
         action: 'trigger-qa',

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

@@ -149,21 +149,19 @@ describe('DecisionEngineAdapter', () => {
             expect(actions).toContain('escalate-human');
             expect(actions).toContain('decompose');
         });
-        it('includes merge queue step in Finished when enabled', () => {
-            const workflow = DecisionEngineAdapter.toWorkflowDefinition({
+        it('never includes merge queue step in Finished (merge queue does not bypass QA)', () => {
+            const workflowEnabled = DecisionEngineAdapter.toWorkflowDefinition({
                 includeMergeQueue: true,
             });
-            const node = findNode(workflow, 'route-finished');
-            const actions = node?.steps?.map(s => s.action);
-            expect(actions).toContain('trigger-merge');
-        });
-        it('excludes merge queue step in Finished when disabled', () => {
-            const workflow = DecisionEngineAdapter.toWorkflowDefinition({
+            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 node = findNode(workflow, 'route-finished');
-            const actions = node?.steps?.map(s => s.action);
-            expect(actions).not.toContain('trigger-merge');
+            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();
@@ -294,16 +292,17 @@ describe('DecisionEngineAdapter', () => {
             const decomposeStep = node?.steps?.find(s => s.action === 'decompose');
             expect(decomposeStep).toBeDefined();
         });
-        it('covers Finished + merge queue → trigger-merge', () => {
+        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-merge');
+            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).toBeDefined();
+            expect(mergeStep).toBeUndefined();
         });
         it('covers Delivered → trigger-acceptance', () => {
             const ctx = makeContext({ issue: makeIssue({ status: 'Delivered' }) });

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/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/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"}

package/dist/src/merge-queue/adapters/local.js

@@ -0,0 +1,136 @@
+/**
+ * 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 { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/** Timeout for gh CLI calls */
+const GH_CLI_TIMEOUT = 15_000;
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+export class LocalMergeQueueAdapter {
+    storage;
+    name = 'local';
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * 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.
+     */
+    async canEnqueue(owner, repo, prNumber) {
+        try {
+            const { stdout } = await execAsync(`gh pr view ${prNumber} --repo ${owner}/${repo} --json state,headRefName`, { timeout: GH_CLI_TIMEOUT });
+            const pr = JSON.parse(stdout);
+            // PR must be open
+            return pr.state === 'OPEN';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Add a PR to the local merge queue.
+     * The merge worker will pick it up and process it (rebase, test, merge).
+     */
+    async enqueue(owner, repo, prNumber) {
+        const repoId = `${owner}/${repo}`;
+        // Check if already enqueued
+        const alreadyQueued = await this.storage.isEnqueued(repoId, prNumber);
+        if (alreadyQueued) {
+            return this.getStatus(owner, repo, prNumber);
+        }
+        // Fetch PR details for the queue entry
+        let sourceBranch = `pr-${prNumber}`;
+        let prUrl = `https://github.com/${owner}/${repo}/pull/${prNumber}`;
+        try {
+            const { stdout } = await execAsync(`gh pr view ${prNumber} --repo ${owner}/${repo} --json headRefName,url`, { timeout: GH_CLI_TIMEOUT });
+            const pr = JSON.parse(stdout);
+            sourceBranch = pr.headRefName ?? sourceBranch;
+            prUrl = pr.url ?? prUrl;
+        }
+        catch {
+            // Fall back to defaults
+        }
+        await this.storage.enqueue({
+            repoId,
+            prNumber,
+            prUrl,
+            issueIdentifier: `PR-${prNumber}`,
+            priority: 3, // Default priority; orchestrator can override
+            sourceBranch,
+            targetBranch: 'main',
+        });
+        return this.getStatus(owner, repo, prNumber);
+    }
+    /**
+     * Get the status of a PR in the local merge queue.
+     */
+    async getStatus(owner, repo, prNumber) {
+        const repoId = `${owner}/${repo}`;
+        // Check if in queue
+        const position = await this.storage.getPosition(repoId, prNumber);
+        if (position !== null) {
+            return {
+                state: position === 1 ? 'merging' : 'queued',
+                position,
+                checksStatus: [],
+            };
+        }
+        // Check if failed
+        const failedReason = await this.storage.getFailedReason(repoId, prNumber);
+        if (failedReason) {
+            return {
+                state: 'failed',
+                failureReason: failedReason,
+                checksStatus: [],
+            };
+        }
+        // Check if blocked (conflict)
+        const blockedReason = await this.storage.getBlockedReason(repoId, prNumber);
+        if (blockedReason) {
+            return {
+                state: 'blocked',
+                failureReason: blockedReason,
+                checksStatus: [],
+            };
+        }
+        // Check if PR was already merged
+        try {
+            const { stdout } = await execAsync(`gh pr view ${prNumber} --repo ${owner}/${repo} --json state`, { timeout: GH_CLI_TIMEOUT });
+            const pr = JSON.parse(stdout);
+            if (pr.state === 'MERGED') {
+                return { state: 'merged', checksStatus: [] };
+            }
+        }
+        catch {
+            // Fall through to not-queued
+        }
+        return { state: 'not-queued', checksStatus: [] };
+    }
+    /**
+     * Remove a PR from the local merge queue.
+     */
+    async dequeue(owner, repo, prNumber) {
+        const repoId = `${owner}/${repo}`;
+        await this.storage.remove(repoId, prNumber);
+    }
+    /**
+     * Local merge queue is always available (no external service dependency).
+     */
+    async isEnabled(_owner, _repo) {
+        return true;
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"local.test.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/adapters/local.test.ts"],"names":[],"mappings":""}

package/dist/src/merge-queue/adapters/local.test.js

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { LocalMergeQueueAdapter } from './local.js';
+// Mock child_process.exec
+vi.mock('child_process', () => ({
+    exec: vi.fn(),
+}));
+import { exec } from 'child_process';
+function mockExec(stdout) {
+    ;
+    exec.mockImplementation((_cmd, _opts, cb) => {
+        // promisify wraps exec — the 2-arg form is (cmd, opts) returning Promise
+        // but we also need to handle the 3-arg callback form
+        if (typeof _opts === 'function') {
+            cb = _opts;
+            _opts = undefined;
+        }
+        if (cb) {
+            cb(null, { stdout, stderr: '' });
+            return;
+        }
+        return { stdout, stderr: '' };
+    });
+}
+function mockExecReject(error) {
+    ;
+    exec.mockImplementation((_cmd, _opts, cb) => {
+        if (typeof _opts === 'function') {
+            cb = _opts;
+        }
+        if (cb) {
+            cb(error, null);
+            return;
+        }
+        throw error;
+    });
+}
+function createMockStorage(overrides = {}) {
+    return {
+        enqueue: vi.fn().mockResolvedValue(undefined),
+        dequeue: vi.fn().mockResolvedValue(null),
+        getQueueDepth: vi.fn().mockResolvedValue(0),
+        isEnqueued: vi.fn().mockResolvedValue(false),
+        getPosition: vi.fn().mockResolvedValue(null),
+        remove: vi.fn().mockResolvedValue(undefined),
+        getFailedReason: vi.fn().mockResolvedValue(null),
+        getBlockedReason: vi.fn().mockResolvedValue(null),
+        ...overrides,
+    };
+}
+describe('LocalMergeQueueAdapter', () => {
+    let storage;
+    let adapter;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        storage = createMockStorage();
+        adapter = new LocalMergeQueueAdapter(storage);
+    });
+    it('has name "local"', () => {
+        expect(adapter.name).toBe('local');
+    });
+    describe('isEnabled', () => {
+        it('always returns true', async () => {
+            expect(await adapter.isEnabled('owner', 'repo')).toBe(true);
+        });
+    });
+    describe('canEnqueue', () => {
+        it('returns true for open PR', async () => {
+            mockExec(JSON.stringify({ state: 'OPEN', headRefName: 'feat/test' }));
+            expect(await adapter.canEnqueue('owner', 'repo', 42)).toBe(true);
+        });
+        it('returns false for merged PR', async () => {
+            mockExec(JSON.stringify({ state: 'MERGED', headRefName: 'feat/test' }));
+            expect(await adapter.canEnqueue('owner', 'repo', 42)).toBe(false);
+        });
+        it('returns false for closed PR', async () => {
+            mockExec(JSON.stringify({ state: 'CLOSED', headRefName: 'feat/test' }));
+            expect(await adapter.canEnqueue('owner', 'repo', 42)).toBe(false);
+        });
+        it('returns false on gh CLI error', async () => {
+            mockExecReject(new Error('gh: not found'));
+            expect(await adapter.canEnqueue('owner', 'repo', 42)).toBe(false);
+        });
+    });
+    describe('enqueue', () => {
+        it('adds PR to storage and returns queued status', async () => {
+            mockExec(JSON.stringify({ headRefName: 'feat/my-branch', url: 'https://github.com/o/r/pull/10' }));
+            storage.isEnqueued.mockResolvedValue(false);
+            storage.getPosition.mockResolvedValue(1);
+            const status = await adapter.enqueue('owner', 'repo', 10);
+            expect(storage.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+                repoId: 'owner/repo',
+                prNumber: 10,
+                sourceBranch: 'feat/my-branch',
+                targetBranch: 'main',
+                priority: 3,
+            }));
+            expect(status.state).toBe('merging'); // position 1 = merging
+        });
+        it('returns existing status if already enqueued', async () => {
+            ;
+            storage.isEnqueued.mockResolvedValue(true);
+            storage.getPosition.mockResolvedValue(3);
+            const status = await adapter.enqueue('owner', 'repo', 10);
+            expect(storage.enqueue).not.toHaveBeenCalled();
+            expect(status.state).toBe('queued');
+            expect(status.position).toBe(3);
+        });
+        it('falls back to default branch name on gh CLI error', async () => {
+            mockExecReject(new Error('gh: not found'));
+            storage.isEnqueued.mockResolvedValue(false);
+            storage.getPosition.mockResolvedValue(2);
+            await adapter.enqueue('owner', 'repo', 5);
+            expect(storage.enqueue).toHaveBeenCalledWith(expect.objectContaining({
+                sourceBranch: 'pr-5',
+                prUrl: 'https://github.com/owner/repo/pull/5',
+            }));
+        });
+    });
+    describe('getStatus', () => {
+        it('returns queued with position when in queue', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(3);
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('queued');
+            expect(status.position).toBe(3);
+        });
+        it('returns merging when position is 1', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(1);
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('merging');
+            expect(status.position).toBe(1);
+        });
+        it('returns failed when PR has failed reason', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(null);
+            storage.getFailedReason.mockResolvedValue('Tests failed');
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('failed');
+            expect(status.failureReason).toBe('Tests failed');
+        });
+        it('returns blocked when PR has blocked reason', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(null);
+            storage.getFailedReason.mockResolvedValue(null);
+            storage.getBlockedReason.mockResolvedValue('Merge conflict in utils.ts');
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('blocked');
+            expect(status.failureReason).toBe('Merge conflict in utils.ts');
+        });
+        it('returns merged when PR is already merged', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(null);
+            storage.getFailedReason.mockResolvedValue(null);
+            storage.getBlockedReason.mockResolvedValue(null);
+            mockExec(JSON.stringify({ state: 'MERGED' }));
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('merged');
+        });
+        it('returns not-queued when PR is not in any state', async () => {
+            ;
+            storage.getPosition.mockResolvedValue(null);
+            storage.getFailedReason.mockResolvedValue(null);
+            storage.getBlockedReason.mockResolvedValue(null);
+            mockExec(JSON.stringify({ state: 'OPEN' }));
+            const status = await adapter.getStatus('owner', 'repo', 10);
+            expect(status.state).toBe('not-queued');
+        });
+    });
+    describe('dequeue', () => {
+        it('removes PR from storage', async () => {
+            await adapter.dequeue('owner', 'repo', 10);
+            expect(storage.remove).toHaveBeenCalledWith('owner/repo', 10);
+        });
+    });
+});

package/dist/src/merge-queue/index.d.ts

@@ -3,16 +3,24 @@
  *
  * Factory and exports for merge queue adapters.
  */
+import type { LocalMergeQueueStorage } from './adapters/local.js';
 export type { MergeQueueAdapter, MergeQueueStatus, MergeQueueProviderName } from './types.js';
+export type { LocalMergeQueueStorage } from './adapters/local.js';
+export { LocalMergeQueueAdapter } from './adapters/local.js';
+export { MergeWorker } from './merge-worker.js';
+export type { MergeWorkerConfig, MergeWorkerDeps, MergeProcessResult } from './merge-worker.js';
+/** Optional dependencies for adapter construction */
+export interface MergeQueueAdapterDeps {
+    /** Required for 'local' provider — Redis-backed queue storage */
+    storage?: LocalMergeQueueStorage;
+}
 /**
  * Create a merge queue adapter by provider name.
  *
- * Currently only 'github-native' is implemented.
- * 'mergify' and 'trunk' will throw until implemented.
- *
  * @param name - Provider name
+ * @param deps - Optional dependencies (storage required for 'local' provider)
  * @returns MergeQueueAdapter instance
- * @throws Error if provider is not yet implemented
+ * @throws Error if provider is not yet implemented or required deps are missing
  */
-export declare function createMergeQueueAdapter(name: import('./types.js').MergeQueueProviderName): import('./types.js').MergeQueueAdapter;
+export declare function createMergeQueueAdapter(name: import('./types.js').MergeQueueProviderName, deps?: MergeQueueAdapterDeps): import('./types.js').MergeQueueAdapter;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/merge-queue/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/merge-queue/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAE7F;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,YAAY,EAAE,sBAAsB,GAAG,OAAO,YAAY,EAAE,iBAAiB,CAiBjI"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/merge-queue/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAEjE,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAC7F,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAE/F,qDAAqD;AACrD,MAAM,WAAW,qBAAqB;IACpC,iEAAiE;IACjE,OAAO,CAAC,EAAE,sBAAsB,CAAA;CACjC;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,YAAY,EAAE,sBAAsB,EACjD,IAAI,CAAC,EAAE,qBAAqB,GAC3B,OAAO,YAAY,EAAE,iBAAiB,CAyBxC"}