@renseiai/agentfactory 0.8.18 → 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.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Decision Engine Adapter
+ *
+ * Translates the full `decideAction()` decision context into a
+ * WorkflowDefinition v2 YAML equivalent. Each decision point in the
+ * engine becomes a condition node or action node in the v2 graph.
+ *
+ * This adapter enables the platform to replace the legacy decision engine
+ * with a declarative workflow while preserving identical behavior.
+ *
+ * @see SUP-1757
+ */
+import type { GovernorConfig } from './governor-types.js';
+import type { WorkflowDefinitionV2 } from '../workflow/workflow-types.js';
+export interface DecisionEngineAdapterConfig {
+    /** Governor configuration to derive workflow from */
+    governorConfig?: GovernorConfig;
+    /** Workflow name (default: "governor-decision-engine") */
+    workflowName?: string;
+    /** Whether to include top-of-funnel nodes (Icebox handling) */
+    includeTopOfFunnel?: boolean;
+    /** Whether to include merge queue handling */
+    includeMergeQueue?: boolean;
+}
+/**
+ * Converts the Governor's `decideAction()` logic into a WorkflowDefinition v2.
+ *
+ * The generated workflow mirrors the decision tree exactly:
+ *
+ * 1. Universal guards: active-session, cooldown, hold, gates, circuit-breaker
+ * 2. Terminal statuses: Accepted, Canceled, Duplicate
+ * 3. Sub-issue guard
+ * 4. Status-specific routing: Icebox, Backlog, Started, Finished, Delivered, Rejected
+ * 5. Escalation strategy overrides (decompose, escalate-human)
+ * 6. Merge queue handling
+ */
+export declare class DecisionEngineAdapter {
+    /**
+     * Generate a WorkflowDefinition v2 that replicates the full decision engine.
+     */
+    static toWorkflowDefinition(config?: DecisionEngineAdapterConfig): WorkflowDefinitionV2;
+}
+//# sourceMappingURL=decision-engine-adapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decision-engine-adapter.d.ts","sourceRoot":"","sources":["../../../src/governor/decision-engine-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEzD,OAAO,KAAK,EACV,oBAAoB,EAKrB,MAAM,+BAA+B,CAAA;AAOtC,MAAM,WAAW,2BAA2B;IAC1C,qDAAqD;IACrD,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,+DAA+D;IAC/D,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,8CAA8C;IAC9C,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAMD;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAChC;;OAEG;IACH,MAAM,CAAC,oBAAoB,CACzB,MAAM,GAAE,2BAAgC,GACvC,oBAAoB;CAgCxB"}

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

