aoaoe 1.0.0 → 2.0.0

package/dist/session-replay.js

@@ -0,0 +1,103 @@
+// session-replay.ts — replay a session's activity timeline step-by-step.
+// reconstructs the session's history from audit trail + fleet snapshots
+// and presents it as a chronological narrative for post-mortem analysis.
+import { readRecentAuditEntries } from "./audit-trail.js";
+/**
+ * Build a replay timeline for a session from the audit trail.
+ */
+export function buildSessionReplay(sessionTitle, maxEvents = 200) {
+    const all = readRecentAuditEntries(10_000);
+    const sessionEvents = all.filter((e) => e.session === sessionTitle ||
+        e.detail.toLowerCase().includes(sessionTitle.toLowerCase()));
+    const events = sessionEvents.slice(-maxEvents).map((e) => ({
+        timestamp: new Date(e.timestamp).getTime(),
+        timeLabel: e.timestamp.slice(11, 19),
+        type: e.type,
+        detail: e.detail,
+    }));
+    const totalDuration = events.length >= 2
+        ? events[events.length - 1].timestamp - events[0].timestamp
+        : 0;
+    return {
+        sessionTitle,
+        events,
+        totalDurationMs: totalDuration,
+        eventCount: events.length,
+    };
+}
+/**
+ * Format replay as a chronological narrative.
+ */
+export function formatReplay(replay) {
+    if (replay.events.length === 0) {
+        return [`  No replay data for "${replay.sessionTitle}" (check audit trail)`];
+    }
+    const lines = [];
+    const durationLabel = replay.totalDurationMs > 0
+        ? formatDuration(replay.totalDurationMs)
+        : "instant";
+    lines.push(`  Replay: "${replay.sessionTitle}" (${replay.eventCount} events, ${durationLabel})`);
+    lines.push("");
+    let lastTimestamp = 0;
+    for (const e of replay.events) {
+        // show time gap between events
+        if (lastTimestamp > 0) {
+            const gap = e.timestamp - lastTimestamp;
+            if (gap > 60_000) {
+                lines.push(`  ... ${formatDuration(gap)} later ...`);
+            }
+        }
+        lastTimestamp = e.timestamp;
+        const icon = eventIcon(e.type);
+        lines.push(`  ${e.timeLabel} ${icon} ${e.type}: ${e.detail}`);
+    }
+    return lines;
+}
+/**
+ * Generate a summary of the replay (for quick review).
+ */
+export function summarizeReplay(replay) {
+    if (replay.events.length === 0)
+        return [`  "${replay.sessionTitle}": no events`];
+    // count by type
+    const typeCounts = new Map();
+    for (const e of replay.events) {
+        typeCounts.set(e.type, (typeCounts.get(e.type) ?? 0) + 1);
+    }
+    const lines = [];
+    lines.push(`  "${replay.sessionTitle}" summary:`);
+    lines.push(`  Duration: ${formatDuration(replay.totalDurationMs)}  Events: ${replay.eventCount}`);
+    const sorted = [...typeCounts.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [type, count] of sorted) {
+        lines.push(`    ${eventIcon(type)} ${type}: ${count}`);
+    }
+    return lines;
+}
+function eventIcon(type) {
+    const icons = {
+        reasoner_action: "🧠",
+        auto_complete: "✅",
+        budget_pause: "💰",
+        conflict_detected: "⚔",
+        operator_command: "👤",
+        task_created: "📋",
+        task_completed: "🏁",
+        session_error: "❌",
+        session_restart: "🔄",
+        config_change: "⚙",
+        stuck_nudge: "👉",
+        daemon_start: "🚀",
+        daemon_stop: "🛑",
+    };
+    return icons[type] ?? "·";
+}
+function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    const h = Math.floor(ms / 3_600_000);
+    const m = Math.round((ms % 3_600_000) / 60_000);
+    return m > 0 ? `${h}h ${m}m` : `${h}h`;
+}
+//# sourceMappingURL=session-replay.js.map

package/dist/token-quota.d.ts

