@supaku/agentfactory-cli 0.7.9 → 0.7.11

package/dist/src/governor.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Governor CLI
+ *
+ * Thin wrapper around the governor runner.
+ *
+ * Usage:
+ *   af-governor [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --no-auto-research          Disable auto-research from Icebox
+ *   --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *
+ * Environment:
+ *   LINEAR_API_KEY              Required API key for Linear authentication
+ */
+export {};
+//# sourceMappingURL=governor.d.ts.map

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

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

package/dist/src/governor.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Governor CLI
+ *
+ * Thin wrapper around the governor runner.
+ *
+ * Usage:
+ *   af-governor [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --no-auto-research          Disable auto-research from Icebox
+ *   --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *
+ * Environment:
+ *   LINEAR_API_KEY              Required API key for Linear authentication
+ */
+import path from 'path';
+import { config } from 'dotenv';
+// Load environment variables from .env.local
+config({ path: path.resolve(process.cwd(), '.env.local') });
+import { parseGovernorArgs, runGovernor, } from './lib/governor-runner.js';
+import { createRealDependencies } from './lib/governor-dependencies.js';
+import { createLinearAgentClient } from '@supaku/agentfactory-linear';
+import { initTouchpointStorage } from '@supaku/agentfactory';
+import { RedisOverrideStorage } from '@supaku/agentfactory-server';
+// ---------------------------------------------------------------------------
+// Stub dependencies
+// ---------------------------------------------------------------------------
+/**
+ * Create placeholder dependencies for the Governor.
+ *
+ * In a production deployment, these would be backed by the Linear SDK
+ * and Redis (via packages/server). For now we provide stubs that log
+ * calls and return safe defaults. The WorkSchedulingFrontend (SUP-709
+ * Wave 3) will provide the real implementations.
+ */
+function createStubDependencies() {
+    const log = {
+        warn: (msg, data) => console.warn(`[governor-stub] ${msg}`, data ? JSON.stringify(data) : ''),
+    };
+    return {
+        listIssues: async (_project) => {
+            log.warn('listIssues stub called — no issues returned', { project: _project });
+            return [];
+        },
+        hasActiveSession: async (_issueId) => false,
+        isWithinCooldown: async (_issueId) => false,
+        isParentIssue: async (_issueId) => false,
+        isHeld: async (_issueId) => false,
+        getOverridePriority: async (_issueId) => null,
+        getWorkflowStrategy: async (_issueId) => undefined,
+        isResearchCompleted: async (_issueId) => false,
+        isBacklogCreationCompleted: async (_issueId) => false,
+        dispatchWork: async (_issueId, _action) => {
+            log.warn('dispatchWork stub called', { issueId: _issueId, action: _action });
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = parseGovernorArgs();
+    if (args.projects.length === 0) {
+        console.error('Error: at least one --project is required');
+        process.exit(1);
+    }
+    console.log('AgentFactory Governor');
+    console.log('=====================');
+    console.log(`Projects: ${args.projects.join(', ')}`);
+    console.log(`Scan interval: ${args.scanIntervalMs}ms`);
+    console.log(`Max dispatches per scan: ${args.maxConcurrentDispatches}`);
+    console.log(`Execution mode: ${args.mode}`);
+    console.log(`Mode: ${args.once ? 'single scan' : 'continuous'}`);
+    console.log('');
+    // -----------------------------------------------------------------------
+    // Choose real or stub dependencies based on environment
+    // -----------------------------------------------------------------------
+    let dependencies;
+    const linearApiKey = process.env.LINEAR_API_KEY;
+    const redisUrl = process.env.REDIS_URL;
+    if (linearApiKey) {
+        console.log('LINEAR_API_KEY detected — using real dependencies');
+        const linearClient = createLinearAgentClient({ apiKey: linearApiKey });
+        // Initialize touchpoint storage (for isHeld / getOverridePriority) when Redis is available
+        if (redisUrl) {
+            console.log('REDIS_URL detected — initializing Redis-backed touchpoint storage');
+            initTouchpointStorage(new RedisOverrideStorage());
+        }
+        else {
+            console.warn('Warning: REDIS_URL not set — touchpoint overrides (HOLD, PRIORITY) will not persist');
+        }
+        dependencies = createRealDependencies({ linearClient });
+    }
+    else {
+        console.warn('Warning: LINEAR_API_KEY not set — using stub dependencies (no real work will be dispatched)');
+        dependencies = createStubDependencies();
+    }
+    const runnerConfig = {
+        projects: args.projects,
+        scanIntervalMs: args.scanIntervalMs,
+        maxConcurrentDispatches: args.maxConcurrentDispatches,
+        enableAutoResearch: args.enableAutoResearch,
+        enableAutoBacklogCreation: args.enableAutoBacklogCreation,
+        enableAutoDevelopment: args.enableAutoDevelopment,
+        enableAutoQA: args.enableAutoQA,
+        enableAutoAcceptance: args.enableAutoAcceptance,
+        once: args.once,
+        mode: args.mode,
+        dependencies,
+        callbacks: {
+            onScanComplete: (results) => {
+                for (const result of results) {
+                    console.log(`[${result.project}] Scanned ${result.scannedIssues} issues, dispatched ${result.actionsDispatched}`);
+                    if (result.errors.length > 0) {
+                        for (const err of result.errors) {
+                            console.error(`  Error: ${err.issueId} — ${err.error}`);
+                        }
+                    }
+                }
+            },
+            onError: (error) => {
+                console.error('Governor error:', error.message);
+            },
+        },
+    };
+    try {
+        const { governor, scanResults } = await runGovernor(runnerConfig);
+        if (args.once && scanResults) {
+            // Print summary and exit
+            let totalDispatched = 0;
+            let totalErrors = 0;
+            for (const result of scanResults) {
+                totalDispatched += result.actionsDispatched;
+                totalErrors += result.errors.length;
+            }
+            console.log('');
+            console.log(`Scan complete: ${totalDispatched} actions dispatched, ${totalErrors} errors`);
+            return;
+        }
+        // Continuous mode — handle graceful shutdown
+        console.log('Governor running. Press Ctrl+C to stop.');
+        const shutdown = () => {
+            console.log('\nShutting down governor...');
+            governor.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        console.error('Governor failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;;;GAKG;AAEH,QAAA,MAAM,OAAO,QAAkB,CAAA;AAE/B,iBAAS,SAAS,IAAI,IAAI,CAqBzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;;;GAKG;AAEH,QAAA,MAAM,OAAO,QAAkB,CAAA;AAE/B,iBAAS,SAAS,IAAI,IAAI,CAsBzB"}

package/dist/src/index.js

@@ -16,6 +16,7 @@ Usage:
 
 Commands:
   orchestrator    Spawn concurrent agents on backlog issues
+  governor        Automated workflow scan loop with configurable triggers
   worker          Start a remote worker that polls for queued work
   worker-fleet    Spawn and manage multiple worker processes
   cleanup         Clean up orphaned git worktrees
@@ -33,6 +34,9 @@ switch (command) {
     case 'orchestrator':
         import('./orchestrator');
         break;
+    case 'governor':
+        import('./governor');
+        break;
     case 'worker':
         import('./worker');
         break;

package/dist/src/lib/governor-dependencies.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Real Governor Dependencies
+ *
+ * Maps each GovernorDependencies callback to its real implementation
+ * using the Linear SDK (via LinearAgentClient) and Redis storage
+ * (from @supaku/agentfactory-server).
+ */
+import type { LinearAgentClient } from '@supaku/agentfactory-linear';
+import type { GovernorDependencies } from '@supaku/agentfactory';
+export interface RealDependenciesConfig {
+    linearClient: LinearAgentClient;
+}
+/**
+ * Create real GovernorDependencies backed by the Linear SDK and Redis.
+ *
+ * Each callback wraps its implementation in a try/catch so that a single
+ * failing dependency does not crash the entire governor scan loop.
+ */
+export declare function createRealDependencies(config: RealDependenciesConfig): GovernorDependencies;
+//# sourceMappingURL=governor-dependencies.d.ts.map

package/dist/src/lib/governor-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-dependencies.d.ts","sourceRoot":"","sources":["../../../src/lib/governor-dependencies.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,sBAAsB,CAAA;AA+B7B,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,iBAAiB,CAAA;CAChC;AAmFD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,oBAAoB,CA+NtB"}

package/dist/src/lib/governor-dependencies.js

@@ -0,0 +1,306 @@
+/**
+ * Real Governor Dependencies
+ *
+ * Maps each GovernorDependencies callback to its real implementation
+ * using the Linear SDK (via LinearAgentClient) and Redis storage
+ * (from @supaku/agentfactory-server).
+ */
+import { isHeld as checkIsHeld, getOverridePriority as checkOverridePriority, } from '@supaku/agentfactory';
+import { getSessionStateByIssue, didJustFailQA, getWorkflowState, RedisProcessingStateStorage, queueWork, } from '@supaku/agentfactory-server';
+// ---------------------------------------------------------------------------
+// Logging
+// ---------------------------------------------------------------------------
+const log = {
+    info: (msg, data) => console.log(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+    warn: (msg, data) => console.warn(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+    error: (msg, data) => console.error(`[governor-deps] ${msg}`, data ? JSON.stringify(data) : ''),
+};
+// ---------------------------------------------------------------------------
+// Action-to-WorkType mapping
+// ---------------------------------------------------------------------------
+function actionToWorkType(action) {
+    switch (action) {
+        case 'trigger-research':
+            return 'research';
+        case 'trigger-backlog-creation':
+            return 'backlog-creation';
+        case 'trigger-development':
+            return 'development';
+        case 'trigger-qa':
+            return 'qa';
+        case 'trigger-acceptance':
+            return 'acceptance';
+        case 'trigger-refinement':
+            return 'refinement';
+        case 'decompose':
+            return 'coordination';
+        case 'escalate-human':
+            return 'escalation';
+        default:
+            return 'development';
+    }
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Terminal statuses (issues in these states are excluded from scans)
+// ---------------------------------------------------------------------------
+const TERMINAL_STATUSES = ['Accepted', 'Canceled', 'Duplicate'];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert a Linear SDK Issue to a GovernorIssue.
+ * Resolves lazy-loaded relations (state, labels, parent, project).
+ *
+ * Uses `unknown` + explicit casts to avoid importing `Issue` from
+ * `@linear/sdk`, keeping the CLI package dependency graph clean.
+ */
+async function sdkIssueToGovernorIssue(issue) {
+    // The Linear SDK Issue type uses LinearFetch (thenable) for lazy-loaded relations.
+    // We cast to `any` to access these properties without importing the SDK types.
+    const i = issue;
+    const state = await i.state;
+    const labels = await i.labels();
+    const parent = await i.parent;
+    const project = await i.project;
+    return {
+        id: i.id,
+        identifier: i.identifier,
+        title: i.title,
+        description: i.description ?? undefined,
+        status: state?.name ?? 'Backlog',
+        labels: labels.nodes.map((l) => l.name),
+        createdAt: i.createdAt.getTime(),
+        parentId: parent?.id,
+        project: project?.name,
+    };
+}
+/**
+ * Create real GovernorDependencies backed by the Linear SDK and Redis.
+ *
+ * Each callback wraps its implementation in a try/catch so that a single
+ * failing dependency does not crash the entire governor scan loop.
+ */
+export function createRealDependencies(config) {
+    const processingState = new RedisProcessingStateStorage();
+    return {
+        // -----------------------------------------------------------------------
+        // 1. listIssues -- scan Linear project for non-terminal issues
+        // -----------------------------------------------------------------------
+        listIssues: async (project) => {
+            try {
+                const linearClient = config.linearClient.linearClient;
+                const issueConnection = await linearClient.issues({
+                    filter: {
+                        project: { name: { eq: project } },
+                        state: { name: { nin: [...TERMINAL_STATUSES] } },
+                    },
+                });
+                const results = [];
+                for (const issue of issueConnection.nodes) {
+                    results.push(await sdkIssueToGovernorIssue(issue));
+                }
+                return results;
+            }
+            catch (err) {
+                log.error('listIssues failed', {
+                    project,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return [];
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 2. hasActiveSession -- check Redis session storage
+        // -----------------------------------------------------------------------
+        hasActiveSession: async (issueId) => {
+            try {
+                const session = await getSessionStateByIssue(issueId);
+                if (!session)
+                    return false;
+                const activeStatuses = ['running', 'claimed', 'pending'];
+                return activeStatuses.includes(session.status);
+            }
+            catch (err) {
+                log.error('hasActiveSession failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 3. isWithinCooldown -- check if QA just failed for this issue
+        // -----------------------------------------------------------------------
+        isWithinCooldown: async (issueId) => {
+            try {
+                return await didJustFailQA(issueId);
+            }
+            catch (err) {
+                log.error('isWithinCooldown failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 4. isParentIssue -- check via Linear API
+        // -----------------------------------------------------------------------
+        isParentIssue: async (issueId) => {
+            try {
+                return await config.linearClient.isParentIssue(issueId);
+            }
+            catch (err) {
+                log.error('isParentIssue failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 5. isHeld -- check touchpoint override storage
+        // -----------------------------------------------------------------------
+        isHeld: async (issueId) => {
+            try {
+                return await checkIsHeld(issueId);
+            }
+            catch (err) {
+                log.error('isHeld failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 6. getOverridePriority -- check touchpoint override storage
+        // -----------------------------------------------------------------------
+        getOverridePriority: async (issueId) => {
+            try {
+                return await checkOverridePriority(issueId);
+            }
+            catch (err) {
+                log.error('getOverridePriority failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return null;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 7. getWorkflowStrategy -- check Redis workflow state
+        // -----------------------------------------------------------------------
+        getWorkflowStrategy: async (issueId) => {
+            try {
+                const workflowState = await getWorkflowState(issueId);
+                return workflowState?.strategy;
+            }
+            catch (err) {
+                log.error('getWorkflowStrategy failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return undefined;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 8. isResearchCompleted -- check Redis processing state
+        // -----------------------------------------------------------------------
+        isResearchCompleted: async (issueId) => {
+            try {
+                return await processingState.isPhaseCompleted(issueId, 'research');
+            }
+            catch (err) {
+                log.error('isResearchCompleted failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 9. isBacklogCreationCompleted -- check Redis processing state
+        // -----------------------------------------------------------------------
+        isBacklogCreationCompleted: async (issueId) => {
+            try {
+                return await processingState.isPhaseCompleted(issueId, 'backlog-creation');
+            }
+            catch (err) {
+                log.error('isBacklogCreationCompleted failed', {
+                    issueId,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return false;
+            }
+        },
+        // -----------------------------------------------------------------------
+        // 10. dispatchWork -- create Linear session and queue work
+        // -----------------------------------------------------------------------
+        dispatchWork: async (issueId, action) => {
+            try {
+                const workType = actionToWorkType(action);
+                log.info('Dispatching work', { issueId, action, workType });
+                // Fetch the issue to get its identifier for the queue entry
+                let issueIdentifier = issueId;
+                try {
+                    const issue = await config.linearClient.getIssue(issueId);
+                    issueIdentifier = issue.identifier;
+                }
+                catch {
+                    log.warn('Could not fetch issue identifier, using issueId', { issueId });
+                }
+                // Create a Linear Agent Session on the issue so the UI shows activity
+                let sessionId;
+                try {
+                    const sessionResult = await config.linearClient.createAgentSessionOnIssue({
+                        issueId,
+                    });
+                    sessionId = sessionResult.sessionId;
+                }
+                catch (err) {
+                    log.warn('Could not create agent session, will queue without sessionId', {
+                        issueId,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                // Queue the work item for a worker to pick up
+                const queuedWork = {
+                    sessionId: sessionId ?? `governor-${issueId}-${Date.now()}`,
+                    issueId,
+                    issueIdentifier,
+                    priority: 3, // Default priority; PRIORITY overrides are handled by the governor sort
+                    queuedAt: Date.now(),
+                    workType: workType,
+                };
+                const queued = await queueWork(queuedWork);
+                if (!queued) {
+                    log.warn('Failed to queue work (Redis may not be configured)', {
+                        issueId,
+                        action,
+                    });
+                }
+                else {
+                    log.info('Work queued successfully', {
+                        issueId,
+                        issueIdentifier,
+                        action,
+                        workType,
+                        sessionId: queuedWork.sessionId,
+                    });
+                }
+            }
+            catch (err) {
+                log.error('dispatchWork failed', {
+                    issueId,
+                    action,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                throw err; // Re-throw so the governor can record the error
+            }
+        },
+    };
+}

package/dist/src/lib/governor-runner.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Governor Runner -- Programmatic API for the governor CLI.
+ *
+ * Exports `runGovernor()` so the governor can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import { WorkflowGovernor, EventDrivenGovernor, type GovernorDependencies, type GovernorEventBus, type EventDeduplicator } from '@supaku/agentfactory';
+import type { ScanResult } from '@supaku/agentfactory';
+export interface GovernorRunnerConfig {
+    /** Projects to scan */
+    projects: string[];
+    /** Scan interval in milliseconds (default: 60000) */
+    scanIntervalMs?: number;
+    /** Maximum concurrent dispatches per scan (default: 3) */
+    maxConcurrentDispatches?: number;
+    /** Enable auto-research from Icebox (default: true) */
+    enableAutoResearch?: boolean;
+    /** Enable auto-backlog-creation from Icebox (default: true) */
+    enableAutoBacklogCreation?: boolean;
+    /** Enable auto-development from Backlog (default: true) */
+    enableAutoDevelopment?: boolean;
+    /** Enable auto-QA from Finished (default: true) */
+    enableAutoQA?: boolean;
+    /** Enable auto-acceptance from Delivered (default: true) */
+    enableAutoAcceptance?: boolean;
+    /** Run a single scan pass and exit (for testing / cron) */
+    once?: boolean;
+    /** Dependency injection for the governor (required) */
+    dependencies: GovernorDependencies;
+    /** Callbacks for governor lifecycle events */
+    callbacks?: GovernorRunnerCallbacks;
+    /** Governor execution mode (default: 'poll-only') */
+    mode?: 'poll-only' | 'event-driven';
+    /** Event bus for event-driven mode (created automatically if not provided) */
+    eventBus?: GovernorEventBus;
+    /** Event deduplicator for event-driven mode (created automatically if not provided) */
+    deduplicator?: EventDeduplicator;
+}
+export interface GovernorRunnerCallbacks {
+    onScanComplete?: (results: ScanResult[]) => void;
+    onError?: (error: Error) => void;
+}
+export interface GovernorRunnerResult {
+    governor: WorkflowGovernor | EventDrivenGovernor;
+    /** Only populated in --once mode (poll-only) */
+    scanResults?: ScanResult[];
+}
+/**
+ * Start the Workflow Governor with the given configuration.
+ *
+ * In `poll-only` mode (default):
+ *   - `once` mode: runs a single scan pass and returns the results.
+ *   - Otherwise: starts the scan loop and returns the governor instance
+ *     (caller is responsible for calling `governor.stop()` on shutdown).
+ *
+ * In `event-driven` mode:
+ *   - Creates an EventDrivenGovernor with an event bus and optional deduplicator.
+ *   - Starts the event loop and periodic poll sweep.
+ *   - `once` mode is not supported in event-driven mode (falls back to poll-only).
+ */
+export declare function runGovernor(config: GovernorRunnerConfig): Promise<GovernorRunnerResult>;
+export interface GovernorCLIArgs {
+    projects: string[];
+    scanIntervalMs: number;
+    maxConcurrentDispatches: number;
+    enableAutoResearch: boolean;
+    enableAutoBacklogCreation: boolean;
+    enableAutoDevelopment: boolean;
+    enableAutoQA: boolean;
+    enableAutoAcceptance: boolean;
+    once: boolean;
+    mode: 'poll-only' | 'event-driven';
+}
+/**
+ * Parse CLI arguments for the governor command.
+ *
+ * Usage:
+ *   agentfactory governor --project <name> [--project <name>] [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --no-auto-research          Disable auto-research from Icebox
+ *   --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *   --help, -h                  Show help
+ */
+export declare function parseGovernorArgs(argv?: string[]): GovernorCLIArgs;
+/**
+ * Print help text for the governor command.
+ */
+export declare function printGovernorHelp(): void;
+//# sourceMappingURL=governor-runner.d.ts.map

package/dist/src/lib/governor-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/governor-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EAGnB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,sBAAsB,CAAA;AAM7B,MAAM,WAAW,oBAAoB;IACnC,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,0DAA0D;IAC1D,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,uDAAuD;IACvD,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,+DAA+D;IAC/D,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,2DAA2D;IAC3D,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,2DAA2D;IAC3D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,uDAAuD;IACvD,YAAY,EAAE,oBAAoB,CAAA;IAClC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,uBAAuB,CAAA;IACnC,qDAAqD;IACrD,IAAI,CAAC,EAAE,WAAW,GAAG,cAAc,CAAA;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,gBAAgB,CAAA;IAC3B,uFAAuF;IACvF,YAAY,CAAC,EAAE,iBAAiB,CAAA;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,CAAA;IAChD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,CAAA;IAChD,gDAAgD;IAChD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;CAC3B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAuD/B;AAMD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,yBAAyB,EAAE,OAAO,CAAA;IAClC,qBAAqB,EAAE,OAAO,CAAA;IAC9B,YAAY,EAAE,OAAO,CAAA;IACrB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,WAAW,GAAG,cAAc,CAAA;CACnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,eAAe,CAuDzF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CA6CxC"}

package/dist/src/lib/governor-runner.js

@@ -0,0 +1,191 @@
+/**
+ * Governor Runner -- Programmatic API for the governor CLI.
+ *
+ * Exports `runGovernor()` so the governor can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import { WorkflowGovernor, EventDrivenGovernor, InMemoryEventBus, InMemoryEventDeduplicator, } from '@supaku/agentfactory';
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+/**
+ * Start the Workflow Governor with the given configuration.
+ *
+ * In `poll-only` mode (default):
+ *   - `once` mode: runs a single scan pass and returns the results.
+ *   - Otherwise: starts the scan loop and returns the governor instance
+ *     (caller is responsible for calling `governor.stop()` on shutdown).
+ *
+ * In `event-driven` mode:
+ *   - Creates an EventDrivenGovernor with an event bus and optional deduplicator.
+ *   - Starts the event loop and periodic poll sweep.
+ *   - `once` mode is not supported in event-driven mode (falls back to poll-only).
+ */
+export async function runGovernor(config) {
+    const governorConfig = {
+        projects: config.projects,
+        scanIntervalMs: config.scanIntervalMs,
+        maxConcurrentDispatches: config.maxConcurrentDispatches,
+        enableAutoResearch: config.enableAutoResearch,
+        enableAutoBacklogCreation: config.enableAutoBacklogCreation,
+        enableAutoDevelopment: config.enableAutoDevelopment,
+        enableAutoQA: config.enableAutoQA,
+        enableAutoAcceptance: config.enableAutoAcceptance,
+    };
+    const mode = config.mode ?? 'poll-only';
+    // -- Event-driven mode --
+    if (mode === 'event-driven' && !config.once) {
+        const eventBus = config.eventBus ?? new InMemoryEventBus();
+        const deduplicator = config.deduplicator ?? new InMemoryEventDeduplicator();
+        const governor = new EventDrivenGovernor({
+            ...governorConfig,
+            // Spread required GovernorConfig defaults so TypeScript is happy
+            projects: config.projects,
+            scanIntervalMs: config.scanIntervalMs ?? 60_000,
+            maxConcurrentDispatches: config.maxConcurrentDispatches ?? 3,
+            enableAutoResearch: config.enableAutoResearch ?? true,
+            enableAutoBacklogCreation: config.enableAutoBacklogCreation ?? true,
+            enableAutoDevelopment: config.enableAutoDevelopment ?? true,
+            enableAutoQA: config.enableAutoQA ?? true,
+            enableAutoAcceptance: config.enableAutoAcceptance ?? true,
+            humanResponseTimeoutMs: 4 * 60 * 60 * 1000,
+            eventBus,
+            deduplicator,
+        }, config.dependencies);
+        await governor.start();
+        return { governor };
+    }
+    // -- Poll-only mode (default) --
+    const governor = new WorkflowGovernor(governorConfig, config.dependencies);
+    // -- Single scan mode (--once) --
+    if (config.once) {
+        const results = await governor.scanOnce();
+        config.callbacks?.onScanComplete?.(results);
+        return { governor, scanResults: results };
+    }
+    // -- Continuous scan loop --
+    governor.start();
+    return { governor };
+}
+/**
+ * Parse CLI arguments for the governor command.
+ *
+ * Usage:
+ *   agentfactory governor --project <name> [--project <name>] [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --no-auto-research          Disable auto-research from Icebox
+ *   --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *   --help, -h                  Show help
+ */
+export function parseGovernorArgs(argv = process.argv.slice(2)) {
+    const result = {
+        projects: [],
+        scanIntervalMs: 60_000,
+        maxConcurrentDispatches: 3,
+        enableAutoResearch: true,
+        enableAutoBacklogCreation: true,
+        enableAutoDevelopment: true,
+        enableAutoQA: true,
+        enableAutoAcceptance: true,
+        once: false,
+        mode: 'poll-only',
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--project':
+                result.projects.push(argv[++i]);
+                break;
+            case '--scan-interval':
+                result.scanIntervalMs = parseInt(argv[++i], 10);
+                break;
+            case '--max-dispatches':
+                result.maxConcurrentDispatches = parseInt(argv[++i], 10);
+                break;
+            case '--no-auto-research':
+                result.enableAutoResearch = false;
+                break;
+            case '--no-auto-backlog-creation':
+                result.enableAutoBacklogCreation = false;
+                break;
+            case '--no-auto-development':
+                result.enableAutoDevelopment = false;
+                break;
+            case '--no-auto-qa':
+                result.enableAutoQA = false;
+                break;
+            case '--no-auto-acceptance':
+                result.enableAutoAcceptance = false;
+                break;
+            case '--once':
+                result.once = true;
+                break;
+            case '--mode':
+                result.mode = argv[++i];
+                break;
+            case '--help':
+            case '-h':
+                printGovernorHelp();
+                process.exit(0);
+        }
+    }
+    return result;
+}
+/**
+ * Print help text for the governor command.
+ */
+export function printGovernorHelp() {
+    console.log(`
+AgentFactory Governor — Automated workflow scan loop
+
+Usage:
+  agentfactory governor [options]
+
+Options:
+  --project <name>            Project to scan (can be repeated for multiple projects)
+  --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+  --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+  --mode <mode>               Execution mode: poll-only (default) or event-driven
+  --no-auto-research          Disable auto-research from Icebox
+  --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+  --no-auto-development       Disable auto-development from Backlog
+  --no-auto-qa                Disable auto-QA from Finished
+  --no-auto-acceptance        Disable auto-acceptance from Delivered
+  --once                      Run a single scan pass and exit
+  --help, -h                  Show this help message
+
+Modes:
+  poll-only      Periodic scan loop using WorkflowGovernor (default)
+  event-driven   Hybrid event-driven + poll sweep using EventDrivenGovernor.
+                 Reacts to events in real time with a periodic safety-net poll.
+
+Environment:
+  LINEAR_API_KEY              Required API key for Linear authentication
+  REDIS_URL                   Redis connection URL (required for real dependencies)
+
+Examples:
+  # Start the governor for a project
+  agentfactory governor --project MyProject
+
+  # Scan multiple projects with custom interval
+  agentfactory governor --project ProjectA --project ProjectB --scan-interval 30000
+
+  # Run a single scan and exit (useful for cron jobs)
+  agentfactory governor --project MyProject --once
+
+  # Disable auto-QA (only scan for development work)
+  agentfactory governor --project MyProject --no-auto-qa --no-auto-acceptance
+
+  # Use event-driven mode
+  agentfactory governor --project MyProject --mode event-driven
+`);
+}

package/dist/src/lib/linear-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/linear-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAC/C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CA2CA;AAymBD,wBAAsB,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA2MvF"}
+{"version":3,"file":"linear-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/linear-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG;IAC/C,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;IACjD,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CA2CA;AAymBD,wBAAsB,SAAS,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA6MvF"}

package/dist/src/lib/linear-runner.js

@@ -4,7 +4,7 @@
  * All 15 command implementations extracted from packages/core/src/linear-cli.ts.
  * This module does NOT call process.exit, read process.argv, or load dotenv.
  */
-import { createLinearAgentClient } from '@supaku/agentfactory-linear';
+import { createLinearAgentClient, getDefaultTeamName } from '@supaku/agentfactory-linear';
 import { checkPRDeploymentStatus, formatDeploymentStatus, } from '@supaku/agentfactory';
 // ── Arg parsing ────────────────────────────────────────────────────
 /** Fields that should be split on commas to create arrays */
@@ -548,12 +548,14 @@ export async function runLinear(config) {
             break;
         }
         case 'create-issue': {
-            if (!args.title || !args.team) {
-                throw new Error('Usage: af-linear create-issue --title "Title" --team "Team" [--description "..."] [--project "..."] [--labels "Label1,Label2"] [--state "Backlog"] [--parentId "..."]');
+            const teamArg = args.team ?? (getDefaultTeamName() || undefined);
+            if (!args.title || !teamArg) {
+                throw new Error('Usage: af-linear create-issue --title "Title" --team "Team" [--description "..."] [--project "..."] [--labels "Label1,Label2"] [--state "Backlog"] [--parentId "..."]\n' +
+                    'Tip: Set LINEAR_TEAM_NAME env var to provide a default team.');
             }
             output = await createIssue(client(), {
                 title: args.title,
-                team: args.team,
+                team: teamArg,
                 description: args.description,
                 project: args.project,
                 labels: args.labels,

package/dist/src/lib/orchestrator-runner.d.ts

@@ -23,6 +23,10 @@ export interface OrchestratorRunnerConfig {
     gitRoot?: string;
     /** Callbacks for agent lifecycle events */
     callbacks?: OrchestratorCallbacks;
+    /** Custom workflow template directory path */
+    templateDir?: string;
+    /** Git repository URL for worktree cloning */
+    repository?: string;
 }
 export interface OrchestratorCallbacks {
     onIssueSelected?: (issue: OrchestratorIssue) => void;

package/dist/src/lib/orchestrator-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/orchestrator-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAA;AAM7B,MAAM,WAAW,wBAAwB;IACvC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iEAAiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,qBAAqB,CAAA;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC/C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC1D,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAA;IAChD,SAAS,EAAE,YAAY,EAAE,CAAA;CAC1B;AAMD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYjD;AA0CD,wBAAsB,eAAe,CACnC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,wBAAwB,CAAC,CAqFnC"}
+{"version":3,"file":"orchestrator-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/orchestrator-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAA;AAM7B,MAAM,WAAW,wBAAwB;IACvC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iEAAiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC/C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC1D,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAA;IAChD,SAAS,EAAE,YAAY,EAAE,CAAA;CAC1B;AAMD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYjD;AA0CD,wBAAsB,eAAe,CACnC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,wBAAwB,CAAC,CA6FnC"}

package/dist/src/lib/orchestrator-runner.js

@@ -77,12 +77,19 @@ export async function runOrchestrator(config) {
     const dryRun = config.dryRun ?? false;
     const gitRoot = config.gitRoot ?? getGitRoot();
     const cb = config.callbacks ?? defaultCallbacks();
-    const orchestrator = createOrchestrator({
+    const orchestratorConfig = {
         project: config.project,
         maxConcurrent,
         worktreePath: path.resolve(gitRoot, '.worktrees'),
         linearApiKey: config.linearApiKey,
-    }, {
+    };
+    if (config.templateDir) {
+        orchestratorConfig.templateDir = config.templateDir;
+    }
+    if (config.repository) {
+        orchestratorConfig.repository = config.repository;
+    }
+    const orchestrator = createOrchestrator(orchestratorConfig, {
         onIssueSelected: cb.onIssueSelected,
         onAgentStart: cb.onAgentStart,
         onAgentComplete: cb.onAgentComplete,

package/dist/src/orchestrator.js

@@ -30,6 +30,8 @@ function parseArgs() {
         single: undefined,
         wait: true,
         dryRun: false,
+        templates: undefined,
+        repo: undefined,
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -49,6 +51,12 @@ function parseArgs() {
             case '--dry-run':
                 result.dryRun = true;
                 break;
+            case '--templates':
+                result.templates = args[++i];
+                break;
+            case '--repo':
+                result.repo = args[++i];
+                break;
             case '--help':
             case '-h':
                 printHelp();
@@ -70,6 +78,8 @@ Options:
   --single <id>       Process a single issue by ID
   --no-wait           Don't wait for agents to complete
   --dry-run           Show what would be done without executing
+  --templates <path>  Custom workflow template directory
+  --repo <url>        Git repository URL for worktree cloning
   --help, -h          Show this help message
 
 Environment:
@@ -96,6 +106,7 @@ async function main() {
     console.log('========================');
     console.log(`Project: ${args.project ?? 'All'}`);
     console.log(`Max concurrent: ${args.max}`);
+    console.log(`Repo: ${args.repo ?? 'Any'}`);
     console.log(`Dry run: ${args.dryRun}`);
     console.log('');
     if (args.single) {
@@ -113,6 +124,8 @@ async function main() {
             single: args.single,
             wait: args.wait,
             dryRun: args.dryRun,
+            templateDir: args.templates,
+            repository: args.repo,
         });
         if (!args.single && !args.dryRun) {
             console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supaku/agentfactory-cli",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "type": "module",
   "description": "CLI tools for AgentFactory — local orchestrator, remote worker, queue admin",
   "author": "Supaku (https://supaku.com)",
@@ -34,7 +34,8 @@
     "af-cleanup": "./dist/src/cleanup.js",
     "af-queue-admin": "./dist/src/queue-admin.js",
     "af-analyze-logs": "./dist/src/analyze-logs.js",
-    "af-linear": "./dist/src/linear.js"
+    "af-linear": "./dist/src/linear.js",
+    "af-governor": "./dist/src/governor.js"
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
@@ -88,9 +89,9 @@
   ],
   "dependencies": {
     "dotenv": "^17.2.3",
-    "@supaku/agentfactory": "0.7.9",
-    "@supaku/agentfactory-linear": "0.7.9",
-    "@supaku/agentfactory-server": "0.7.9"
+    "@supaku/agentfactory-linear": "0.7.11",
+    "@supaku/agentfactory": "0.7.11",
+    "@supaku/agentfactory-server": "0.7.11"
   },
   "devDependencies": {
     "@types/node": "^22.5.4",