aoaoe 0.186.0 → 0.187.0

package/dist/health-score.d.ts

@@ -0,0 +1,11 @@
+import type { TaskState } from "./types.js";
+export interface SessionHealth {
+    session: string;
+    score: number;
+    grade: "healthy" | "ok" | "degraded" | "critical" | "inactive";
+    factors: string[];
+}
+export declare function computeHealth(task: TaskState): SessionHealth;
+export declare function computeAllHealth(tasks: TaskState[]): SessionHealth[];
+export declare function formatHealthReport(tasks: TaskState[]): string;
+//# sourceMappingURL=health-score.d.ts.map

package/dist/health-score.js

@@ -0,0 +1,100 @@
+// health-score.ts — compute per-session health from task state + progress patterns.
+// health is a 0-100 score where 100 = healthy, active, progressing.
+import { BOLD, DIM, GREEN, YELLOW, RED, CYAN, RESET } from "./colors.js";
+// compute health score for a single task
+export function computeHealth(task) {
+    const factors = [];
+    let score = 100;
+    const now = Date.now();
+    // status penalties
+    if (task.status === "completed") {
+        return { session: task.sessionTitle, score: 100, grade: "healthy", factors: ["completed"] };
+    }
+    if (task.status === "failed") {
+        return { session: task.sessionTitle, score: 0, grade: "critical", factors: ["task failed"] };
+    }
+    if (task.status === "paused") {
+        return { session: task.sessionTitle, score: 30, grade: "degraded", factors: ["paused"] };
+    }
+    if (task.status === "pending") {
+        const hasDeps = task.dependsOn && task.dependsOn.length > 0;
+        return { session: task.sessionTitle, score: 50, grade: "inactive", factors: [hasDeps ? "waiting on dependencies" : "not started"] };
+    }
+    // progress recency (active tasks)
+    if (task.lastProgressAt) {
+        const ageMs = now - task.lastProgressAt;
+        if (ageMs < 10 * 60_000) {
+            factors.push("progress <10m ago");
+        }
+        else if (ageMs < 30 * 60_000) {
+            score -= 10;
+            factors.push("progress 10-30m ago");
+        }
+        else if (ageMs < 60 * 60_000) {
+            score -= 25;
+            factors.push("progress 30-60m ago");
+        }
+        else if (ageMs < 4 * 60 * 60_000) {
+            score -= 40;
+            factors.push("progress 1-4h ago");
+        }
+        else {
+            score -= 55;
+            factors.push(`progress ${Math.round(ageMs / 3_600_000)}h ago`);
+        }
+    }
+    else {
+        score -= 30;
+        factors.push("no progress recorded");
+    }
+    // stuck nudge count
+    const nudges = task.stuckNudgeCount ?? 0;
+    if (nudges > 0) {
+        score -= Math.min(nudges * 10, 30);
+        factors.push(`${nudges} stuck nudge(s)`);
+    }
+    // progress velocity (more entries = healthier)
+    const recentEntries = task.progress.filter((p) => p.at >= now - 4 * 60 * 60_000).length;
+    if (recentEntries >= 3) {
+        score = Math.min(score + 10, 100);
+        factors.push(`${recentEntries} progress entries in 4h`);
+    }
+    else if (recentEntries === 0 && task.progress.length > 0) {
+        score -= 10;
+        factors.push("no progress in last 4h");
+    }
+    score = Math.max(0, Math.min(100, score));
+    const grade = score >= 80 ? "healthy" :
+        score >= 60 ? "ok" :
+            score >= 40 ? "degraded" :
+                "critical";
+    return { session: task.sessionTitle, score, grade, factors };
+}
+// compute health for all tasks
+export function computeAllHealth(tasks) {
+    return tasks.map(computeHealth);
+}
+// format health report for display
+export function formatHealthReport(tasks) {
+    const healths = computeAllHealth(tasks);
+    if (healths.length === 0)
+        return "  (no tasks)";
+    const lines = [];
+    lines.push(`  ${BOLD}SESSION HEALTH${RESET}`);
+    lines.push(`  ${"-".repeat(60)}`);
+    for (const h of healths) {
+        const color = h.grade === "healthy" ? GREEN
+            : h.grade === "ok" ? CYAN
+                : h.grade === "degraded" ? YELLOW
+                    : h.grade === "critical" ? RED
+                        : DIM;
+        const bar = "█".repeat(Math.round(h.score / 10)) + "░".repeat(10 - Math.round(h.score / 10));
+        lines.push(`  ${color}${bar}${RESET} ${h.score.toString().padStart(3)}  ${BOLD}${h.session}${RESET} ${DIM}(${h.grade})${RESET}`);
+        lines.push(`  ${DIM}  ${h.factors.join(" · ")}${RESET}`);
+    }
+    const avg = Math.round(healths.reduce((sum, h) => sum + h.score, 0) / healths.length);
+    lines.push("");
+    lines.push(`  ${DIM}fleet average: ${avg}/100${RESET}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=health-score.js.map

package/dist/index.js

@@ -24,6 +24,9 @@ import { sendNotification, sendTestNotification, formatNotifyFilters, parseNotif
 import { startHealthServer } from "./health.js";
 import { loadTuiHistory, searchHistory, TUI_HISTORY_FILE, computeHistoryStats } from "./tui-history.js";
 import { appendSupervisorEvent, loadSupervisorEvents } from "./supervisor-history.js";
+import { savePreset, deletePreset, getPreset, formatPresetList } from "./pin-presets.js";
+import { resolvePromptTemplate, formatPromptTemplateList } from "./reasoner/prompt-templates.js";
+import { formatHealthReport } from "./health-score.js";
 import { ConfigWatcher, formatConfigChange } from "./config-watcher.js";
 import { parseActionLogEntries, parseActivityEntries, mergeTimeline, filterByAge, parseDuration, formatTimelineJson, formatTimelineMarkdown } from "./export.js";
 import { actionSession, actionDetail, toActionLogEntry } from "./types.js";
@@ -2295,6 +2298,150 @@ async function main() {
         const userMessage = userMessages.length > 0 ? formatUserMessages(userMessages) : undefined;
         // handle built-in command markers (from stdin or chat.ts file IPC)
         for (const cmd of commands) {
+            if (cmd.startsWith("__CMD_PIN_SAVE__")) {
+                const name = cmd.slice("__CMD_PIN_SAVE__".length).trim();
+                if (!name) {
+                    const msg = "usage: /pin-save <preset-name>";
+                    if (tui)
+                        tui.log("error", msg);
+                    else
+                        log(msg);
+                    continue;
+                }
+                if (tui) {
+                    const titles = tui.getPinnedTitles();
+                    if (titles.length === 0) {
+                        const msg = "no sessions pinned — /pin a session first";
+                        tui.log("status", msg);
+                    }
+                    else {
+                        savePreset(name, titles);
+                        const msg = `pin preset saved: ${name} (${titles.join(", ")})`;
+                        tui.log("system", msg);
+                        pushSupervisorEvent(`pin-save: ${name} [${titles.length} sessions]`);
+                    }
+                }
+                else {
+                    log("pin presets require TUI mode");
+                }
+                continue;
+            }
+            if (cmd.startsWith("__CMD_PIN_LOAD__")) {
+                const name = cmd.slice("__CMD_PIN_LOAD__".length).trim();
+                if (!name) {
+                    const msg = "usage: /pin-load <preset-name>";
+                    if (tui)
+                        tui.log("error", msg);
+                    else
+                        log(msg);
+                    continue;
+                }
+                const titles = getPreset(name);
+                if (!titles) {
+                    const msg = `pin preset not found: ${name}`;
+                    if (tui)
+                        tui.log("error", msg);
+                    else
+                        log(msg);
+                    continue;
+                }
+                if (tui) {
+                    const count = tui.loadPinPreset(titles);
+                    const msg = `pin preset loaded: ${name} (${count} sessions pinned)`;
+                    tui.log("system", msg);
+                    pushSupervisorEvent(`pin-load: ${name} [${count} pinned]`);
+                }
+                continue;
+            }
+            if (cmd.startsWith("__CMD_PIN_DELETE__")) {
+                const name = cmd.slice("__CMD_PIN_DELETE__".length).trim();
+                if (!name) {
+                    const msg = "usage: /pin-delete <preset-name>";
+                    if (tui)
+                        tui.log("error", msg);
+                    else
+                        log(msg);
+                    continue;
+                }
+                const ok = deletePreset(name);
+                const msg = ok ? `pin preset deleted: ${name}` : `pin preset not found: ${name}`;
+                if (tui)
+                    tui.log(ok ? "system" : "error", msg);
+                else
+                    log(msg);
+                continue;
+            }
+            if (cmd === "__CMD_PIN_PRESETS__") {
+                const msg = formatPresetList();
+                for (const line of msg.split("\n")) {
+                    if (tui)
+                        tui.log("status", line);
+                    else
+                        log(line);
+                }
+                continue;
+            }
+            if (cmd.startsWith("__CMD_PROMPT_TEMPLATE__")) {
+                const name = cmd.slice("__CMD_PROMPT_TEMPLATE__".length).trim();
+                if (!name) {
+                    const current = config.promptTemplate || "default";
+                    const msg = `current prompt template: ${current}`;
+                    if (tui)
+                        tui.log("status", msg);
+                    else
+                        log(msg);
+                    const list = formatPromptTemplateList();
+                    for (const line of list.split("\n")) {
+                        if (tui)
+                            tui.log("status", line);
+                        else
+                            log(line);
+                    }
+                }
+                else {
+                    const tmpl = resolvePromptTemplate(name);
+                    if (!tmpl) {
+                        const msg = `unknown prompt template: ${name}`;
+                        if (tui)
+                            tui.log("error", msg);
+                        else
+                            log(msg);
+                        const list = formatPromptTemplateList();
+                        for (const line of list.split("\n")) {
+                            if (tui)
+                                tui.log("status", line);
+                            else
+                                log(line);
+                        }
+                    }
+                    else {
+                        config.promptTemplate = tmpl.name;
+                        const msg = `prompt template set to: ${tmpl.name} — ${tmpl.description}`;
+                        if (tui)
+                            tui.log("system", msg);
+                        else
+                            log(msg);
+                        pushSupervisorEvent(`prompt-template: ${tmpl.name}`);
+                        reasonerConsole.writeSystem(msg);
+                        // note: takes effect on next reasoner init (next reasoning cycle)
+                        if (tui)
+                            tui.log("status", `(takes effect on next reasoning cycle)`);
+                    }
+                }
+                continue;
+            }
+            if (cmd === "__CMD_HEALTH__") {
+                const tasks = taskManager?.tasks ?? [];
+                const report = formatHealthReport(tasks);
+                for (const line of report.split("\n")) {
+                    if (tui)
+                        tui.log("status", line);
+                    else
+                        log(line);
+                    reasonerConsole.writeSystem(line);
+                }
+                continue;
+            }
             if (cmd === "__CMD_STATUS__") {
                 const isPausedNow = paused || input.isPaused();
                 const modeMsg = `status: poll #${pollCount}, mode=${getRunMode()}, reasoner=${getReasonerLabel()}, paused=${isPausedNow}`;
@@ -3600,6 +3747,36 @@ async function daemonTick(config, poller, reasoner, executor, reasonerConsole, p
             }
         }
     }
