aoaoe 1.0.0 → 1.3.0

package/README.md

@@ -4,7 +4,7 @@
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml"><img src="https://github.com/Talador12/agent-of-agent-of-empires/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
     <a href="https://www.npmjs.com/package/aoaoe"><img src="https://img.shields.io/npm/v/aoaoe" alt="npm version"></a>
     <a href="https://github.com/Talador12/agent-of-agent-of-empires/releases"><img src="https://img.shields.io/github/v/release/Talador12/agent-of-agent-of-empires" alt="GitHub release"></a>
-    <img src="https://img.shields.io/badge/tests-2427-brightgreen" alt="tests">
+    <img src="https://img.shields.io/badge/tests-3332-brightgreen" alt="tests">
     <img src="https://img.shields.io/badge/node-%3E%3D20-blue" alt="Node.js >= 20">
     <img src="https://img.shields.io/badge/runtime%20deps-0-brightgreen" alt="zero runtime dependencies">
     <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
@@ -822,6 +822,28 @@ The daemon and chat UI communicate via files in `~/.aoaoe/`:
 | `chat.pid` | chat UI | daemon | Chat process PID for detection |
 | `actions.log` | daemon | -- | Persistent action history (JSONL) |
 
+## Intelligence Modules
+
+aoaoe includes 55 intelligence modules that run every daemon tick without LLM calls. They handle observability, automation, and fleet management autonomously:
+
+**Reasoning Pipeline** (7 gates, runs before every LLM call):
+- Fleet rate limiter, observation cache, priority filter, context compressor, LLM call, approval workflow, cost tracker
+
+**Per-Tick Autonomous Systems**:
+- Session summarizer, conflict detector + auto-resolver, goal completion detector, cost budget enforcer
+- Activity heatmap, budget predictor, task retry with backoff, adaptive poll controller
+- Fleet SLA monitor, progress velocity tracker, recovery playbook, dependency scheduler
+- Session graduation (trust ladder), fleet utilization tracker, anomaly detector
+- Workflow engine (fan-out/fan-in stage orchestration)
+
+**On-Demand Analytics** (via TUI commands):
+- Audit trail + search, fleet snapshots + diff, lifecycle analytics, cost attribution
+- Goal decomposition, difficulty scoring, smart nudge generation, template auto-detection
+- Fleet-wide search, nudge effectiveness tracking, difficulty-based allocation
+- Goal refinement from completed task patterns, fleet HTML export, session replay
+
+See `AGENTS.md` for the full source layout with all 55 modules described.
+
 ## Project Structure
 
 ```

package/dist/cli-completions.d.ts

@@ -0,0 +1,24 @@
+export declare const CLI_COMMANDS: readonly ["init", "tasks", "progress", "health", "summary", "supervisor", "incident", "runbook", "adopt", "doctor", "stats", "replay", "export", "tail", "web", "sync", "test-context", "task", "config"];
+export declare const CLI_FLAGS: readonly ["--config", "--verbose", "--dry-run", "--observe", "--confirm", "--json", "--ndjson", "--watch", "--changes-only", "--heartbeat", "--follow", "--help", "--version"];
+export declare const TUI_COMMANDS: readonly ["/supervisor", "/incident", "/runbook", "/progress", "/health", "/prompt-template", "/pin-save", "/pin-load", "/pin-presets", "/activity", "/conflicts", "/heatmap", "/audit", "/audit-stats", "/audit-search", "/fleet-snap", "/budget-predict", "/retries", "/fleet-forecast", "/priority", "/escalations", "/poll-status", "/drift", "/goal-progress", "/pool", "/reasoner-cost", "/anomaly", "/sla", "/velocity", "/schedule", "/cost-summary", "/session-report", "/cache", "/rate-limit", "/recovery", "/lifecycle", "/cost-report", "/decompose", "/memory", "/dep-graph", "/approvals", "/approve", "/reject", "/fleet-diff", "/template", "/difficulty", "/smart-nudge", "/utilization", "/detect-template", "/fleet-search", "/nudge-stats", "/allocation", "/graduation", "/refine", "/export", "/clear"];
+/**
+ * Generate bash completion script.
+ */
+export declare function generateBashCompletion(): string;
+/**
+ * Generate zsh completion script.
+ */
+export declare function generateZshCompletion(): string;
+/**
+ * Generate fish completion script.
+ */
+export declare function generateFishCompletion(): string;
+/**
+ * Generate completion script for the specified shell.
+ */
+export declare function generateCompletion(shell: "bash" | "zsh" | "fish"): string;
+/**
+ * List all available commands for help display.
+ */
+export declare function formatCommandList(): string[];
+//# sourceMappingURL=cli-completions.d.ts.map

package/dist/cli-completions.js

@@ -0,0 +1,114 @@
+// cli-completions.ts — shell autocomplete for all aoaoe commands and TUI slash commands.
+// generates completion scripts for bash, zsh, and fish.
+export const CLI_COMMANDS = [
+    "init", "tasks", "progress", "health", "summary", "supervisor",
+    "incident", "runbook", "adopt", "doctor", "stats", "replay",
+    "export", "tail", "web", "sync", "test-context",
+    "task", "config",
+];
+export const CLI_FLAGS = [
+    "--config", "--verbose", "--dry-run", "--observe", "--confirm",
+    "--json", "--ndjson", "--watch", "--changes-only", "--heartbeat", "--follow",
+    "--help", "--version",
+];
+export const TUI_COMMANDS = [
+    "/supervisor", "/incident", "/runbook", "/progress", "/health",
+    "/prompt-template", "/pin-save", "/pin-load", "/pin-presets",
+    "/activity", "/conflicts", "/heatmap", "/audit", "/audit-stats",
+    "/audit-search", "/fleet-snap", "/budget-predict", "/retries",
+    "/fleet-forecast", "/priority", "/escalations", "/poll-status",
+    "/drift", "/goal-progress", "/pool", "/reasoner-cost",
+    "/anomaly", "/sla", "/velocity", "/schedule", "/cost-summary",
+    "/session-report", "/cache", "/rate-limit", "/recovery",
+    "/lifecycle", "/cost-report", "/decompose", "/memory",
+    "/dep-graph", "/approvals", "/approve", "/reject", "/fleet-diff",
+    "/template", "/difficulty", "/smart-nudge", "/utilization",
+    "/detect-template", "/fleet-search", "/nudge-stats", "/allocation",
+    "/graduation", "/refine", "/export", "/clear",
+];
+/**
+ * Generate bash completion script.
+ */
+export function generateBashCompletion() {
+    const cmds = CLI_COMMANDS.join(" ");
+    const flags = CLI_FLAGS.join(" ");
+    return `# aoaoe bash completion
+# Add to ~/.bashrc: eval "$(aoaoe completions bash)"
+_aoaoe() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  if [[ "\${cur}" == --* ]]; then
+    COMPREPLY=($(compgen -W "${flags}" -- "\${cur}"))
+  elif [[ "\${COMP_CWORD}" -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "${cmds}" -- "\${cur}"))
+  fi
+}
+complete -F _aoaoe aoaoe
+`;
+}
+/**
+ * Generate zsh completion script.
+ */
+export function generateZshCompletion() {
+    const cmdList = CLI_COMMANDS.map((c) => `'${c}'`).join(" ");
+    const flagList = CLI_FLAGS.map((f) => `'${f}'`).join(" ");
+    return `# aoaoe zsh completion
+# Add to ~/.zshrc: eval "$(aoaoe completions zsh)"
+_aoaoe() {
+  local -a commands flags
+  commands=(${cmdList})
+  flags=(${flagList})
+  
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+  elif [[ "\${words[CURRENT]}" == --* ]]; then
+    _describe 'flag' flags
+  fi
+}
+compdef _aoaoe aoaoe
+`;
+}
+/**
+ * Generate fish completion script.
+ */
+export function generateFishCompletion() {
+    const lines = [
+        "# aoaoe fish completion",
+        "# Add to ~/.config/fish/completions/aoaoe.fish",
+    ];
+    for (const cmd of CLI_COMMANDS) {
+        lines.push(`complete -c aoaoe -n '__fish_use_subcommand' -a '${cmd}'`);
+    }
+    for (const flag of CLI_FLAGS) {
+        lines.push(`complete -c aoaoe -l '${flag.replace(/^--/, "")}'`);
+    }
+    return lines.join("\n") + "\n";
+}
+/**
+ * Generate completion script for the specified shell.
+ */
+export function generateCompletion(shell) {
+    switch (shell) {
+        case "bash": return generateBashCompletion();
+        case "zsh": return generateZshCompletion();
+        case "fish": return generateFishCompletion();
+    }
+}
+/**
+ * List all available commands for help display.
+ */
+export function formatCommandList() {
+    const lines = [];
+    lines.push(`  CLI commands (${CLI_COMMANDS.length}):`);
+    lines.push(`    ${CLI_COMMANDS.join(", ")}`);
+    lines.push("");
+    lines.push(`  TUI slash commands (${TUI_COMMANDS.length}):`);
+    // group in rows of 6
+    for (let i = 0; i < TUI_COMMANDS.length; i += 6) {
+        lines.push(`    ${TUI_COMMANDS.slice(i, i + 6).join("  ")}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=cli-completions.js.map

