@renseiai/agentfactory 0.8.0

package/dist/src/deployment/deployment-checker.js

@@ -0,0 +1,242 @@
+/**
+ * Deployment Status Checker
+ *
+ * Queries GitHub commit status API for Vercel deployment state.
+ * Used to verify deployments before QA/acceptance work can proceed.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const DEFAULT_OPTIONS = {
+    owner: 'renseiai',
+    repo: 'agentfactory',
+    timeout: 30000,
+};
+/**
+ * Parse Vercel app name from GitHub status context
+ * Contexts look like: "Vercel – renseiai-social" or "Vercel"
+ */
+function parseAppName(context) {
+    // Extract app name after "Vercel – " or "Vercel - "
+    const match = context.match(/Vercel\s*[–-]\s*(.+)/);
+    if (match) {
+        return match[1].trim();
+    }
+    // Fallback to just "Vercel" if no app name
+    return context;
+}
+/**
+ * Check if a status description indicates a successful skip (monorepo optimization)
+ * Vercel skips deployments for unchanged apps, which is treated as success
+ */
+function isSuccessfulSkip(description) {
+    return description.toLowerCase().includes('skipped') &&
+        description.toLowerCase().includes('not affected');
+}
+/**
+ * Map GitHub status state to our normalized state
+ */
+function normalizeState(state, description) {
+    // Handle successful skips as success
+    if (isSuccessfulSkip(description)) {
+        return 'success';
+    }
+    switch (state.toLowerCase()) {
+        case 'success':
+            return 'success';
+        case 'pending':
+            return 'pending';
+        case 'failure':
+            return 'failure';
+        case 'error':
+            return 'error';
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Get the PR number for the current branch using gh CLI
+ */
+export async function getPRNumber(timeout = 30000) {
+    try {
+        const { stdout } = await execAsync('gh pr list --head "$(git branch --show-current)" --json number -q ".[0].number"', { timeout });
+        const prNumber = parseInt(stdout.trim(), 10);
+        return isNaN(prNumber) ? null : prNumber;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the head commit SHA for a PR
+ */
+export async function getPRHeadSha(prNumber, options = {}) {
+    const { owner, repo, timeout } = { ...DEFAULT_OPTIONS, ...options };
+    try {
+        const { stdout } = await execAsync(`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.head.sha'`, { timeout });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check deployment status for a specific commit SHA
+ */
+export async function checkDeploymentStatus(commitSha, options = {}) {
+    const { owner, repo, timeout } = { ...DEFAULT_OPTIONS, ...options };
+    const { stdout } = await execAsync(`gh api repos/${owner}/${repo}/commits/${commitSha}/status`, { timeout });
+    const response = JSON.parse(stdout);
+    // Extract Vercel-related statuses
+    const allStatuses = response.statuses || [];
+    // Filter to only Vercel statuses
+    const vercelStatuses = allStatuses.filter((s) => s.context.toLowerCase().includes('vercel'));
+    const deploymentStatuses = vercelStatuses.map((s) => ({
+        app: parseAppName(s.context),
+        state: normalizeState(s.state, s.description || ''),
+        description: s.description || '',
+        targetUrl: s.target_url,
+        context: s.context,
+    }));
+    // Calculate aggregate states
+    const allSucceeded = deploymentStatuses.length > 0 &&
+        deploymentStatuses.every((s) => s.state === 'success');
+    const anyFailed = deploymentStatuses.some((s) => s.state === 'failure' || s.state === 'error');
+    const anyPending = deploymentStatuses.some((s) => s.state === 'pending');
+    return {
+        allSucceeded,
+        anyFailed,
+        anyPending,
+        statuses: deploymentStatuses,
+        commitSha,
+        overallState: response.state || 'unknown',
+    };
+}
+/**
+ * Check deployment status for a PR number
+ * Convenience function that gets the commit SHA and checks status
+ */
+export async function checkPRDeploymentStatus(prNumber, options = {}) {
+    const commitSha = await getPRHeadSha(prNumber, options);
+    if (!commitSha) {
+        return null;
+    }
+    return checkDeploymentStatus(commitSha, options);
+}
+/**
+ * Format deployment check result for display
+ */
+export function formatDeploymentStatus(result) {
+    const lines = [];
+    lines.push(`## Deployment Status Check`);
+    lines.push(``);
+    lines.push(`**Commit:** \`${result.commitSha.slice(0, 7)}\``);
+    lines.push(`**Overall State:** ${result.overallState}`);
+    lines.push(``);
+    if (result.statuses.length === 0) {
+        lines.push(`No Vercel deployments found for this commit.`);
+        return lines.join('\n');
+    }
+    lines.push(`| App | State | Description |`);
+    lines.push(`|-----|-------|-------------|`);
+    for (const status of result.statuses) {
+        const stateEmoji = {
+            success: '✅',
+            pending: '⏳',
+            failure: '❌',
+            error: '❌',
+        }[status.state];
+        const url = status.targetUrl
+            ? `[${status.app}](${status.targetUrl})`
+            : status.app;
+        lines.push(`| ${url} | ${stateEmoji} ${status.state} | ${status.description} |`);
+    }
+    lines.push(``);
+    if (result.anyFailed) {
+        lines.push(`### ❌ Deployment Failed`);
+        lines.push(``);
+        lines.push(`One or more Vercel deployments failed. QA/acceptance cannot proceed until deployments succeed.`);
+    }
+    else if (result.anyPending) {
+        lines.push(`### ⏳ Deployment Pending`);
+        lines.push(``);
+        lines.push(`One or more Vercel deployments are still in progress.`);
+    }
+    else if (result.allSucceeded) {
+        lines.push(`### ✅ All Deployments Succeeded`);
+        lines.push(``);
+        lines.push(`All Vercel deployments have completed successfully.`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format failed deployments for a comment
+ */
+export function formatFailedDeployments(result) {
+    const failed = result.statuses.filter((s) => s.state === 'failure' || s.state === 'error');
+    if (failed.length === 0) {
+        return 'No failed deployments.';
+    }
+    const lines = ['**Failed Deployments:**', ''];
+    for (const status of failed) {
+        const url = status.targetUrl
+            ? ` - [View logs](${status.targetUrl})`
+            : '';
+        lines.push(`- **${status.app}**: ${status.description}${url}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Find open PRs associated with a Linear issue identifier
+ * Searches for PRs with the issue identifier in the branch name or title
+ *
+ * @param issueIdentifier - The Linear issue identifier (e.g., "SUP-123")
+ * @param options - Options for the search
+ * @returns Array of matching PRs
+ */
+export async function findPRsForIssue(issueIdentifier, options = {}) {
+    const { owner, repo, timeout } = { ...DEFAULT_OPTIONS, ...options };
+    try {
+        // Search for PRs with the issue identifier in branch name or title
+        const { stdout } = await execAsync(`gh pr list --repo ${owner}/${repo} --state open --json number,headRefName,headRefOid,title,url --search "${issueIdentifier}"`, { timeout });
+        const prs = JSON.parse(stdout || '[]');
+        // Filter to PRs that actually match the issue identifier
+        const lowerIdentifier = issueIdentifier.toLowerCase();
+        const matchingPRs = prs.filter((pr) => {
+            const branchMatch = pr.headRefName.toLowerCase().includes(lowerIdentifier);
+            const titleMatch = pr.title.toLowerCase().includes(lowerIdentifier);
+            return branchMatch || titleMatch;
+        });
+        return matchingPRs.map((pr) => ({
+            number: pr.number,
+            headSha: pr.headRefOid,
+            branch: pr.headRefName,
+            title: pr.title,
+            url: pr.url,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Check deployment status for an issue by finding associated PRs
+ * Returns the first PR's deployment status, or null if no PRs found
+ *
+ * @param issueIdentifier - The Linear issue identifier (e.g., "SUP-123")
+ * @param options - Options for the search and check
+ * @returns Deployment check result with PR info, or null if no PR found
+ */
+export async function checkIssueDeploymentStatus(issueIdentifier, options = {}) {
+    const prs = await findPRsForIssue(issueIdentifier, options);
+    if (prs.length === 0) {
+        return null;
+    }
+    // Use the first matching PR (most recent PRs are returned first by gh)
+    const pr = prs[0];
+    const result = await checkDeploymentStatus(pr.headSha, options);
+    return {
+        ...result,
+        pr,
+    };
+}

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

@@ -0,0 +1,3 @@
+export { checkDeploymentStatus, checkPRDeploymentStatus, checkIssueDeploymentStatus, findPRsForIssue, getPRNumber, getPRHeadSha, formatDeploymentStatus, formatFailedDeployments, } from './deployment-checker.js';
+export type { DeploymentStatus, DeploymentCheckResult, DeploymentCheckOptions, IssuePRInfo, } from './deployment-checker.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/deployment/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EACf,WAAW,EACX,YAAY,EACZ,sBAAsB,EACtB,uBAAuB,GACxB,MAAM,yBAAyB,CAAA;AAEhC,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,WAAW,GACZ,MAAM,yBAAyB,CAAA"}

package/dist/src/deployment/index.js

@@ -0,0 +1,2 @@
+// Deployment status checker
+export { checkDeploymentStatus, checkPRDeploymentStatus, checkIssueDeploymentStatus, findPRsForIssue, getPRNumber, getPRHeadSha, formatDeploymentStatus, formatFailedDeployments, } from './deployment-checker.js';

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

@@ -0,0 +1,2 @@
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/src/frontend/index.js

@@ -0,0 +1 @@
+export * from './types.js';

package/dist/src/frontend/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Frontend-agnostic types for work scheduling systems.
+ *
+ * These types define the contract between the orchestrator/governor
+ * and any work scheduling frontend (Linear, Asana, etc.).
+ * Each frontend provides an adapter implementing WorkSchedulingFrontend.
+ */
+/**
+ * Abstract workflow statuses that map to frontend-specific names.
+ * Each frontend adapter maps these to its native equivalents.
+ */
+export type AbstractStatus = 'icebox' | 'backlog' | 'started' | 'finished' | 'delivered' | 'accepted' | 'rejected' | 'canceled';
+/**
+ * Terminal statuses where no agent work is needed.
+ */
+export declare const TERMINAL_ABSTRACT_STATUSES: AbstractStatus[];
+/**
+ * Minimal issue representation shared across frontends.
+ */
+export interface AbstractIssue {
+    id: string;
+    identifier: string;
+    title: string;
+    description?: string;
+    url: string;
+    status: AbstractStatus;
+    priority: number;
+    labels: string[];
+    parentId?: string;
+    project?: string;
+    createdAt: Date;
+}
+/**
+ * Minimal comment representation.
+ */
+export interface AbstractComment {
+    id: string;
+    body: string;
+    userId?: string;
+    userName?: string;
+    createdAt: Date;
+}
+/**
+ * External URL for agent sessions.
+ */
+export interface ExternalUrl {
+    label: string;
+    url: string;
+}
+/**
+ * Input for creating an issue.
+ */
+export interface CreateIssueInput {
+    title: string;
+    teamId?: string;
+    description?: string;
+    projectId?: string;
+    status?: AbstractStatus;
+    labels?: string[];
+    parentId?: string;
+    priority?: number;
+}
+/**
+ * Input for creating a blocker issue.
+ */
+export interface CreateBlockerInput {
+    title: string;
+    description?: string;
+    teamId?: string;
+    projectId?: string;
+    assignee?: string;
+}
+/**
+ * Input for updating an agent session.
+ */
+export interface UpdateSessionInput {
+    externalUrls?: ExternalUrl[];
+    plan?: Array<{
+        content: string;
+        status: 'pending' | 'inProgress' | 'completed' | 'canceled';
+    }>;
+}
+/**
+ * The frontend-agnostic interface for work scheduling systems.
+ * Each frontend (Linear, Asana, etc.) provides an adapter implementing this interface.
+ */
+export interface WorkSchedulingFrontend {
+    readonly name: string;
+    resolveStatus(abstract: AbstractStatus): string;
+    abstractStatus(nativeStatus: string): AbstractStatus;
+    getIssue(id: string): Promise<AbstractIssue>;
+    listIssuesByStatus(project: string, status: AbstractStatus): Promise<AbstractIssue[]>;
+    getUnblockedIssues(project: string, status: AbstractStatus): Promise<AbstractIssue[]>;
+    getIssueComments(id: string): Promise<AbstractComment[]>;
+    isParentIssue(id: string): Promise<boolean>;
+    isChildIssue(id: string): Promise<boolean>;
+    getSubIssues(id: string): Promise<AbstractIssue[]>;
+    transitionIssue(id: string, status: AbstractStatus): Promise<void>;
+    createComment(id: string, body: string): Promise<void>;
+    createIssue(data: CreateIssueInput): Promise<AbstractIssue>;
+    createBlockerIssue(sourceId: string, data: CreateBlockerInput): Promise<AbstractIssue>;
+    createAgentSession(issueId: string, externalUrls?: ExternalUrl[]): Promise<string>;
+    updateAgentSession(sessionId: string, data: UpdateSessionInput): Promise<void>;
+    createActivity(sessionId: string, type: string, content: string): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/frontend/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/frontend/types.ts"],"names":[],"mappings":"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"}

package/dist/src/frontend/types.js

@@ -0,0 +1,11 @@
+/**
+ * Frontend-agnostic types for work scheduling systems.
+ *
+ * These types define the contract between the orchestrator/governor
+ * and any work scheduling frontend (Linear, Asana, etc.).
+ * Each frontend provides an adapter implementing WorkSchedulingFrontend.
+ */
+/**
+ * Terminal statuses where no agent work is needed.
+ */
+export const TERMINAL_ABSTRACT_STATUSES = ['accepted', 'canceled'];

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

@@ -0,0 +1,52 @@
+/**
+ * Decision Engine
+ *
+ * Pure function that determines what action the Governor should take for a
+ * given issue. No side effects, no I/O — just decision logic.
+ *
+ * The decision tree evaluates issues based on their current status, override
+ * state, active sessions, cooldowns, and configuration flags.
+ */
+import type { GovernorAction, GovernorConfig, GovernorIssue } from './governor-types.js';
+/**
+ * All external state the Governor gathers before asking the decision engine
+ * what to do. Callers are responsible for populating this context; the
+ * decision engine itself never performs I/O.
+ */
+export interface DecisionContext {
+    issue: GovernorIssue;
+    config: GovernorConfig;
+    hasActiveSession: boolean;
+    isHeld: boolean;
+    isWithinCooldown: boolean;
+    isParentIssue: boolean;
+    workflowStrategy?: string;
+    researchCompleted: boolean;
+    backlogCreationCompleted: boolean;
+    /** Number of completed agent sessions for this issue (for circuit breaker) */
+    completedSessionCount: number;
+}
+/** Max agent sessions before the circuit breaker trips and the issue is held */
+export declare const MAX_SESSION_ATTEMPTS = 3;
+export interface DecisionResult {
+    action: GovernorAction;
+    reason: string;
+}
+/**
+ * Determine what action the Governor should take for a single issue.
+ *
+ * Decision rules (evaluated in order):
+ *
+ * 1. Skip if active session exists
+ * 2. Skip if within cooldown
+ * 3. Skip if HOLD override is active
+ * 4. Terminal status (Accepted, Canceled, Duplicate) -> none
+ * 5. Icebox -> delegate to top-of-funnel (research / backlog-creation)
+ * 6. Backlog -> trigger-development (if enabled)
+ * 7. Finished -> trigger-qa (if enabled; check escalation)
+ * 8. Delivered -> trigger-acceptance (if enabled)
+ * 9. Rejected -> trigger-refinement (check strategy for escalation)
+ * 10. Unknown status -> none
+ */
+export declare function decideAction(ctx: DecisionContext): DecisionResult;
+//# sourceMappingURL=decision-engine.d.ts.map

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

@@ -0,0 +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;AAWxF;;;;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;CAC9B;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,CAsEjE"}

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

@@ -0,0 +1,220 @@
+/**
+ * Decision Engine
+ *
+ * Pure function that determines what action the Governor should take for a
+ * given issue. No side effects, no I/O — just decision logic.
+ *
+ * The decision tree evaluates issues based on their current status, override
+ * state, active sessions, cooldowns, and configuration flags.
+ */
+import { determineTopOfFunnelAction, DEFAULT_TOP_OF_FUNNEL_CONFIG, } from './top-of-funnel.js';
+/** Max agent sessions before the circuit breaker trips and the issue is held */
+export const MAX_SESSION_ATTEMPTS = 3;
+// ---------------------------------------------------------------------------
+// Terminal statuses
+// ---------------------------------------------------------------------------
+/** Statuses where no further agent work is required */
+const TERMINAL_STATUSES = new Set(['Accepted', 'Canceled', 'Duplicate']);
+// ---------------------------------------------------------------------------
+// Decision Function
+// ---------------------------------------------------------------------------
+/**
+ * Determine what action the Governor should take for a single issue.
+ *
+ * Decision rules (evaluated in order):
+ *
+ * 1. Skip if active session exists
+ * 2. Skip if within cooldown
+ * 3. Skip if HOLD override is active
+ * 4. Terminal status (Accepted, Canceled, Duplicate) -> none
+ * 5. Icebox -> delegate to top-of-funnel (research / backlog-creation)
+ * 6. Backlog -> trigger-development (if enabled)
+ * 7. Finished -> trigger-qa (if enabled; check escalation)
+ * 8. Delivered -> trigger-acceptance (if enabled)
+ * 9. Rejected -> trigger-refinement (check strategy for escalation)
+ * 10. Unknown status -> none
+ */
+export function decideAction(ctx) {
+    const { issue, config } = ctx;
+    // --- Universal skip conditions ---
+    if (ctx.hasActiveSession) {
+        return { action: 'none', reason: `Issue ${issue.identifier} already has an active agent session` };
+    }
+    if (ctx.isWithinCooldown) {
+        return { action: 'none', reason: `Issue ${issue.identifier} is within cooldown period` };
+    }
+    if (ctx.isHeld) {
+        return { action: 'none', reason: `Issue ${issue.identifier} is held (HOLD override active)` };
+    }
+    // --- Circuit breaker ---
+    // Prevent issues from cycling through agents indefinitely.
+    // If an issue has had too many sessions without reaching a terminal status,
+    // stop dispatching and require manual intervention.
+    if (ctx.completedSessionCount >= MAX_SESSION_ATTEMPTS) {
+        return {
+            action: 'none',
+            reason: `Issue ${issue.identifier} has had ${ctx.completedSessionCount} agent sessions without progressing — circuit breaker tripped (max ${MAX_SESSION_ATTEMPTS})`,
+        };
+    }
+    // --- Terminal statuses ---
+    if (TERMINAL_STATUSES.has(issue.status)) {
+        return { action: 'none', reason: `Issue ${issue.identifier} is in terminal status: ${issue.status}` };
+    }
+    // --- Sub-issue guard ---
+    // Sub-issues are managed exclusively by the coordinator (or qa-coordinator /
+    // acceptance-coordinator) via the parent issue. The governor must never
+    // dispatch workflows on sub-issues directly, regardless of their status,
+    // to prevent duplicate work.
+    if (issue.parentId !== undefined) {
+        return {
+            action: 'none',
+            reason: `Sub-issue ${issue.identifier} skipped — coordinator manages sub-issues via parent`,
+        };
+    }
+    // --- Status-specific decisions ---
+    switch (issue.status) {
+        case 'Icebox':
+            return decideIcebox(ctx);
+        case 'Backlog':
+            return decideBacklog(ctx);
+        case 'Started':
+            return { action: 'none', reason: `Issue ${issue.identifier} is in Started status (agent already working)` };
+        case 'Finished':
+            return decideFinished(ctx);
+        case 'Delivered':
+            return decideDelivered(ctx);
+        case 'Rejected':
+            return decideRejected(ctx);
+        default:
+            return { action: 'none', reason: `Issue ${issue.identifier} has unrecognized status: ${issue.status}` };
+    }
+}
+// ---------------------------------------------------------------------------
+// Per-status decision helpers
+// ---------------------------------------------------------------------------
+/**
+ * Handle Icebox issues by delegating to the top-of-funnel logic.
+ */
+function decideIcebox(ctx) {
+    const { issue, config } = ctx;
+    // Build top-of-funnel config by merging defaults with any overrides
+    const tofConfig = {
+        ...DEFAULT_TOP_OF_FUNNEL_CONFIG,
+        enableAutoResearch: config.enableAutoResearch,
+        enableAutoBacklogCreation: config.enableAutoBacklogCreation,
+        ...(config.topOfFunnel ?? {}),
+    };
+    const tofAction = determineTopOfFunnelAction({
+        id: issue.id,
+        identifier: issue.identifier,
+        title: issue.title,
+        description: issue.description,
+        status: issue.status,
+        labels: issue.labels,
+        createdAt: issue.createdAt,
+        parentId: issue.parentId,
+    }, tofConfig, {
+        hasActiveSession: ctx.hasActiveSession,
+        isHeld: ctx.isHeld,
+        researchCompleted: ctx.researchCompleted,
+        backlogCreationCompleted: ctx.backlogCreationCompleted,
+        isParentIssue: ctx.isParentIssue,
+    });
+    switch (tofAction.type) {
+        case 'trigger-research':
+            return { action: 'trigger-research', reason: tofAction.reason };
+        case 'trigger-backlog-creation':
+            return { action: 'trigger-backlog-creation', reason: tofAction.reason };
+        case 'none':
+            return { action: 'none', reason: tofAction.reason };
+    }
+}
+/**
+ * Handle Backlog issues — trigger development if enabled.
+ * Parent issues use the coordination template.
+ * Sub-issues are skipped — only top-level/parent issues are dispatched directly.
+ * The coordinator handles sub-issue lifecycle once the parent is being worked.
+ */
+function decideBacklog(ctx) {
+    const { issue, config } = ctx;
+    if (!config.enableAutoDevelopment) {
+        return { action: 'none', reason: `Auto-development is disabled for ${issue.identifier}` };
+    }
+    // Parent issues use the coordination template for sub-issue orchestration.
+    if (ctx.isParentIssue) {
+        return {
+            action: 'trigger-development',
+            reason: `Parent issue ${issue.identifier} is in Backlog — triggering coordination development`,
+        };
+    }
+    return {
+        action: 'trigger-development',
+        reason: `Issue ${issue.identifier} is in Backlog — triggering development`,
+    };
+}
+/**
+ * Handle Finished issues — trigger QA if enabled.
+ * Check workflow strategy for escalation scenarios.
+ */
+function decideFinished(ctx) {
+    const { issue, config } = ctx;
+    if (!config.enableAutoQA) {
+        return { action: 'none', reason: `Auto-QA is disabled for ${issue.identifier}` };
+    }
+    // If strategy is escalate-human, the issue needs human attention
+    if (ctx.workflowStrategy === 'escalate-human') {
+        return {
+            action: 'escalate-human',
+            reason: `Issue ${issue.identifier} is in Finished with escalate-human strategy — needs human review`,
+        };
+    }
+    // If strategy is decompose, trigger decomposition instead of QA
+    if (ctx.workflowStrategy === 'decompose') {
+        return {
+            action: 'decompose',
+            reason: `Issue ${issue.identifier} is in Finished with decompose strategy — triggering decomposition`,
+        };
+    }
+    return {
+        action: 'trigger-qa',
+        reason: `Issue ${issue.identifier} is in Finished — triggering QA`,
+    };
+}
+/**
+ * Handle Delivered issues — trigger acceptance if enabled.
+ */
+function decideDelivered(ctx) {
+    const { issue, config } = ctx;
+    if (!config.enableAutoAcceptance) {
+        return { action: 'none', reason: `Auto-acceptance is disabled for ${issue.identifier}` };
+    }
+    return {
+        action: 'trigger-acceptance',
+        reason: `Issue ${issue.identifier} is in Delivered — triggering acceptance`,
+    };
+}
+/**
+ * Handle Rejected issues — trigger refinement.
+ * Check strategy for escalation thresholds.
+ */
+function decideRejected(ctx) {
+    const { issue } = ctx;
+    // If strategy is escalate-human, the issue needs human attention
+    if (ctx.workflowStrategy === 'escalate-human') {
+        return {
+            action: 'escalate-human',
+            reason: `Issue ${issue.identifier} is Rejected with escalate-human strategy — needs human intervention`,
+        };
+    }
+    // If strategy is decompose, trigger decomposition instead of refinement
+    if (ctx.workflowStrategy === 'decompose') {
+        return {
+            action: 'decompose',
+            reason: `Issue ${issue.identifier} is Rejected with decompose strategy — triggering decomposition`,
+        };
+    }
+    return {
+        action: 'trigger-refinement',
+        reason: `Issue ${issue.identifier} is Rejected — triggering refinement`,
+    };
+}

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

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

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

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