+    // auto-pause tracking: record stuck nudges for send_input actions targeting stuck sessions.
+    // a "stuck nudge" = send_input to a session that hasn't had progress in >30 min.
+    if (taskManager) {
+        const maxNudges = config.policies.maxStuckNudgesBeforePause ?? 0;
+        const stuckThresholdMs = 30 * 60 * 1000;
+        const now = Date.now();
+        for (const entry of executed) {
+            if (entry.action.action !== "send_input" || !entry.success)
+                continue;
+            const sid = actionSession(entry.action);
+            const title = sid ? (sessionTitleMap.get(sid) ?? sid) : undefined;
+            if (!title)
+                continue;
+            const task = taskManager.getTaskForSession(title);
+            if (!task || task.status !== "active")
+                continue;
+            const lastProgress = task.lastProgressAt ?? 0;
+            if (lastProgress > 0 && (now - lastProgress) > stuckThresholdMs) {
+                const paused = taskManager.recordStuckNudge(title, maxNudges);
+                if (paused) {
+                    const msg = `auto-paused '${title}' after ${task.stuckNudgeCount} stuck nudges`;
+                    if (tui)
+                        tui.log("system", msg);
+                    else
+                        log(msg);
+                    appendSupervisorEvent({ at: Date.now(), detail: `auto-pause: ${title}` });
+                }
+            }
+        }
+    }
     // fire lifecycle hooks for completed actions
     if (tui) {
         const hooks = tui.getLifecycleHooks();
@@ -4224,7 +4401,18 @@ async function showProgressDigest(since, asJson = false) {
         console.log("no tasks defined.");
         return;
     }
+    // enrich with live session status
+    const liveStatus = await probeLiveSessionStatus();
+    const liveCount = liveStatus.size;
+    const missingFromTasks = [...liveStatus.keys()].filter((title) => !tasks.some((t) => t.sessionTitle.toLowerCase() === title));
     console.log("");
+    if (liveCount > 0) {
+        console.log(`  ${DIM}live sessions: ${liveCount} (${[...liveStatus.entries()].map(([t, s]) => `${t}=${s}`).join(", ")})${RESET}`);
+        if (missingFromTasks.length > 0) {
+            console.log(`  ${YELLOW}untracked sessions: ${missingFromTasks.join(", ")} — use /task <name> :: <goal> to adopt${RESET}`);
+        }
+        console.log("");
+    }
     console.log(formatProgressDigest(tasks, maxAgeMs));
 }
 // `aoaoe history` -- review recent actions from the persistent action log