package/dist/config.d.ts

@@ -91,6 +91,9 @@ export declare function parseCliArgs(argv: string[]): {
     replaySpeed?: number;
     replayLast?: string;
     registerTitle?: string;
+    runService: boolean;
+    runCompletions: boolean;
+    completionsShell?: string;
 };
 export declare function printHelp(): void;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -359,7 +359,7 @@ export function parseCliArgs(argv) {
     let initForce = false;
     let runTaskCli = false;
     let registerTitle;
-    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showTasksJson: false, runProgress: false, progressSince: undefined, progressJson: false, runHealth: false, healthJson: false, runSummary: false, runAdopt: false, adoptTemplate: undefined, showHistory: false, showStatus: false, runRunbook: false, runbookJson: false, runbookSection: undefined, runIncident: false, incidentSince: undefined, incidentLimit: undefined, incidentJson: false, incidentNdjson: false, incidentWatch: false, incidentChangesOnly: false, incidentHeartbeatSec: undefined, incidentIntervalMs: undefined, runSupervisor: false, supervisorAll: false, supervisorSince: undefined, supervisorLimit: undefined, supervisorJson: false, supervisorNdjson: false, supervisorWatch: false, supervisorChangesOnly: false, supervisorHeartbeatSec: undefined, supervisorIntervalMs: undefined, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runBackup: false, backupOutput: undefined, runRestore: false, restoreInput: undefined, runSync: false, syncAction: undefined, syncRemote: undefined, runWeb: false, webPort: undefined, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, exportTasks: false, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined };
+    const defaults = { overrides, help: false, version: false, register: false, testContext: false, runTest: false, showTasks: false, showTasksJson: false, runProgress: false, progressSince: undefined, progressJson: false, runHealth: false, healthJson: false, runSummary: false, runAdopt: false, adoptTemplate: undefined, showHistory: false, showStatus: false, runRunbook: false, runbookJson: false, runbookSection: undefined, runIncident: false, incidentSince: undefined, incidentLimit: undefined, incidentJson: false, incidentNdjson: false, incidentWatch: false, incidentChangesOnly: false, incidentHeartbeatSec: undefined, incidentIntervalMs: undefined, runSupervisor: false, supervisorAll: false, supervisorSince: undefined, supervisorLimit: undefined, supervisorJson: false, supervisorNdjson: false, supervisorWatch: false, supervisorChangesOnly: false, supervisorHeartbeatSec: undefined, supervisorIntervalMs: undefined, showConfig: false, configValidate: false, configDiff: false, notifyTest: false, runDoctor: false, runBackup: false, backupOutput: undefined, runRestore: false, restoreInput: undefined, runSync: false, syncAction: undefined, syncRemote: undefined, runWeb: false, webPort: undefined, runLogs: false, logsActions: false, logsGrep: undefined, logsCount: undefined, runExport: false, exportFormat: undefined, exportOutput: undefined, exportLast: undefined, exportTasks: false, runInit: false, initForce: false, runTaskCli: false, runTail: false, tailFollow: false, tailCount: undefined, runStats: false, statsLast: undefined, runReplay: false, replaySpeed: undefined, replayLast: undefined, runService: false, runCompletions: false, completionsShell: undefined };
     // check for subcommand as first non-flag arg
     if (argv[2] === "test-context") {
         return { ...defaults, testContext: true };
@@ -573,6 +573,13 @@ export function parseCliArgs(argv) {
     if (argv[2] === "doctor") {
         return { ...defaults, runDoctor: true };
     }
+    if (argv[2] === "service") {
+        return { ...defaults, runService: true };
+    }
+    if (argv[2] === "completions") {
+        const shell = argv[3] ?? "bash";
+        return { ...defaults, runCompletions: true, completionsShell: shell };
+    }
     if (argv[2] === "backup") {
         const output = argv[3] && !argv[3].startsWith("-") ? argv[3] : undefined;
         return { ...defaults, runBackup: true, backupOutput: output };

package/dist/index.js

@@ -59,6 +59,9 @@ import { GraduationManager } from "./session-graduation.js";
 import { filterThroughApproval, formatApprovalWorkflowStatus } from "./approval-workflow.js";
 import { analyzeCompletedTasks, refineGoal, formatGoalRefinement } from "./goal-refiner.js";
 import { generateHtmlReport, buildReportData } from "./fleet-export.js";
+import { installService } from "./service-generator.js";
+import { buildSessionReplay, formatReplay, summarizeReplay } from "./session-replay.js";
+import { advanceWorkflow, formatWorkflow } from "./workflow-engine.js";
 import { buildLifecycleRecords, computeLifecycleStats, formatLifecycleStats } from "./lifecycle-analytics.js";
 import { buildCostAttributions, computeCostReport, formatCostReport } from "./cost-attribution.js";
 import { decomposeGoal, formatDecomposition } from "./goal-decomposer.js";
@@ -87,7 +90,7 @@ const AOAOE_DIR = join(homedir(), ".aoaoe"); // watch dir for wakeable sleep
 const INPUT_FILE = join(AOAOE_DIR, "pending-input.txt"); // file IPC from chat.ts
 const TASK_RECONCILE_EVERY_POLLS = 6;
 async function main() {
-    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showTasksJson, runProgress, progressSince, progressJson, runHealth, healthJson, runSummary, runAdopt, adoptTemplate, showHistory, showStatus, runRunbook, runbookJson, runbookSection, runIncident, incidentSince, incidentLimit, incidentJson, incidentNdjson, incidentWatch, incidentChangesOnly, incidentHeartbeatSec, incidentIntervalMs, runSupervisor, supervisorAll, supervisorSince, supervisorLimit, supervisorJson, supervisorNdjson, supervisorWatch, supervisorChangesOnly, supervisorHeartbeatSec, supervisorIntervalMs, showConfig, configValidate, configDiff, notifyTest, runDoctor, runBackup, backupOutput, runRestore, restoreInput, runSync, syncAction, syncRemote, runWeb, webPort, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, runReplay: isReplay, replaySpeed, replayLast, registerTitle } = parseCliArgs(process.argv);
+    const { overrides, help, version, register, testContext: isTestContext, runTest, showTasks, showTasksJson, runProgress, progressSince, progressJson, runHealth, healthJson, runSummary, runAdopt, adoptTemplate, showHistory, showStatus, runRunbook, runbookJson, runbookSection, runIncident, incidentSince, incidentLimit, incidentJson, incidentNdjson, incidentWatch, incidentChangesOnly, incidentHeartbeatSec, incidentIntervalMs, runSupervisor, supervisorAll, supervisorSince, supervisorLimit, supervisorJson, supervisorNdjson, supervisorWatch, supervisorChangesOnly, supervisorHeartbeatSec, supervisorIntervalMs, showConfig, configValidate, configDiff, notifyTest, runDoctor, runBackup, backupOutput, runRestore, restoreInput, runSync, syncAction, syncRemote, runWeb, webPort, runLogs, logsActions, logsGrep, logsCount, runExport, exportFormat, exportOutput, exportLast, runInit, initForce, runTaskCli: isTaskCli, runTail: isTail, tailFollow, tailCount, runStats: isStats, statsLast, runReplay: isReplay, replaySpeed, replayLast, registerTitle, runService, runCompletions, completionsShell } = parseCliArgs(process.argv);
     if (help) {
         printHelp();
         process.exit(0);
@@ -232,6 +235,18 @@ async function main() {
         await runDoctorCheck();
         return;
     }
+    if (runService) {
+        const lines = installService({ workingDir: process.cwd() });
+        for (const l of lines)
+            console.log(l);
+        return;
+    }
+    if (runCompletions) {
+        const { generateCompletion } = await import("./cli-completions.js");
+        const shell = (completionsShell ?? "bash");
+        console.log(generateCompletion(shell));
+        return;
+    }
     if (runBackup) {
         try {
             const result = await createBackup(backupOutput);
@@ -551,6 +566,7 @@ async function main() {
     const recoveryPlaybookManager = new RecoveryPlaybookManager();
     const approvalQueue = new ApprovalQueue();
     const graduationManager = new GraduationManager();
+    let activeWorkflow = null;
     // audit: log daemon start
     audit("daemon_start", `daemon started (v${pkg ?? "dev"}, reasoner=${config.reasoner})`);
     const refreshTaskSupervisorState = (reason) => {
@@ -2420,6 +2436,37 @@ async function main() {
             writeFileSync(filepath, html);
             tui.log("system", `fleet report exported: ${filepath}`);
         });
+        // wire /service — generate systemd/launchd service file
+        input.onService(() => {
+            const lines = installService({ workingDir: process.cwd() });
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /session-replay — session activity timeline replay
+        input.onSessionReplay((target) => {
+            const replay = buildSessionReplay(target);
+            if (replay.events.length === 0) {
+                tui.log("system", `replay: no events for "${target}" — run the daemon to generate audit data first`);
+                return;
+            }
+            const summary = summarizeReplay(replay);
+            for (const l of summary)
+                tui.log("system", l);
+            tui.log("system", "");
+            const detailed = formatReplay(replay);
+            for (const l of detailed)
+                tui.log("system", l);
+        });
+        // wire /workflow — show active workflow state
+        input.onWorkflow(() => {
+            if (!activeWorkflow) {
+                tui.log("system", "workflow: no active workflow (define one in aoaoe.tasks.json with workflow stages)");
+                return;
+            }
+            const lines = formatWorkflow(activeWorkflow);
+            for (const l of lines)
+                tui.log("system", l);
+        });
         input.onCostSummary(() => {
             const sessions = tui.getSessions();
             const summary = computeCostSummary(sessions, tui.getAllSessionCosts());
@@ -4045,6 +4092,25 @@ async function main() {
                             }
                         }
                     }
+                    // workflow engine: advance active workflow based on task states
+                    if (activeWorkflow && taskManager && tui) {
+                        const wf = activeWorkflow; // capture before potential null assignment
+                        const taskStates = new Map(taskManager.tasks.map((t) => [t.sessionTitle, t.status]));
+                        const { actions: wfActions, completed } = advanceWorkflow(wf, taskStates);
+                        for (const a of wfActions) {
+                            if (a.type === "activate_task") {
+                                const task = taskManager.getTaskForSession(a.detail);
+                                if (task && task.status === "pending")
+                                    task.status = "active";
+                            }
+                            tui.log("status", `workflow: ${a.type} — ${a.detail}`);
+                            audit("task_created", `workflow ${a.type}: ${a.detail}`, a.detail);
+                        }
+                        if (completed) {
+                            tui.log("+ action", `workflow "${wf.name}" completed`);
+                            activeWorkflow = null;
+                        }
+                    }
                     // trust ladder: record stable tick or failure, sync mode if escalated
                     if (tui && decisionsThisTick > 0) {
                         if (actionsFail > 0) {

package/dist/input.d.ts

@@ -131,6 +131,9 @@ export type AllocationHandler = () => void;
 export type GraduationHandler = () => void;
 export type RefineHandler = (target: string) => void;
 export type ExportHandler = () => void;
+export type ServiceHandler = () => void;
+export type SessionReplayHandler = (target: string) => void;
+export type WorkflowHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -443,6 +446,12 @@ export declare class InputReader {
     onGraduation(handler: GraduationHandler): void;
     onRefine(handler: RefineHandler): void;
     onExport(handler: ExportHandler): void;
+    private serviceHandler;
+    private sessionReplayHandler;
+    private workflowHandler;
+    onService(handler: ServiceHandler): void;
+    onSessionReplay(handler: SessionReplayHandler): void;
+    onWorkflow(handler: WorkflowHandler): void;
     onFleetSearch(handler: FleetSearchHandler): void;
     onNudgeStats(handler: NudgeStatsHandler): void;
     onAllocation(handler: AllocationHandler): void;

package/dist/input.js

@@ -540,6 +540,12 @@ export class InputReader {
     onGraduation(handler) { this.graduationHandler = handler; }
     onRefine(handler) { this.refineHandler = handler; }
     onExport(handler) { this.exportHandler = handler; }
+    serviceHandler = null;
+    sessionReplayHandler = null;
+    workflowHandler = null;
+    onService(handler) { this.serviceHandler = handler; }
+    onSessionReplay(handler) { this.sessionReplayHandler = handler; }
+    onWorkflow(handler) { this.workflowHandler = handler; }
     onFleetSearch(handler) { this.fleetSearchHandler = handler; }
     onNudgeStats(handler) { this.nudgeStatsHandler = handler; }
     onAllocation(handler) { this.allocationHandler = handler; }
@@ -2364,6 +2370,30 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}export not available (no TUI)${RESET}`);
                 break;
+            case "/service":
+                if (this.serviceHandler)
+                    this.serviceHandler();
+                else
+                    console.error(`${DIM}service not available (no TUI)${RESET}`);
+                break;
+            case "/session-replay": {
+                const rpArg = line.slice("/session-replay".length).trim();
+                if (!rpArg) {
+                    console.error(`${DIM}usage: /session-replay <session-name>${RESET}`);
+                    break;
+                }
+                if (this.sessionReplayHandler)
+                    this.sessionReplayHandler(rpArg);
+                else
+                    console.error(`${DIM}session-replay not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/workflow":
+                if (this.workflowHandler)
+                    this.workflowHandler();
+                else
+                    console.error(`${DIM}workflow not available (no TUI)${RESET}`);
+                break;
             case "/clear":
                 process.stderr.write("\x1b[2J\x1b[H");
                 break;

package/dist/service-generator.d.ts

@@ -0,0 +1,32 @@
+export interface ServiceConfig {
+    name: string;
+    description: string;
+    execPath: string;
+    workingDir: string;
+    configPath?: string;
+    user?: string;
+    restartSec: number;
+    logPath?: string;
+}
+/**
+ * Generate a systemd unit file for Linux.
+ */
+export declare function generateSystemdUnit(config?: Partial<ServiceConfig>): string;
+/**
+ * Generate a launchd plist file for macOS.
+ */
+export declare function generateLaunchdPlist(config?: Partial<ServiceConfig>): string;
+/**
+ * Detect the current platform and generate the appropriate service file.
+ */
+export declare function generateServiceFile(config?: Partial<ServiceConfig>): {
+    content: string;
+    filename: string;
+    installPath: string;
+    platform: string;
+};
+/**
+ * Write the service file and return install instructions.
+ */
+export declare function installService(config?: Partial<ServiceConfig>): string[];
+//# sourceMappingURL=service-generator.d.ts.map

package/dist/service-generator.js

@@ -0,0 +1,132 @@
+// service-generator.ts — generate systemd/launchd service files for daemon
+// auto-start on boot and crash restart. supports both Linux (systemd) and
+// macOS (launchd) platforms.
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+const DEFAULT_CONFIG = {
+    name: "aoaoe",
+    description: "aoaoe — autonomous supervisor daemon for agent-of-empires",
+    execPath: "aoaoe",
+    workingDir: process.cwd(),
+    restartSec: 5,
+};
+/**
+ * Generate a systemd unit file for Linux.
+ */
+export function generateSystemdUnit(config = {}) {
+    const c = { ...DEFAULT_CONFIG, ...config };
+    const execStart = c.configPath
+        ? `${c.execPath} --config ${c.configPath}`
+        : c.execPath;
+    return `[Unit]
+Description=${c.description}
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+WorkingDirectory=${c.workingDir}
+Restart=on-failure
+RestartSec=${c.restartSec}
+${c.user ? `User=${c.user}` : ""}
+${c.logPath ? `StandardOutput=append:${c.logPath}\nStandardError=append:${c.logPath}` : "StandardOutput=journal\nStandardError=journal"}
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+/**
+ * Generate a launchd plist file for macOS.
+ */
+export function generateLaunchdPlist(config = {}) {
+    const c = { ...DEFAULT_CONFIG, ...config };
+    const logPath = c.logPath ?? join(homedir(), "Library", "Logs", "aoaoe.log");
+    const errPath = c.logPath ? c.logPath.replace(".log", ".err.log") : join(homedir(), "Library", "Logs", "aoaoe.err.log");
+    const args = c.configPath
+        ? [`${c.execPath}`, "--config", c.configPath]
+        : [c.execPath];
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.aoaoe.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+${args.map((a) => `    <string>${escXml(a)}</string>`).join("\n")}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escXml(c.workingDir)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>${c.restartSec}</integer>
+  <key>StandardOutPath</key>
+  <string>${escXml(logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escXml(errPath)}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>NODE_ENV</key>
+    <string>production</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+/**
+ * Detect the current platform and generate the appropriate service file.
+ */
+export function generateServiceFile(config = {}) {
+    const os = platform();
+    if (os === "darwin") {
+        const filename = "com.aoaoe.daemon.plist";
+        const installPath = join(homedir(), "Library", "LaunchAgents", filename);
+        return { content: generateLaunchdPlist(config), filename, installPath, platform: "launchd" };
+    }
+    // Linux + fallback
+    const filename = `${config.name ?? "aoaoe"}.service`;
+    const installPath = join("/etc", "systemd", "system", filename);
+    return { content: generateSystemdUnit(config), filename, installPath, platform: "systemd" };
+}
+/**
+ * Write the service file and return install instructions.
+ */
+export function installService(config = {}) {
+    const { content, filename, installPath, platform: plat } = generateServiceFile(config);
+    const outDir = join(homedir(), ".aoaoe");
+    mkdirSync(outDir, { recursive: true });
+    const outPath = join(outDir, filename);
+    writeFileSync(outPath, content);
+    const lines = [];
+    lines.push(`Generated ${plat} service file: ${outPath}`);
+    lines.push("");
+    if (plat === "systemd") {
+        lines.push("Install with:");
+        lines.push(`  sudo cp ${outPath} ${installPath}`);
+        lines.push("  sudo systemctl daemon-reload");
+        lines.push(`  sudo systemctl enable ${filename}`);
+        lines.push(`  sudo systemctl start ${filename.replace(".service", "")}`);
+    }
+    else {
+        lines.push("Install with:");
+        lines.push(`  cp ${outPath} ${installPath}`);
+        lines.push(`  launchctl load ${installPath}`);
+        lines.push("");
+        lines.push("Uninstall with:");
+        lines.push(`  launchctl unload ${installPath}`);
+        lines.push(`  rm ${installPath}`);
+    }
+    return lines;
+}
+function escXml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//# sourceMappingURL=service-generator.js.map

package/dist/session-replay.d.ts

@@ -0,0 +1,25 @@
+export interface ReplayEvent {
+    timestamp: number;
+    timeLabel: string;
+    type: string;
+    detail: string;
+}
+export interface SessionReplay {
+    sessionTitle: string;
+    events: ReplayEvent[];
+    totalDurationMs: number;
+    eventCount: number;
+}
+/**
+ * Build a replay timeline for a session from the audit trail.
+ */
+export declare function buildSessionReplay(sessionTitle: string, maxEvents?: number): SessionReplay;
+/**
+ * Format replay as a chronological narrative.
+ */
+export declare function formatReplay(replay: SessionReplay): string[];
+/**
+ * Generate a summary of the replay (for quick review).
+ */
+export declare function summarizeReplay(replay: SessionReplay): string[];
+//# sourceMappingURL=session-replay.d.ts.map

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/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/package.json

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