@@ -0,0 +1,45 @@
+export interface TokenQuota {
+    model: string;
+    maxInputTokensPerHour: number;
+    maxOutputTokensPerHour: number;
+}
+export interface TokenUsageSample {
+    timestamp: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+export interface TokenQuotaStatus {
+    model: string;
+    inputTokensUsed: number;
+    outputTokensUsed: number;
+    inputLimit: number;
+    outputLimit: number;
+    inputPercent: number;
+    outputPercent: number;
+    blocked: boolean;
+    reason: string;
+}
+/**
+ * Manage per-model token quotas.
+ */
+export declare class TokenQuotaManager {
+    private quotas;
+    private samples;
+    private windowMs;
+    constructor(quotas?: TokenQuota[], windowMs?: number);
+    /** Set or update a quota for a model. */
+    setQuota(model: string, maxInput: number, maxOutput: number): void;
+    /** Record token usage for a model. */
+    recordUsage(model: string, inputTokens: number, outputTokens: number, now?: number): void;
+    /** Check if a model is within its token quota. */
+    getStatus(model: string, now?: number): TokenQuotaStatus;
+    /** Check if reasoning should be blocked for a model. */
+    isBlocked(model: string, now?: number): boolean;
+    /** Get status for all models with quotas. */
+    getAllStatuses(now?: number): TokenQuotaStatus[];
+    /** Format for TUI display. */
+    formatAll(now?: number): string[];
+    private prune;
+}
+//# sourceMappingURL=token-quota.d.ts.map

package/dist/token-quota.js

@@ -0,0 +1,76 @@
+// token-quota.ts — per-model token quotas for fleet-wide rate limiting.
+// extends the USD-based rate limiter with token-level granularity per model.
+/**
+ * Manage per-model token quotas.
+ */
+export class TokenQuotaManager {
+    quotas;
+    samples = [];
+    windowMs;
+    constructor(quotas = [], windowMs = 3_600_000) {
+        this.quotas = new Map(quotas.map((q) => [q.model, q]));
+        this.windowMs = windowMs;
+    }
+    /** Set or update a quota for a model. */
+    setQuota(model, maxInput, maxOutput) {
+        this.quotas.set(model, { model, maxInputTokensPerHour: maxInput, maxOutputTokensPerHour: maxOutput });
+    }
+    /** Record token usage for a model. */
+    recordUsage(model, inputTokens, outputTokens, now = Date.now()) {
+        this.samples.push({ timestamp: now, model, inputTokens, outputTokens });
+        this.prune(now);
+    }
+    /** Check if a model is within its token quota. */
+    getStatus(model, now = Date.now()) {
+        this.prune(now);
+        const quota = this.quotas.get(model);
+        if (!quota) {
+            return { model, inputTokensUsed: 0, outputTokensUsed: 0, inputLimit: Infinity, outputLimit: Infinity, inputPercent: 0, outputPercent: 0, blocked: false, reason: "no quota set" };
+        }
+        const cutoff = now - this.windowMs;
+        const modelSamples = this.samples.filter((s) => s.model === model && s.timestamp >= cutoff);
+        const inputUsed = modelSamples.reduce((sum, s) => sum + s.inputTokens, 0);
+        const outputUsed = modelSamples.reduce((sum, s) => sum + s.outputTokens, 0);
+        const inputPct = (inputUsed / quota.maxInputTokensPerHour) * 100;
+        const outputPct = (outputUsed / quota.maxOutputTokensPerHour) * 100;
+        const blocked = inputUsed >= quota.maxInputTokensPerHour || outputUsed >= quota.maxOutputTokensPerHour;
+        return {
+            model,
+            inputTokensUsed: inputUsed,
+            outputTokensUsed: outputUsed,
+            inputLimit: quota.maxInputTokensPerHour,
+            outputLimit: quota.maxOutputTokensPerHour,
+            inputPercent: inputPct,
+            outputPercent: outputPct,
+            blocked,
+            reason: blocked
+                ? `${inputUsed >= quota.maxInputTokensPerHour ? "input" : "output"} quota exceeded`
+                : "ok",
+        };
+    }
+    /** Check if reasoning should be blocked for a model. */
+    isBlocked(model, now = Date.now()) {
+        return this.getStatus(model, now).blocked;
+    }
+    /** Get status for all models with quotas. */
+    getAllStatuses(now = Date.now()) {
+        return [...this.quotas.keys()].map((m) => this.getStatus(m, now));
+    }
+    /** Format for TUI display. */
+    formatAll(now = Date.now()) {
+        const statuses = this.getAllStatuses(now);
+        if (statuses.length === 0)
+            return ["  (no token quotas configured)"];
+        const lines = [];
+        for (const s of statuses) {
+            const icon = s.blocked ? "🔴" : s.inputPercent > 80 || s.outputPercent > 80 ? "🟡" : "🟢";
+            lines.push(`  ${icon} ${s.model}: ${s.inputTokensUsed.toLocaleString()}/${s.inputLimit.toLocaleString()} in, ${s.outputTokensUsed.toLocaleString()}/${s.outputLimit.toLocaleString()} out (${Math.round(Math.max(s.inputPercent, s.outputPercent))}%)`);
+        }
+        return lines;
+    }
+    prune(now) {
+        const cutoff = now - this.windowMs * 2;
+        this.samples = this.samples.filter((s) => s.timestamp >= cutoff);
+    }
+}
+//# sourceMappingURL=token-quota.js.map

package/dist/workflow-chain.d.ts

@@ -0,0 +1,33 @@
+import type { WorkflowState } from "./workflow-engine.js";
+export interface WorkflowChainEntry {
+    workflowName: string;
+    dependsOn: string[];
+    status: "pending" | "active" | "completed" | "failed";
+}
+export interface WorkflowChain {
+    name: string;
+    entries: WorkflowChainEntry[];
+    startedAt: number;
+    completedAt?: number;
+}
+/**
+ * Create a workflow chain from a list of entries.
+ */
+export declare function createWorkflowChain(name: string, entries: Array<{
+    workflowName: string;
+    dependsOn?: string[];
+}>, now?: number): WorkflowChain;
+/**
+ * Advance the chain: activate workflows whose dependencies are met.
+ * Returns workflow names that should be started.
+ */
+export declare function advanceChain(chain: WorkflowChain, workflowStates: ReadonlyMap<string, WorkflowState>): {
+    activate: string[];
+    completed: boolean;
+    failed: boolean;
+};
+/**
+ * Format workflow chain for TUI display.
+ */
+export declare function formatWorkflowChain(chain: WorkflowChain): string[];
+//# sourceMappingURL=workflow-chain.d.ts.map

package/dist/workflow-chain.js

@@ -0,0 +1,69 @@
+// workflow-chain.ts — chain workflows together with dependencies.
+// a workflow chain is a sequence of workflows where each can depend on
+// the completion of previous workflows before starting.
+/**
+ * Create a workflow chain from a list of entries.
+ */
+export function createWorkflowChain(name, entries, now = Date.now()) {
+    return {
+        name,
+        entries: entries.map((e) => ({
+            workflowName: e.workflowName,
+            dependsOn: e.dependsOn ?? [],
+            status: "pending",
+        })),
+        startedAt: now,
+    };
+}
+/**
+ * Advance the chain: activate workflows whose dependencies are met.
+ * Returns workflow names that should be started.
+ */
+export function advanceChain(chain, workflowStates) {
+    const completedSet = new Set();
+    const failedSet = new Set();
+    for (const entry of chain.entries) {
+        const wfState = workflowStates.get(entry.workflowName);
+        if (entry.status === "completed" || wfState?.completedAt) {
+            entry.status = "completed";
+            completedSet.add(entry.workflowName);
+        }
+        if (entry.status === "failed") {
+            failedSet.add(entry.workflowName);
+        }
+    }
+    // check for failed chains
+    if (failedSet.size > 0) {
+        return { activate: [], completed: false, failed: true };
+    }
+    const activate = [];
+    for (const entry of chain.entries) {
+        if (entry.status !== "pending")
+            continue;
+        const depsmet = entry.dependsOn.every((dep) => completedSet.has(dep));
+        if (depsmet) {
+            entry.status = "active";
+            activate.push(entry.workflowName);
+        }
+    }
+    const allDone = chain.entries.every((e) => e.status === "completed");
+    if (allDone)
+        chain.completedAt = Date.now();
+    return { activate, completed: allDone, failed: false };
+}
+/**
+ * Format workflow chain for TUI display.
+ */
+export function formatWorkflowChain(chain) {
+    const lines = [];
+    const elapsed = chain.completedAt ? chain.completedAt - chain.startedAt : Date.now() - chain.startedAt;
+    const dur = elapsed < 60_000 ? `${Math.round(elapsed / 1000)}s` : `${Math.round(elapsed / 60_000)}m`;
+    lines.push(`  Workflow chain: ${chain.name} (${dur})`);
+    for (const e of chain.entries) {
+        const icon = e.status === "completed" ? "✓" : e.status === "active" ? "▶" : e.status === "failed" ? "✗" : "○";
+        const deps = e.dependsOn.length > 0 ? ` ← [${e.dependsOn.join(", ")}]` : "";
+        lines.push(`  ${icon} ${e.workflowName} (${e.status})${deps}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-chain.js.map

package/dist/workflow-cost-forecast.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowDefinition } from "./workflow-engine.js";
+export interface WorkflowCostForecast {
+    workflowName: string;
+    totalEstimatedCostUsd: number;
+    totalEstimatedHours: number;
+    stages: Array<{
+        name: string;
+        taskCount: number;
+        estimatedCostUsd: number;
+        estimatedHours: number;
+    }>;
+    confidence: "low" | "medium" | "high";
+}
+/**
+ * Estimate the total cost of running a workflow.
+ */
+export declare function forecastWorkflowCost(workflow: WorkflowDefinition, historicalCostPerHour?: number): WorkflowCostForecast;
+/**
+ * Format workflow cost forecast for TUI display.
+ */
+export declare function formatWorkflowCostForecast(forecast: WorkflowCostForecast): string[];
+//# sourceMappingURL=workflow-cost-forecast.d.ts.map

package/dist/workflow-cost-forecast.js

@@ -0,0 +1,55 @@
+// workflow-cost-forecast.ts — estimate total workflow cost before starting.
+// uses per-stage task difficulty + historical cost patterns to project spend.
+import { scoreDifficulty } from "./difficulty-scorer.js";
+// rough cost per difficulty point per hour (based on typical LLM usage)
+const COST_PER_DIFFICULTY_HOUR = 0.50; // $0.50/difficulty-point/hour
+/**
+ * Estimate the total cost of running a workflow.
+ */
+export function forecastWorkflowCost(workflow, historicalCostPerHour) {
+    const costRate = historicalCostPerHour ?? COST_PER_DIFFICULTY_HOUR;
+    let totalCost = 0;
+    let totalHours = 0;
+    const stages = workflow.stages.map((stage) => {
+        let stageCost = 0;
+        let stageHours = 0;
+        for (const task of stage.tasks) {
+            const difficulty = scoreDifficulty(task.sessionTitle, task.goal);
+            const hours = difficulty.estimatedHours;
+            const cost = hours * costRate * (difficulty.score / 5); // scale by difficulty
+            stageCost += cost;
+            stageHours = Math.max(stageHours, hours); // parallel tasks: max duration
+        }
+        totalCost += stageCost;
+        totalHours += stageHours; // sequential stages: sum durations
+        return {
+            name: stage.name,
+            taskCount: stage.tasks.length,
+            estimatedCostUsd: Math.round(stageCost * 100) / 100,
+            estimatedHours: Math.round(stageHours * 10) / 10,
+        };
+    });
+    const confidence = historicalCostPerHour ? "medium" : "low";
+    return {
+        workflowName: workflow.name,
+        totalEstimatedCostUsd: Math.round(totalCost * 100) / 100,
+        totalEstimatedHours: Math.round(totalHours * 10) / 10,
+        stages,
+        confidence,
+    };
+}
+/**
+ * Format workflow cost forecast for TUI display.
+ */
+export function formatWorkflowCostForecast(forecast) {
+    const conf = forecast.confidence === "high" ? "●" : forecast.confidence === "medium" ? "◐" : "○";
+    const lines = [];
+    lines.push(`  ${conf} Workflow cost forecast: "${forecast.workflowName}"`);
+    lines.push(`  Total: ~$${forecast.totalEstimatedCostUsd.toFixed(2)} over ~${forecast.totalEstimatedHours}h`);
+    lines.push("");
+    for (const s of forecast.stages) {
+        lines.push(`  ${s.name}: ${s.taskCount} task${s.taskCount !== 1 ? "s" : ""}, ~$${s.estimatedCostUsd.toFixed(2)}, ~${s.estimatedHours}h`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-cost-forecast.js.map

package/dist/workflow-engine.d.ts

@@ -0,0 +1,48 @@
+export interface WorkflowStage {
+    name: string;
+    tasks: Array<{
+        sessionTitle: string;
+        goal: string;
+    }>;
+    dependsOnStage?: string;
+}
+export interface WorkflowDefinition {
+    name: string;
+    stages: WorkflowStage[];
+}
+export interface WorkflowState {
+    name: string;
+    currentStage: number;
+    stages: Array<{
+        name: string;
+        status: "pending" | "active" | "completed" | "failed";
+        tasks: Array<{
+            sessionTitle: string;
+            status: string;
+        }>;
+    }>;
+    startedAt: number;
+    completedAt?: number;
+}
+/**
+ * Create a workflow state from a definition.
+ */
+export declare function createWorkflowState(def: WorkflowDefinition, now?: number): WorkflowState;
+/**
+ * Advance the workflow based on current task states.
+ * Returns actions to take (activate next stage's tasks, complete workflow, etc.)
+ */
+export declare function advanceWorkflow(workflow: WorkflowState, taskStates: ReadonlyMap<string, string>): {
+    actions: WorkflowAction[];
+    completed: boolean;
+};
+export interface WorkflowAction {
+    type: "activate_task" | "stage_started" | "stage_completed" | "stage_failed" | "workflow_completed";
+    stage: string;
+    detail: string;
+}
+/**
+ * Format workflow state for TUI display.
+ */
+export declare function formatWorkflow(workflow: WorkflowState): string[];
+//# sourceMappingURL=workflow-engine.d.ts.map

package/dist/workflow-engine.js

@@ -0,0 +1,91 @@
+// workflow-engine.ts — define multi-session workflows with fan-out/fan-in.
+// a workflow is a DAG of stages, each containing one or more parallel tasks.
+// stages execute sequentially; tasks within a stage execute in parallel.
+/**
+ * Create a workflow state from a definition.
+ */
+export function createWorkflowState(def, now = Date.now()) {
+    return {
+        name: def.name,
+        currentStage: 0,
+        stages: def.stages.map((s) => ({
+            name: s.name,
+            status: "pending",
+            tasks: s.tasks.map((t) => ({ sessionTitle: t.sessionTitle, status: "pending" })),
+        })),
+        startedAt: now,
+    };
+}
+/**
+ * Advance the workflow based on current task states.
+ * Returns actions to take (activate next stage's tasks, complete workflow, etc.)
+ */
+export function advanceWorkflow(workflow, taskStates) {
+    const actions = [];
+    if (workflow.currentStage >= workflow.stages.length) {
+        return { actions: [], completed: true };
+    }
+    const current = workflow.stages[workflow.currentStage];
+    // update task statuses from live data
+    for (const task of current.tasks) {
+        const liveStatus = taskStates.get(task.sessionTitle);
+        if (liveStatus)
+            task.status = liveStatus;
+    }
+    // check if current stage is completed
+    const allDone = current.tasks.every((t) => t.status === "completed");
+    const anyFailed = current.tasks.some((t) => t.status === "failed");
+    if (anyFailed) {
+        current.status = "failed";
+        actions.push({ type: "stage_failed", stage: current.name, detail: `stage "${current.name}" has failed tasks` });
+        return { actions, completed: false };
+    }
+    if (allDone) {
+        current.status = "completed";
+        workflow.currentStage++;
+        if (workflow.currentStage >= workflow.stages.length) {
+            workflow.completedAt = Date.now();
+            actions.push({ type: "workflow_completed", stage: workflow.name, detail: `workflow "${workflow.name}" completed` });
+            return { actions, completed: true };
+        }
+        // activate next stage
+        const next = workflow.stages[workflow.currentStage];
+        next.status = "active";
+        for (const task of next.tasks) {
+            actions.push({ type: "activate_task", stage: next.name, detail: task.sessionTitle });
+        }
+        actions.push({ type: "stage_started", stage: next.name, detail: `stage "${next.name}" started (${next.tasks.length} tasks)` });
+    }
+    else if (current.status === "pending") {
+        // activate first stage
+        current.status = "active";
+        for (const task of current.tasks) {
+            actions.push({ type: "activate_task", stage: current.name, detail: task.sessionTitle });
+        }
+        actions.push({ type: "stage_started", stage: current.name, detail: `stage "${current.name}" started (${current.tasks.length} tasks)` });
+    }
+    return { actions, completed: false };
+}
+/**
+ * Format workflow state for TUI display.
+ */
+export function formatWorkflow(workflow) {
+    const lines = [];
+    const elapsed = workflow.completedAt
+        ? workflow.completedAt - workflow.startedAt
+        : Date.now() - workflow.startedAt;
+    const duration = elapsed < 60_000 ? `${Math.round(elapsed / 1000)}s` : `${Math.round(elapsed / 60_000)}m`;
+    lines.push(`  Workflow: ${workflow.name} (${duration})`);
+    for (let i = 0; i < workflow.stages.length; i++) {
+        const s = workflow.stages[i];
+        const icon = s.status === "completed" ? "✓" : s.status === "active" ? "▶" : s.status === "failed" ? "✗" : "○";
+        const current = i === workflow.currentStage ? " ←" : "";
+        lines.push(`  ${icon} Stage ${i + 1}: ${s.name} (${s.status})${current}`);
+        for (const t of s.tasks) {
+            const tIcon = t.status === "completed" ? "✓" : t.status === "active" ? "~" : t.status === "failed" ? "!" : ".";
+            lines.push(`      [${tIcon}] ${t.sessionTitle}`);
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-engine.js.map

package/dist/workflow-templates.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowDefinition } from "./workflow-engine.js";
+export interface WorkflowTemplate {
+    name: string;
+    description: string;
+    stages: Array<{
+        name: string;
+        taskGoals: string[];
+    }>;
+    tags: string[];
+}
+export declare const BUILTIN_WORKFLOW_TEMPLATES: WorkflowTemplate[];
+/**
+ * Find a workflow template by name.
+ */
+export declare function findWorkflowTemplate(name: string): WorkflowTemplate | undefined;
+/**
+ * Instantiate a workflow definition from a template.
+ * sessionPrefix is used to generate session titles for each task.
+ */
+export declare function instantiateWorkflow(template: WorkflowTemplate, sessionPrefix: string): WorkflowDefinition;
+/**
+ * Format workflow template list for TUI display.
+ */
+export declare function formatWorkflowTemplateList(): string[];
+//# sourceMappingURL=workflow-templates.d.ts.map

package/dist/workflow-templates.js

@@ -0,0 +1,92 @@
+// workflow-templates.ts — pre-built workflow definitions for common patterns.
+// each template produces a WorkflowDefinition ready to instantiate.
+export const BUILTIN_WORKFLOW_TEMPLATES = [
+    {
+        name: "ci-cd",
+        description: "Build → Test → Deploy pipeline",
+        stages: [
+            { name: "build", taskGoals: ["Build the project and fix any compilation errors"] },
+            { name: "test", taskGoals: ["Run the full test suite and fix any failures"] },
+            { name: "deploy", taskGoals: ["Deploy to staging/production and verify health checks"] },
+        ],
+        tags: ["ci", "cd", "deploy"],
+    },
+    {
+        name: "feature-dev",
+        description: "Implement → Test → Review → Merge",
+        stages: [
+            { name: "implement", taskGoals: ["Implement the feature according to the spec"] },
+            { name: "test", taskGoals: ["Write unit and integration tests for the new feature", "Run existing tests to verify no regressions"] },
+            { name: "review", taskGoals: ["Self-review: check for code quality, security, and documentation"] },
+            { name: "merge", taskGoals: ["Create PR, address feedback, merge to main"] },
+        ],
+        tags: ["feature", "development"],
+    },
+    {
+        name: "refactor",
+        description: "Analyze → Refactor → Test → Cleanup",
+        stages: [
+            { name: "analyze", taskGoals: ["Identify code smells, duplications, and improvement opportunities"] },
+            { name: "refactor", taskGoals: ["Apply refactoring changes incrementally with tests passing at each step"] },
+            { name: "test", taskGoals: ["Run full test suite, fix any regressions from refactoring"] },
+            { name: "cleanup", taskGoals: ["Remove dead code, update documentation, commit with clear message"] },
+        ],
+        tags: ["refactor", "cleanup"],
+    },
+    {
+        name: "incident-response",
+        description: "Triage → Fix → Test → Postmortem",
+        stages: [
+            { name: "triage", taskGoals: ["Identify root cause from logs and error output"] },
+            { name: "fix", taskGoals: ["Implement the fix with minimal blast radius"] },
+            { name: "test", taskGoals: ["Verify fix resolves the issue, run regression tests"] },
+            { name: "postmortem", taskGoals: ["Document what happened, why, and how to prevent recurrence"] },
+        ],
+        tags: ["incident", "hotfix", "production"],
+    },
+    {
+        name: "multi-repo",
+        description: "Parallel work across multiple repositories",
+        stages: [
+            { name: "parallel-work", taskGoals: ["Complete assigned work in each repository"] },
+            { name: "integration", taskGoals: ["Verify cross-repo integration works correctly"] },
+            { name: "release", taskGoals: ["Tag releases and update dependency references"] },
+        ],
+        tags: ["multi-repo", "monorepo"],
+    },
+];
+/**
+ * Find a workflow template by name.
+ */
+export function findWorkflowTemplate(name) {
+    return BUILTIN_WORKFLOW_TEMPLATES.find((t) => t.name.toLowerCase() === name.toLowerCase());
+}
+/**
+ * Instantiate a workflow definition from a template.
+ * sessionPrefix is used to generate session titles for each task.
+ */
+export function instantiateWorkflow(template, sessionPrefix) {
+    let taskCounter = 0;
+    const stages = template.stages.map((s) => ({
+        name: s.name,
+        tasks: s.taskGoals.map((goal) => {
+            taskCounter++;
+            return { sessionTitle: `${sessionPrefix}-${s.name}-${taskCounter}`, goal };
+        }),
+    }));
+    return { name: `${sessionPrefix}-${template.name}`, stages };
+}
+/**
+ * Format workflow template list for TUI display.
+ */
+export function formatWorkflowTemplateList() {
+    const lines = [];
+    lines.push(`  Workflow templates (${BUILTIN_WORKFLOW_TEMPLATES.length} built-in):`);
+    for (const t of BUILTIN_WORKFLOW_TEMPLATES) {
+        const stageNames = t.stages.map((s) => s.name).join(" → ");
+        lines.push(`  ${t.name.padEnd(18)} ${stageNames}  [${t.tags.join(", ")}]`);
+        lines.push(`    ${t.description}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=workflow-templates.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aoaoe",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Autonomous supervisor for agent-of-empires sessions using OpenCode or Claude Code",
   "type": "module",
   "main": "dist/index.js",