package/dist/input.js

@@ -709,6 +709,10 @@ ${BOLD}navigation:${RESET}
   /sort [mode]       sort sessions: status, name, activity, default (or cycle)
   /compact           toggle compact mode (dense session panel)
   /pin [N|name]      pin/unpin a session to the top (toggle)
+  /pin-save <name>   save current pins as a named preset
+  /pin-load <name>   restore a saved pin preset
+  /pin-delete <name> delete a saved preset
+  /pin-presets       list saved pin presets
   /bell              toggle terminal bell on errors/completions
   /focus             toggle focus mode (show only pinned sessions)
   /mute [N|name]     mute/unmute a session's activity entries (toggle)
@@ -797,6 +801,8 @@ ${BOLD}navigation:${RESET}
 ${BOLD}info:${RESET}
   /status            show daemon state
   /progress [opts]   what each session accomplished recently; opts: --since <1h|8h|24h> --json
+  /health            session health scores (0-100 per task, fleet average)
+  /prompt-template [name] set/show reasoner prompt strategy (default, hands-off, aggressive, review-focused, shipping)
   /incident [opts]   quick incident view; opts: --since <30m|2h|1d> --limit N --json --ndjson --follow (watch via CLI)
   /runbook [section] show operator playbook (opts: quickstart|response-flow|incident|all, --json)
   /supervisor [opts] show judge/orchestrator status; opts: --all --since <1h|30m|2d> --limit N --json
@@ -994,6 +1000,24 @@ ${BOLD}other:${RESET}
                 }
                 break;
             }