@@ -0,0 +1,417 @@
+/**
+ * Decision Engine Adapter
+ *
+ * Translates the full `decideAction()` decision context into a
+ * WorkflowDefinition v2 YAML equivalent. Each decision point in the
+ * engine becomes a condition node or action node in the v2 graph.
+ *
+ * This adapter enables the platform to replace the legacy decision engine
+ * with a declarative workflow while preserving identical behavior.
+ *
+ * @see SUP-1757
+ */
+import { DEFAULT_GOVERNOR_CONFIG } from './governor-types.js';
+import { MAX_SESSION_ATTEMPTS } from './decision-engine.js';
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+/**
+ * Converts the Governor's `decideAction()` logic into a WorkflowDefinition v2.
+ *
+ * The generated workflow mirrors the decision tree exactly:
+ *
+ * 1. Universal guards: active-session, cooldown, hold, gates, circuit-breaker
+ * 2. Terminal statuses: Accepted, Canceled, Duplicate
+ * 3. Sub-issue guard
+ * 4. Status-specific routing: Icebox, Backlog, Started, Finished, Delivered, Rejected
+ * 5. Escalation strategy overrides (decompose, escalate-human)
+ * 6. Merge queue handling
+ */
+export class DecisionEngineAdapter {
+    /**
+     * Generate a WorkflowDefinition v2 that replicates the full decision engine.
+     */
+    static toWorkflowDefinition(config = {}) {
+        const govConfig = config.governorConfig ?? DEFAULT_GOVERNOR_CONFIG;
+        const workflowName = config.workflowName ?? 'governor-decision-engine';
+        const includeTopOfFunnel = config.includeTopOfFunnel ?? true;
+        const includeMergeQueue = config.includeMergeQueue ?? false;
+        const triggers = buildTriggers();
+        const providers = buildProviders();
+        const nodes = buildNodes(govConfig, includeTopOfFunnel, includeMergeQueue);
+        return {
+            apiVersion: 'v2',
+            kind: 'WorkflowDefinition',
+            metadata: {
+                name: workflowName,
+                description: 'Auto-generated from Governor DecisionEngine. ' +
+                    'Replicates the full decideAction() decision tree as v2 workflow nodes.',
+            },
+            triggers,
+            providers,
+            config: {
+                maxSessionAttempts: MAX_SESSION_ATTEMPTS,
+                enableAutoDevelopment: govConfig.enableAutoDevelopment,
+                enableAutoQA: govConfig.enableAutoQA,
+                enableAutoAcceptance: govConfig.enableAutoAcceptance,
+                enableAutoResearch: govConfig.enableAutoResearch,
+                enableAutoBacklogCreation: govConfig.enableAutoBacklogCreation,
+            },
+            nodes,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Trigger builders
+// ---------------------------------------------------------------------------
+function buildTriggers() {
+    return [
+        {
+            name: 'issue-status-change',
+            type: 'webhook',
+            source: 'linear',
+            event: 'issue.status_changed',
+        },
+        {
+            name: 'governor-scan',
+            type: 'schedule',
+            schedule: '*/1 * * * *', // Every minute
+        },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Provider builders
+// ---------------------------------------------------------------------------
+function buildProviders() {
+    return [
+        { name: 'linear', type: 'linear' },
+        { name: 'agent', type: 'agent-provider' },
+    ];
+}
+// ---------------------------------------------------------------------------
+// Node builders
+// ---------------------------------------------------------------------------
+function buildNodes(config, includeTopOfFunnel, includeMergeQueue) {
+    const nodes = [];
+    // --- Universal guard nodes ---
+    nodes.push(buildActiveSessionGuard());
+    nodes.push(buildCooldownGuard());
+    nodes.push(buildHoldGuard());
+    nodes.push(buildGateGuard());
+    nodes.push(buildCircuitBreakerGuard());
+    nodes.push(buildTerminalStatusGuard());
+    nodes.push(buildSubIssueGuard());
+    // --- Status-specific routing nodes ---
+    if (includeTopOfFunnel) {
+        nodes.push(buildIceboxResearchNode(config));
+        nodes.push(buildIceboxBacklogCreationNode(config));
+    }
+    nodes.push(buildBacklogNode(config));
+    nodes.push(buildStartedNode());
+    nodes.push(buildFinishedNode(config, includeMergeQueue));
+    nodes.push(buildDeliveredNode(config));
+    nodes.push(buildRejectedNode());
+    return nodes;
+}
+// ---------------------------------------------------------------------------
+// Guard nodes
+// ---------------------------------------------------------------------------
+function buildActiveSessionGuard() {
+    return {
+        name: 'guard-active-session',
+        description: 'Skip if issue already has an active agent session',
+        when: '{{ hasActiveSession }}',
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} already has an active agent session',
+                },
+            },
+        ],
+    };
+}
+function buildCooldownGuard() {
+    return {
+        name: 'guard-cooldown',
+        description: 'Skip if issue is within cooldown period',
+        when: '{{ isWithinCooldown }}',
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is within cooldown period',
+                },
+            },
+        ],
+    };
+}
+function buildHoldGuard() {
+    return {
+        name: 'guard-hold',
+        description: 'Skip if HOLD override is active',
+        when: '{{ isHeld }}',
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is held (HOLD override active)',
+                },
+            },
+        ],
+    };
+}
+function buildGateGuard() {
+    return {
+        name: 'guard-gates',
+        description: 'Block when gates are unsatisfied (Phase 4 gate evaluation)',
+        when: '{{ gateEvaluation && !gateEvaluation.allSatisfied }}',
+        steps: [
+            {
+                id: 'block',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} has unsatisfied gates',
+                },
+            },
+        ],
+    };
+}
+function buildCircuitBreakerGuard() {
+    return {
+        name: 'guard-circuit-breaker',
+        description: `Trip circuit breaker when session count >= ${MAX_SESSION_ATTEMPTS}`,
+        when: `{{ completedSessionCount >= ${MAX_SESSION_ATTEMPTS} }}`,
+        steps: [
+            {
+                id: 'trip',
+                action: 'none',
+                with: {
+                    reason: `Issue {{ issue.identifier }} has had {{ completedSessionCount }} agent sessions — circuit breaker tripped (max ${MAX_SESSION_ATTEMPTS})`,
+                },
+            },
+        ],
+    };
+}
+function buildTerminalStatusGuard() {
+    return {
+        name: 'guard-terminal-status',
+        description: 'No action for terminal statuses (Accepted, Canceled, Duplicate)',
+        when: "{{ issue.status == 'Accepted' || issue.status == 'Canceled' || issue.status == 'Duplicate' }}",
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is in terminal status: {{ issue.status }}',
+                },
+            },
+        ],
+    };
+}
+function buildSubIssueGuard() {
+    return {
+        name: 'guard-sub-issue',
+        description: 'Sub-issues managed by coordinator via parent — skip direct dispatch',
+        when: '{{ issue.parentId != undefined }}',
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Sub-issue {{ issue.identifier }} skipped — coordinator manages sub-issues via parent',
+                },
+            },
+        ],
+    };
+}
+// ---------------------------------------------------------------------------
+// Status-specific routing nodes
+// ---------------------------------------------------------------------------
+function buildIceboxResearchNode(config) {
+    return {
+        name: 'icebox-research',
+        description: 'Trigger research for sparse Icebox issues (top-of-funnel)',
+        provider: 'agent',
+        when: `{{ issue.status == 'Icebox' && config.enableAutoResearch && !researchCompleted && !isParentIssue }}`,
+        steps: [
+            {
+                id: 'evaluate',
+                action: 'trigger-research',
+                with: {
+                    enableAutoResearch: config.enableAutoResearch,
+                },
+            },
+        ],
+    };
+}
+function buildIceboxBacklogCreationNode(config) {
+    return {
+        name: 'icebox-backlog-creation',
+        description: 'Trigger backlog creation for well-researched Icebox issues',
+        provider: 'agent',
+        when: `{{ issue.status == 'Icebox' && config.enableAutoBacklogCreation && !backlogCreationCompleted && !isParentIssue }}`,
+        steps: [
+            {
+                id: 'evaluate',
+                action: 'trigger-backlog-creation',
+                with: {
+                    enableAutoBacklogCreation: config.enableAutoBacklogCreation,
+                },
+            },
+        ],
+    };
+}
+function buildBacklogNode(config) {
+    return {
+        name: 'route-backlog',
+        description: 'Backlog → trigger-development (if enabled)',
+        provider: 'agent',
+        when: "{{ issue.status == 'Backlog' }}",
+        steps: [
+            {
+                id: 'check-enabled',
+                action: 'none',
+                when: `{{ !config.enableAutoDevelopment }}`,
+                with: {
+                    reason: 'Auto-development is disabled for {{ issue.identifier }}',
+                },
+            },
+            {
+                id: 'dispatch',
+                action: 'trigger-development',
+                when: `{{ config.enableAutoDevelopment }}`,
+                with: {
+                    isParentIssue: '{{ isParentIssue }}',
+                    reason: '{{ isParentIssue ? "Parent issue" : "Issue" }} {{ issue.identifier }} is in Backlog — triggering {{ isParentIssue ? "coordination " : "" }}development',
+                },
+            },
+        ],
+    };
+}
+function buildStartedNode() {
+    return {
+        name: 'route-started',
+        description: 'Started → none (agent already working)',
+        when: "{{ issue.status == 'Started' }}",
+        steps: [
+            {
+                id: 'skip',
+                action: 'none',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is in Started status (agent already working)',
+                },
+            },
+        ],
+    };
+}
+function buildFinishedNode(config, includeMergeQueue) {
+    const steps = [
+        {
+            id: 'check-enabled',
+            action: 'none',
+            when: '{{ !config.enableAutoQA }}',
+            with: {
+                reason: 'Auto-QA is disabled for {{ issue.identifier }}',
+            },
+        },
+        {
+            id: 'check-escalate-human',
+            action: 'escalate-human',
+            when: "{{ workflowStrategy == 'escalate-human' }}",
+            with: {
+                reason: 'Issue {{ issue.identifier }} is in Finished with escalate-human strategy — needs human review',
+            },
+        },
+        {
+            id: 'check-decompose',
+            action: 'decompose',
+            when: "{{ workflowStrategy == 'decompose' }}",
+            with: {
+                reason: 'Issue {{ issue.identifier }} is in Finished with decompose strategy — triggering decomposition',
+            },
+        },
+    ];
+    // 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',
+        when: '{{ config.enableAutoQA }}',
+        with: {
+            reason: 'Issue {{ issue.identifier }} is in Finished — triggering QA',
+        },
+    });
+    return {
+        name: 'route-finished',
+        description: 'Finished → trigger-qa (with escalation/merge-queue checks)',
+        provider: 'agent',
+        when: "{{ issue.status == 'Finished' }}",
+        steps,
+    };
+}
+function buildDeliveredNode(config) {
+    return {
+        name: 'route-delivered',
+        description: 'Delivered → trigger-acceptance (if enabled)',
+        provider: 'agent',
+        when: "{{ issue.status == 'Delivered' }}",
+        steps: [
+            {
+                id: 'check-enabled',
+                action: 'none',
+                when: '{{ !config.enableAutoAcceptance }}',
+                with: {
+                    reason: 'Auto-acceptance is disabled for {{ issue.identifier }}',
+                },
+            },
+            {
+                id: 'dispatch',
+                action: 'trigger-acceptance',
+                when: '{{ config.enableAutoAcceptance }}',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is in Delivered — triggering acceptance',
+                },
+            },
+        ],
+    };
+}
+function buildRejectedNode() {
+    return {
+        name: 'route-rejected',
+        description: 'Rejected → trigger-refinement (with escalation checks)',
+        provider: 'agent',
+        when: "{{ issue.status == 'Rejected' }}",
+        steps: [
+            {
+                id: 'check-escalate-human',
+                action: 'escalate-human',
+                when: "{{ workflowStrategy == 'escalate-human' }}",
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is Rejected with escalate-human strategy — needs human intervention',
+                },
+            },
+            {
+                id: 'check-decompose',
+                action: 'decompose',
+                when: "{{ workflowStrategy == 'decompose' }}",
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is Rejected with decompose strategy — triggering decomposition',
+                },
+            },
+            {
+                id: 'dispatch-refinement',
+                action: 'trigger-refinement',
+                with: {
+                    reason: 'Issue {{ issue.identifier }} is Rejected — triggering refinement',
+                },
+            },
+        ],
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"decision-engine-adapter.test.d.ts","sourceRoot":"","sources":["../../../src/governor/decision-engine-adapter.test.ts"],"names":[],"mappings":""}