+            case "/pin-save":
+                this.queue.push(`__CMD_PIN_SAVE__${line.slice("/pin-save".length)}`);
+                break;
+            case "/pin-load":
+                this.queue.push(`__CMD_PIN_LOAD__${line.slice("/pin-load".length)}`);
+                break;
+            case "/pin-delete":
+                this.queue.push(`__CMD_PIN_DELETE__${line.slice("/pin-delete".length)}`);
+                break;
+            case "/pin-presets":
+                this.queue.push("__CMD_PIN_PRESETS__");
+                break;
+            case "/prompt-template":
+                this.queue.push(`__CMD_PROMPT_TEMPLATE__${line.slice("/prompt-template".length)}`);
+                break;
+            case "/health":
+                this.queue.push("__CMD_HEALTH__");
+                break;
             case "/bell":
                 if (this.bellHandler) {
                     this.bellHandler();

package/dist/pin-presets.d.ts

@@ -0,0 +1,10 @@
+export interface PinPresets {
+    [name: string]: string[];
+}
+export declare function loadPinPresets(filePath?: string): PinPresets;
+export declare function savePinPresets(presets: PinPresets, filePath?: string): void;
+export declare function savePreset(name: string, titles: string[], filePath?: string): void;
+export declare function deletePreset(name: string, filePath?: string): boolean;
+export declare function getPreset(name: string, filePath?: string): string[] | undefined;
+export declare function formatPresetList(filePath?: string): string;
+//# sourceMappingURL=pin-presets.d.ts.map

package/dist/pin-presets.js

@@ -0,0 +1,72 @@
+// pin-presets.ts — save/restore named sets of pinned session titles.
+// stored in ~/.aoaoe/pin-presets.json as { presetName: ["title1", "title2"] }.
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { BOLD, DIM, GREEN, RESET } from "./colors.js";
+const AOAOE_DIR = join(homedir(), ".aoaoe");
+const PRESETS_FILE = join(AOAOE_DIR, "pin-presets.json");
+export function loadPinPresets(filePath = PRESETS_FILE) {
+    try {
+        if (!existsSync(filePath))
+            return {};
+        const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return {};
+        const result = {};
+        for (const [k, v] of Object.entries(raw)) {
+            if (Array.isArray(v) && v.every((s) => typeof s === "string")) {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+export function savePinPresets(presets, filePath = PRESETS_FILE) {
+    try {
+        if (!existsSync(AOAOE_DIR))
+            mkdirSync(AOAOE_DIR, { recursive: true });
+        writeFileSync(filePath, JSON.stringify(presets, null, 2) + "\n");
+    }
+    catch (e) {
+        console.error(`failed to save pin presets: ${e}`);
+    }
+}
+export function savePreset(name, titles, filePath = PRESETS_FILE) {
+    const presets = loadPinPresets(filePath);
+    presets[name] = titles;
+    savePinPresets(presets, filePath);
+}
+export function deletePreset(name, filePath = PRESETS_FILE) {
+    const presets = loadPinPresets(filePath);
+    if (!(name in presets))
+        return false;
+    delete presets[name];
+    savePinPresets(presets, filePath);
+    return true;
+}
+export function getPreset(name, filePath = PRESETS_FILE) {
+    const presets = loadPinPresets(filePath);
+    const lower = name.toLowerCase();
+    const key = Object.keys(presets).find((k) => k.toLowerCase() === lower);
+    return key ? presets[key] : undefined;
+}
+export function formatPresetList(filePath = PRESETS_FILE) {
+    const presets = loadPinPresets(filePath);
+    const names = Object.keys(presets);
+    if (names.length === 0)
+        return `  ${DIM}(no saved presets)${RESET}\n  ${DIM}save: /pin-save <name>${RESET}`;
+    const lines = [];
+    lines.push(`  ${BOLD}saved pin presets:${RESET}`);
+    for (const name of names) {
+        const titles = presets[name];
+        lines.push(`  ${GREEN}${name}${RESET} — ${titles.join(", ")} ${DIM}(${titles.length} sessions)${RESET}`);
+    }
+    lines.push("");
+    lines.push(`  ${DIM}restore: /pin-load <name>  |  delete: /pin-delete <name>${RESET}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=pin-presets.js.map

package/dist/reasoner/claude-code.js

@@ -9,7 +9,7 @@ export class ClaudeCodeReasoner {
     sessionId = null;
     constructor(config, globalContext) {
         this.config = config;
-        this.systemPrompt = buildSystemPrompt(globalContext);
+        this.systemPrompt = buildSystemPrompt(globalContext, config.promptTemplate);
     }
     async init() {
         // verify claude is available

package/dist/reasoner/opencode.js

@@ -20,7 +20,7 @@ export class OpencodeReasoner {
     static MAX_SESSION_MESSAGES = 7;
     constructor(config, globalContext) {
         this.config = config;
-        this.systemPrompt = buildSystemPrompt(globalContext);
+        this.systemPrompt = buildSystemPrompt(globalContext, config.promptTemplate);
     }
     async init() {
         // try to connect to existing opencode server first, then start one

package/dist/reasoner/prompt-templates.d.ts

@@ -0,0 +1,10 @@
+export interface PromptTemplate {
+    name: string;
+    description: string;
+    preamble: string;
+}
+export declare function getAllPromptTemplates(): PromptTemplate[];
+export declare function resolvePromptTemplate(name: string): PromptTemplate | undefined;
+export declare function applyPromptTemplate(basePrompt: string, templateName: string): string;
+export declare function formatPromptTemplateList(): string;
+//# sourceMappingURL=prompt-templates.d.ts.map

package/dist/reasoner/prompt-templates.js

@@ -0,0 +1,111 @@
+// prompt-templates.ts — named system prompt strategies for the reasoner.
+// the active template is set via config or /prompt-template command.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { BOLD, DIM, GREEN, RESET } from "../colors.js";
+const BUILTIN_TEMPLATES = [
+    {
+        name: "default",
+        description: "balanced supervisor — intervene only when needed",
+        preamble: "",
+    },
+    {
+        name: "hands-off",
+        description: "minimal intervention — only act on errors and permission prompts",
+        preamble: `IMPORTANT OVERRIDE: You are in hands-off mode. Be extremely conservative with interventions.
+- Only send_input when a session has an ERROR or a PERMISSION prompt that needs clearing.
+- Do NOT nudge idle sessions — they may be thinking or compiling.
+- Do NOT send motivational or progress-check messages.
+- Prefer "wait" in almost all cases. Let agents work autonomously.
+`,
+    },
+    {
+        name: "aggressive",
+        description: "proactive supervisor — nudge idle agents, push for progress",
+        preamble: `IMPORTANT OVERRIDE: You are in aggressive supervision mode. Be proactive.
+- If a session has been idle for more than 60 seconds, nudge it with a prompt.
+- If a session seems to be going in circles, redirect it with clearer instructions.
+- Report progress frequently — every meaningful commit or test pass.
+- Push agents toward completing their goals. Don't let them drift.
+- Still avoid micromanaging specific code decisions.
+`,
+    },
+    {
+        name: "review-focused",
+        description: "PR/MR review cycle — focus on CI, reviewer feedback, rebasing",
+        preamble: `IMPORTANT OVERRIDE: You are in review-focused mode. Prioritize PR/MR lifecycle.
+- Watch for CI pipeline failures and push fixes immediately.
+- Monitor for reviewer comments and address them promptly.
+- If a PR is approved, push to merge. If blocked, ping the reviewer.
+- Prefer rebasing over merge commits. Keep commit history clean.
+- Report progress for each PR status change (CI green, review received, merged).
+`,
+    },
+    {
+        name: "shipping",
+        description: "ship mode — focus on commits, pushes, and version bumps",
+        preamble: `IMPORTANT OVERRIDE: You are in shipping mode. Focus on getting code out the door.
+- Push agents to commit and push frequently. Small atomic commits are better than big batches.
+- If an agent has uncommitted work, nudge them to commit.
+- Report progress for every push/commit.
+- Don't let perfect be the enemy of good — ship working code, iterate later.
+- Complete tasks as soon as their core goal is met. Don't gold-plate.
+`,
+    },
+];
+const AOAOE_DIR = join(homedir(), ".aoaoe");
+const USER_TEMPLATES_FILE = join(AOAOE_DIR, "prompt-templates.json");
+function loadUserTemplates() {
+    try {
+        if (!existsSync(USER_TEMPLATES_FILE))
+            return [];
+        const raw = JSON.parse(readFileSync(USER_TEMPLATES_FILE, "utf-8"));
+        if (!Array.isArray(raw))
+            return [];
+        return raw.filter((t) => !!t && typeof t === "object" &&
+            typeof t.name === "string" &&
+            typeof t.preamble === "string").map((t) => ({
+            ...t,
+            description: t.description || "(user-defined)",
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export function getAllPromptTemplates() {
+    const user = loadUserTemplates();
+    const userNames = new Set(user.map((t) => t.name.toLowerCase()));
+    const builtins = BUILTIN_TEMPLATES.filter((t) => !userNames.has(t.name.toLowerCase()));
+    return [...builtins, ...user];
+}
+export function resolvePromptTemplate(name) {
+    const templates = getAllPromptTemplates();
+    const lower = name.toLowerCase();
+    return (templates.find((t) => t.name.toLowerCase() === lower) ??
+        templates.find((t) => t.name.toLowerCase().startsWith(lower)));
+}
+export function applyPromptTemplate(basePrompt, templateName) {
+    if (!templateName || templateName === "default")
+        return basePrompt;
+    const template = resolvePromptTemplate(templateName);
+    if (!template || !template.preamble)
+        return basePrompt;
+    return `${template.preamble}\n${basePrompt}`;
+}
+export function formatPromptTemplateList() {
+    const templates = getAllPromptTemplates();
+    const lines = [];
+    lines.push(`  ${BOLD}available prompt templates:${RESET}`);
+    lines.push("");
+    for (const t of templates) {
+        const preview = t.preamble ? t.preamble.split("\n")[0].slice(0, 60) : "(no preamble — base prompt only)";
+        lines.push(`  ${GREEN}${t.name}${RESET} — ${t.description}`);
+        lines.push(`  ${DIM}  ${preview}${t.preamble.length > 60 ? "..." : ""}${RESET}`);
+        lines.push("");
+    }
+    lines.push(`  ${DIM}custom templates: ${USER_TEMPLATES_FILE}${RESET}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=prompt-templates.js.map

package/dist/reasoner/prompt.d.ts

@@ -1,5 +1,5 @@
 import type { Observation, TaskState } from "../types.js";
-export declare function buildSystemPrompt(globalContext?: string): string;
+export declare function buildSystemPrompt(globalContext?: string, promptTemplate?: string): string;
 export interface SessionPolicyState {
     sessionId: string;
     lastOutputChangeAt: number;

package/dist/reasoner/prompt.js

@@ -1,4 +1,5 @@
 import { goalToList } from "../types.js";
+import { applyPromptTemplate } from "./prompt-templates.js";
 // base system prompt -- global context appended at runtime via buildSystemPrompt()
 const BASE_SYSTEM_PROMPT = `You are a supervisor managing multiple AI coding agents in an agent-of-empires (AoE) tmux session.
 
@@ -43,10 +44,11 @@ Rules:
 - Use "complete_task" when a task's goal has been fully achieved and the agent has nothing left to do.
   This will clean up the session. Only use when truly done, not just idle.`;
 // build the full system prompt with global context appended
-export function buildSystemPrompt(globalContext) {
+export function buildSystemPrompt(globalContext, promptTemplate) {
+    const base = applyPromptTemplate(BASE_SYSTEM_PROMPT, promptTemplate ?? "default");
     if (!globalContext)
-        return BASE_SYSTEM_PROMPT;
-    return `${BASE_SYSTEM_PROMPT}\n${globalContext}`;
+        return base;
+    return `${base}\n${globalContext}`;
 }
 // detect permission prompts in tmux output.
 // the prompt-watcher module (prompt-watcher.ts) handles these reactively via

package/dist/task-cli.js

@@ -8,6 +8,7 @@ import { loadConfig } from "./config.js";
 import { resolveProfiles } from "./tui.js";
 import { loadTaskState, saveTaskState, formatTaskTable, syncTaskDefinitionsFromState, taskStateKey, resolveTaskRepoPath, TaskManager, loadTaskDefinitions, injectGoalToSession } from "./task-manager.js";
 import { goalToList } from "./types.js";
+import { resolveTemplate, formatTemplateList } from "./task-templates.js";
 import { BOLD, DIM, GREEN, YELLOW, RED, RESET } from "./colors.js";
 function buildProfileAwareAoeArgs(profile, tailArgs) {
     if (!profile || profile === "default")
@@ -25,9 +26,15 @@ function getTaskProfiles() {
 function taskCommandHelp(prefix = "aoaoe task") {
     return [
         `${prefix} list                     show tracked tasks`,
+        `${prefix} templates                show available task templates`,
         `${prefix} reconcile                link/create sessions now`,
         `${prefix} new <title> <path>       create task + session`,
+        `${prefix} new <t> <p> --template roadmap  create with template goal`,
         `${prefix} start|stop <task>         control task session`,
+        `${prefix} start-all                 start all paused/pending tasks`,
+        `${prefix} stop-all                  stop all active tasks`,
+        `${prefix} pause-all                 pause all active tasks (no session stop)`,
+        `${prefix} resume-all                resume all paused tasks`,
         `${prefix} edit <task> <goal>        update task goal`,
         `${prefix} rm <task>                 remove task + session`,
         "step-in quick path: /task <session> :: <new instructions>",
@@ -331,6 +338,67 @@ export async function runTaskCli(argv) {
             await taskStop(args[0]);
             return;
         }
+        case "start-all": {
+            const states = loadTaskState();
+            const tasks = [...states.values()].filter((t) => t.status === "paused" || t.status === "pending");
+            if (tasks.length === 0) {
+                console.log(`${DIM}no paused/pending tasks to start${RESET}`);
+                return;
+            }
+            for (const t of tasks)
+                await taskStart(t.sessionTitle);
+            console.log(`${GREEN}started ${tasks.length} task(s)${RESET}`);
+            return;
+        }
+        case "stop-all": {
+            const states = loadTaskState();
+            const tasks = [...states.values()].filter((t) => t.status === "active");
+            if (tasks.length === 0) {
+                console.log(`${DIM}no active tasks to stop${RESET}`);
+                return;
+            }
+            for (const t of tasks)
+                await taskStop(t.sessionTitle);
+            console.log(`${YELLOW}stopped ${tasks.length} task(s)${RESET}`);
+            return;
+        }
+        case "pause-all": {
+            const states = loadTaskState();
+            let count = 0;
+            for (const [key, t] of states) {
+                if (t.status === "active") {
+                    t.status = "paused";
+                    states.set(key, t);
+                    count++;
+                }
+            }
+            if (count === 0) {
+                console.log(`${DIM}no active tasks to pause${RESET}`);
+                return;
+            }
+            saveTaskState(states);
+            console.log(`${YELLOW}paused ${count} task(s)${RESET}`);
+            return;
+        }
+        case "resume-all": {
+            const states = loadTaskState();
+            let count = 0;
+            for (const [key, t] of states) {
+                if (t.status === "paused") {
+                    t.status = "active";
+                    t.stuckNudgeCount = 0;
+                    states.set(key, t);
+                    count++;
+                }
+            }
+            if (count === 0) {
+                console.log(`${DIM}no paused tasks to resume${RESET}`);
+                return;
+            }
+            saveTaskState(states);
+            console.log(`${GREEN}resumed ${count} task(s)${RESET}`);
+            return;
+        }
         case "edit": {
             if (!args[0] || !args[1]) {
                 console.error(`usage: aoaoe task edit <name|id> <new goal text>`);
@@ -343,7 +411,7 @@ export async function runTaskCli(argv) {
         case "create":
         case "add": {
             if (!args[0] || !args[1]) {
-                console.error(`usage: aoaoe task new <title> <path> [--tool opencode] [--mode new|existing|auto]`);
+                console.error(`usage: aoaoe task new <title> <path> [--template roadmap] [--tool opencode] [--mode new|existing|auto]`);
                 return;
             }
             const title = args[0];
@@ -360,7 +428,30 @@ export async function runTaskCli(argv) {
             const profileIdx = args.indexOf("--profile");
             if (profileIdx !== -1 && args[profileIdx + 1])
                 profile = args[profileIdx + 1];
-            await taskNew(title, path, tool, mode, profile);
+            // apply template if specified
+            const templateIdx = args.indexOf("--template");
+            let templateGoal;
+            if (templateIdx !== -1 && args[templateIdx + 1]) {
+                const tmpl = resolveTemplate(args[templateIdx + 1]);
+                if (!tmpl) {
+                    console.error(`${RED}unknown template: ${args[templateIdx + 1]}${RESET}`);
+                    console.log(formatTemplateList());
+                    return;
+                }
+                templateGoal = tmpl.goal;
+                if (tmpl.tool)
+                    tool = tmpl.tool;
+                console.log(`${DIM}using template: ${tmpl.name}${RESET}`);
+            }
+            const ok = await taskNew(title, path, tool, mode, profile);
+            if (ok && templateGoal) {
+                await taskEdit(title, templateGoal);
+            }
+            return;
+        }
+        case "templates":
+        case "template": {
+            console.log(formatTemplateList());
             return;
         }
         case "reconcile": {
@@ -383,7 +474,7 @@ export async function runTaskCli(argv) {
         }
         default:
             console.error(`unknown task subcommand: ${sub}`);
-            console.error(`usage: aoaoe task [list|start|stop|edit|new|rm|reconcile|help]`);
+            console.error(`usage: aoaoe task [list|start|stop|edit|new|rm|reconcile|templates|help]`);
     }
 }
 /**
@@ -529,6 +620,9 @@ export async function handleTaskSlashCommand(args) {
         const { created, linked, goalsInjected } = await tm.reconcileSessions();
         return `reconciled tasks: +${created.length} created, +${linked.length} linked, +${goalsInjected.length} goals injected`;
     }
-    return "usage: /task [list|start|stop|edit|new|rm|reconcile|help] [args]";
+    if (sub === "templates" || sub === "template") {
+        return formatTemplateList();
+    }
+    return "usage: /task [list|start|stop|edit|new|rm|reconcile|templates|help] [args]";
 }
 //# sourceMappingURL=task-cli.js.map

package/dist/task-manager.d.ts

@@ -31,6 +31,7 @@ export declare class TaskManager {
         goalsInjected: string[];
     }>;
     reportProgress(sessionTitle: string, summary: string): void;
+    recordStuckNudge(sessionTitle: string, maxNudges: number): boolean;
     completeTask(sessionTitle: string, summary: string, cleanupSession?: boolean): Promise<void>;
     private save;
 }

package/dist/task-manager.js

@@ -460,12 +460,28 @@ export class TaskManager {
         const entry = { at: Date.now(), summary };
         task.progress.push(entry);
         task.lastProgressAt = Date.now();
+        task.stuckNudgeCount = 0; // progress means it's not stuck anymore
         // keep progress bounded (last 50 entries)
         if (task.progress.length > 50) {
             task.progress = task.progress.slice(-50);
         }
         this.save();
     }
+    // record that the reasoner nudged a stuck session. returns true if the task should be auto-paused.
+    recordStuckNudge(sessionTitle, maxNudges) {
+        const task = this.getTaskForSession(sessionTitle);
+        if (!task || task.status !== "active")
+            return false;
+        task.stuckNudgeCount = (task.stuckNudgeCount ?? 0) + 1;
+        if (maxNudges > 0 && task.stuckNudgeCount >= maxNudges) {
+            task.status = "paused";
+            log(`auto-paused '${sessionTitle}' after ${task.stuckNudgeCount} stuck nudges (threshold: ${maxNudges})`);
+            this.save();
+            return true;
+        }
+        this.save();
+        return false;
+    }
     // mark a task as completed, optionally clean up its session.
     // if the task definition has continueOnRoadmap:true, resets with next backlog items instead.
     async completeTask(sessionTitle, summary, cleanupSession = true) {

package/dist/task-templates.d.ts

@@ -0,0 +1,11 @@
+export interface TaskTemplate {
+    name: string;
+    description: string;
+    goal: string;
+    tool?: string;
+    continueOnRoadmap?: boolean;
+}
+export declare function getAllTemplates(): TaskTemplate[];
+export declare function resolveTemplate(name: string): TaskTemplate | undefined;
+export declare function formatTemplateList(): string;
+//# sourceMappingURL=task-templates.d.ts.map

package/dist/task-templates.js

@@ -0,0 +1,96 @@
+// task-templates.ts — built-in + user-defined task goal templates.
+// templates are just named goal strings that can be applied via --template flag.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { BOLD, DIM, GREEN, RESET } from "./colors.js";
+// built-in templates derived from real usage patterns
+const BUILTIN_TEMPLATES = [
+    {
+        name: "roadmap",
+        description: "grind through claude.md/AGENTS.md roadmap items, commit each improvement",
+        goal: "Find the roadmap (check claude.md, README.md, AGENTS.md). Pick the next item and implement it. Add new ideas to the roadmap as you or the human think of them. Commit and push after each self-contained improvement.",
+        continueOnRoadmap: true,
+    },
+    {
+        name: "roadmap-strict",
+        description: "roadmap grind with full tests required before push",
+        goal: "Find the roadmap (check claude.md, README.md, AGENTS.md). Pick the next item and implement it with full tests. Add new ideas to the roadmap as you or the human think of them. Commit and push after each self-contained improvement.",
+        continueOnRoadmap: true,
+    },
+    {
+        name: "pr-review",
+        description: "monitor open PRs/MRs, address review feedback, push fixes, ping reviewers",
+        goal: "Check for open PRs/MRs in this repo. Address any review feedback by pushing fixes. Monitor CI pipelines and fix failures. Ping reviewers when changes are ready for re-review. Update claude.md with PR status.",
+    },
+    {
+        name: "bugfix",
+        description: "reproduce, fix, test, and commit a specific bug",
+        goal: "Investigate the reported bug. Reproduce it with a minimal test case. Fix the root cause. Add regression tests. Commit and push the fix.",
+    },
+    {
+        name: "explore",
+        description: "read and understand the codebase, update claude.md with findings",
+        goal: "Explore the codebase. Read AGENTS.md and claude.md for context. Understand the architecture, key modules, and current state. Update claude.md with your findings and any issues you discover.",
+    },
+    {
+        name: "ci-fix",
+        description: "fix failing CI pipelines — build errors, test failures, flaky tests",
+        goal: "Check CI pipeline status. Fix any build errors, test failures, or flaky tests. Push fixes and verify pipelines go green. Add retry config for transient infra failures if needed.",
+    },
+];
+const AOAOE_DIR = join(homedir(), ".aoaoe");
+const USER_TEMPLATES_FILE = join(AOAOE_DIR, "templates.json");
+// load user-defined templates from ~/.aoaoe/templates.json (optional)
+function loadUserTemplates() {
+    try {
+        if (!existsSync(USER_TEMPLATES_FILE))
+            return [];
+        const raw = JSON.parse(readFileSync(USER_TEMPLATES_FILE, "utf-8"));
+        if (!Array.isArray(raw))
+            return [];
+        return raw.filter((t) => !!t && typeof t === "object" &&
+            typeof t.name === "string" &&
+            typeof t.goal === "string").map((t) => ({
+            ...t,
+            description: t.description || "(user-defined)",
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// get all templates — user templates override builtins with the same name
+export function getAllTemplates() {
+    const user = loadUserTemplates();
+    const userNames = new Set(user.map((t) => t.name.toLowerCase()));
+    const builtins = BUILTIN_TEMPLATES.filter((t) => !userNames.has(t.name.toLowerCase()));
+    return [...builtins, ...user];
+}
+// resolve a template by name (case-insensitive, prefix match)
+export function resolveTemplate(name) {
+    const templates = getAllTemplates();
+    const lower = name.toLowerCase();
+    return (templates.find((t) => t.name.toLowerCase() === lower) ??
+        templates.find((t) => t.name.toLowerCase().startsWith(lower)));
+}
+// format template list for display
+export function formatTemplateList() {
+    const templates = getAllTemplates();
+    const lines = [];
+    lines.push(`  ${BOLD}available task templates:${RESET}`);
+    lines.push("");
+    for (const t of templates) {
+        const goalPreview = t.goal.length > 70 ? t.goal.slice(0, 67) + "..." : t.goal;
+        lines.push(`  ${GREEN}${t.name}${RESET} — ${t.description}`);
+        lines.push(`  ${DIM}  goal: ${goalPreview}${RESET}`);
+        if (t.tool)
+            lines.push(`  ${DIM}  tool: ${t.tool}${RESET}`);
+        if (t.continueOnRoadmap)
+            lines.push(`  ${DIM}  continueOnRoadmap: true${RESET}`);
+        lines.push("");
+    }
+    lines.push(`  ${DIM}custom templates: ${USER_TEMPLATES_FILE}${RESET}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=task-templates.js.map

package/dist/tui.d.ts

@@ -579,6 +579,10 @@ export declare class TUI {
     isPinned(id: string): boolean;
     /** Return count of pinned sessions. */
     getPinnedCount(): number;
+    /** Return titles of all pinned sessions. */
+    getPinnedTitles(): string[];
+    /** Load a pin preset: clear current pins, pin sessions matching given titles. Returns count pinned. */
+    loadPinPreset(titles: string[]): number;
     /** Enable or disable focus mode. When focused, only pinned sessions are visible. */
     setFocus(enabled: boolean): void;
     /** Return whether focus mode is enabled. */

package/dist/tui.js

@@ -971,6 +971,8 @@ export const BUILTIN_COMMANDS = new Set([
     "/supervisor",
     "/runbook",
     "/incident",
+    "/pin-save", "/pin-load", "/pin-delete", "/pin-presets",
+    "/prompt-template", "/health",
     "/explain", "/verbose", "/clear", "/view", "/back", "/sort", "/compact",
     "/pin", "/bell", "/focus", "/mute", "/unmute-all", "/filter", "/who",
     "/uptime", "/auto-pin", "/note", "/notes", "/clip", "/diff", "/mark",
@@ -1442,6 +1444,26 @@ export class TUI {
     getPinnedCount() {
         return this.pinnedIds.size;
     }
+    /** Return titles of all pinned sessions. */
+    getPinnedTitles() {
+        return this.sessions.filter((s) => this.pinnedIds.has(s.id)).map((s) => s.title);
+    }
+    /** Load a pin preset: clear current pins, pin sessions matching given titles. Returns count pinned. */
+    loadPinPreset(titles) {
+        this.pinnedIds.clear();
+        const lowerTitles = new Set(titles.map((t) => t.toLowerCase()));
+        let count = 0;
+        for (const s of this.sessions) {
+            if (lowerTitles.has(s.title.toLowerCase())) {
+                this.pinnedIds.add(s.id);
+                count++;
+            }
+        }
+        this.sessions = sortSessions(this.sessions, this.sortMode, this.lastChangeAt, this.pinnedIds);
+        if (this.active)
+            this.paintAll();
+        return count;
+    }
     /** Enable or disable focus mode. When focused, only pinned sessions are visible. */
     setFocus(enabled) {
         if (enabled === this.focusMode)

package/dist/types.d.ts

@@ -111,12 +111,14 @@ export interface AoaoeConfig {
         actionCooldownMs?: number;
         userActivityThresholdMs?: number;
         allowDestructive?: boolean;
+        maxStuckNudgesBeforePause?: number;
     };
     contextFiles: string[];
     sessionDirs: Record<string, string>;
     protectedSessions: string[];
     captureLinesCount: number;
     reasonIntervalMs: number;
+    promptTemplate?: string;
     verbose: boolean;
     dryRun: boolean;
     observe: boolean;
@@ -200,6 +202,7 @@ export interface TaskState {
     createdAt?: number;
     lastProgressAt?: number;
     completedAt?: number;
+    stuckNudgeCount?: number;
     progress: TaskProgress[];
 }
 export declare function toTaskState(raw: unknown): TaskState | null;

package/dist/types.js

@@ -91,6 +91,7 @@ export function toTaskState(raw) {
         goal: r.goal,
         status: r.status,
         dependsOn: Array.isArray(r.dependsOn) ? r.dependsOn.filter((d) => typeof d === "string" && d.length > 0) : undefined,
+        stuckNudgeCount: typeof r.stuckNudgeCount === "number" ? r.stuckNudgeCount : undefined,
         sessionId: typeof r.sessionId === "string" ? r.sessionId : undefined,
         createdAt: typeof r.createdAt === "number" ? r.createdAt : undefined,
         lastProgressAt: typeof r.lastProgressAt === "number" ? r.lastProgressAt : undefined,

package/package.json

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