aoaoe 2.5.0 → 3.0.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-3332-brightgreen" alt="tests">
+    <img src="https://img.shields.io/badge/tests-3491-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>

package/dist/cost-allocation-tags.d.ts

@@ -0,0 +1,30 @@
+export interface CostTag {
+    key: string;
+    value: string;
+}
+export interface TaggedSession {
+    sessionTitle: string;
+    tags: CostTag[];
+    costUsd: number;
+}
+export interface TagReport {
+    tagKey: string;
+    groups: Array<{
+        value: string;
+        sessions: number;
+        totalCostUsd: number;
+    }>;
+}
+/**
+ * Group sessions by a tag key and sum costs.
+ */
+export declare function groupByTag(sessions: TaggedSession[], tagKey: string): TagReport;
+/**
+ * Format tag report for TUI display.
+ */
+export declare function formatTagReport(report: TagReport): string[];
+/**
+ * Parse tags from a config string: "team=platform,project=aoaoe"
+ */
+export declare function parseTags(tagStr: string): CostTag[];
+//# sourceMappingURL=cost-allocation-tags.d.ts.map

package/dist/cost-allocation-tags.js

@@ -0,0 +1,47 @@
+// cost-allocation-tags.ts — label sessions by team/project for cost attribution.
+// tags are key-value pairs attached to sessions, used to group costs in reports.
+/**
+ * Group sessions by a tag key and sum costs.
+ */
+export function groupByTag(sessions, tagKey) {
+    const groups = new Map();
+    for (const s of sessions) {
+        const tag = s.tags.find((t) => t.key === tagKey);
+        const value = tag?.value ?? "(untagged)";
+        const group = groups.get(value) ?? { sessions: 0, totalCostUsd: 0 };
+        group.sessions++;
+        group.totalCostUsd += s.costUsd;
+        groups.set(value, group);
+    }
+    return {
+        tagKey,
+        groups: [...groups.entries()]
+            .map(([value, g]) => ({ value, ...g }))
+            .sort((a, b) => b.totalCostUsd - a.totalCostUsd),
+    };
+}
+/**
+ * Format tag report for TUI display.
+ */
+export function formatTagReport(report) {
+    if (report.groups.length === 0)
+        return [`  (no sessions tagged with "${report.tagKey}")`];
+    const lines = [];
+    lines.push(`  Cost by ${report.tagKey}:`);
+    for (const g of report.groups) {
+        lines.push(`  ${g.value.padEnd(20)} ${g.sessions} session${g.sessions !== 1 ? "s" : ""}  $${g.totalCostUsd.toFixed(2)}`);
+    }
+    return lines;
+}
+/**
+ * Parse tags from a config string: "team=platform,project=aoaoe"
+ */
+export function parseTags(tagStr) {
+    if (!tagStr)
+        return [];
+    return tagStr.split(",").map((pair) => {
+        const [key, ...rest] = pair.split("=");
+        return { key: key.trim(), value: rest.join("=").trim() };
+    }).filter((t) => t.key && t.value);
+}
+//# sourceMappingURL=cost-allocation-tags.js.map

package/dist/goal-similarity.d.ts

@@ -0,0 +1,20 @@
+import type { TaskState } from "./types.js";
+export interface SimilarityPair {
+    titleA: string;
+    titleB: string;
+    similarity: number;
+    sharedKeywords: string[];
+}
+/**
+ * Compute Jaccard similarity between two keyword sets.
+ */
+export declare function jaccardSimilarity(setA: Set<string>, setB: Set<string>): number;
+/**
+ * Find pairs of tasks with similar goals.
+ */
+export declare function findSimilarGoals(tasks: readonly TaskState[], threshold?: number): SimilarityPair[];
+/**
+ * Format similarity pairs for TUI display.
+ */
+export declare function formatSimilarGoals(pairs: SimilarityPair[]): string[];
+//# sourceMappingURL=goal-similarity.d.ts.map

package/dist/goal-similarity.js

@@ -0,0 +1,55 @@
+// goal-similarity.ts — detect sessions with overlapping goals for coordination.
+// uses Jaccard similarity on keyword sets to find related tasks.
+import { extractKeywords } from "./drift-detector.js";
+/**
+ * Compute Jaccard similarity between two keyword sets.
+ */
+export function jaccardSimilarity(setA, setB) {
+    if (setA.size === 0 && setB.size === 0)
+        return 0;
+    let intersection = 0;
+    for (const w of setA)
+        if (setB.has(w))
+            intersection++;
+    const union = setA.size + setB.size - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Find pairs of tasks with similar goals.
+ */
+export function findSimilarGoals(tasks, threshold = 0.3) {
+    const keywordSets = tasks.map((t) => ({
+        title: t.sessionTitle,
+        keywords: new Set(extractKeywords(t.goal)),
+    }));
+    const pairs = [];
+    for (let i = 0; i < keywordSets.length; i++) {
+        for (let j = i + 1; j < keywordSets.length; j++) {
+            const sim = jaccardSimilarity(keywordSets[i].keywords, keywordSets[j].keywords);
+            if (sim >= threshold) {
+                const shared = [...keywordSets[i].keywords].filter((w) => keywordSets[j].keywords.has(w));
+                pairs.push({
+                    titleA: keywordSets[i].title,
+                    titleB: keywordSets[j].title,
+                    similarity: Math.round(sim * 100) / 100,
+                    sharedKeywords: shared,
+                });
+            }
+        }
+    }
+    return pairs.sort((a, b) => b.similarity - a.similarity);
+}
+/**
+ * Format similarity pairs for TUI display.
+ */
+export function formatSimilarGoals(pairs) {
+    if (pairs.length === 0)
+        return ["  (no similar goals detected)"];
+    const lines = [];
+    lines.push(`  Similar goals (${pairs.length} pair${pairs.length !== 1 ? "s" : ""}):`);
+    for (const p of pairs) {
+        lines.push(`  ${Math.round(p.similarity * 100)}% — "${p.titleA}" ↔ "${p.titleB}" [${p.sharedKeywords.join(", ")}]`);
+    }
+    return lines;
+}
+//# sourceMappingURL=goal-similarity.js.map

package/dist/index.js

@@ -76,6 +76,13 @@ import { defaultAlertRules, evaluateAlertRules, formatAlertRules } from "./alert
 import { forecastHealth, formatHealthForecast } from "./health-forecast.js";
 import { tailSession, formatTail, parseTailArgs } from "./session-tail.js";
 import { renderWorkflowDag, renderChainDag } from "./workflow-viz.js";
+import { formatPrometheusMetrics, buildMetricsSnapshot } from "./metrics-export.js";
+import { grepArchives, formatGrepResult } from "./fleet-grep.js";
+import { createExecution, advanceExecution, formatExecution } from "./runbook-executor.js";
+import { cloneSession, formatCloneResult } from "./session-clone.js";
+import { findSimilarGoals, formatSimilarGoals } from "./goal-similarity.js";
+import { groupByTag, formatTagReport, parseTags } from "./cost-allocation-tags.js";
+import { recommendScaling, formatScalingRecommendation } from "./predictive-scaling.js";
 import { buildLifecycleRecords, computeLifecycleStats, formatLifecycleStats } from "./lifecycle-analytics.js";
 import { buildCostAttributions, computeCostReport, formatCostReport } from "./cost-attribution.js";
 import { decomposeGoal, formatDecomposition } from "./goal-decomposer.js";
@@ -585,6 +592,7 @@ async function main() {
     const tokenQuotaManager = new TokenQuotaManager();
     const abReasoningTracker = new ABReasoningTracker(config.reasoner, "claude-code");
     const alertRules = defaultAlertRules();
+    let activeRunbookExec = null;
     // checkpoint restore: load previous daemon state if available
     if (shouldRestoreCheckpoint()) {
         const cp = loadCheckpoint();
@@ -2666,6 +2674,133 @@ async function main() {
                 tui.log("system", "workflow-viz: no active workflow or chain");
             }
         });
+        // wire /metrics — Prometheus metrics snapshot
+        input.onMetrics(() => {
+            const sessions = tui.getSessions();
+            const tasks = taskManager?.tasks ?? [];
+            const scores = sessions.map((s) => s.status === "working" || s.status === "running" ? 80 : s.status === "error" ? 20 : 50);
+            const health = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 100;
+            let cost = 0;
+            for (const s of sessions) {
+                const m = s.costStr?.match(/\$(\d+(?:\.\d+)?)/);
+                if (m)
+                    cost += parseFloat(m[1]);
+            }
+            const cacheStats = observationCache.getStats();
+            const reasonerStats = reasonerCostTracker.getSummary();
+            const nudgeReport = nudgeTracker.getReport();
+            const snapshot = buildMetricsSnapshot({
+                fleetHealth: health, totalSessions: sessions.length,
+                activeSessions: sessions.filter((s) => s.status === "working" || s.status === "running").length,
+                errorSessions: sessions.filter((s) => s.status === "error").length,
+                totalTasks: tasks.length, activeTasks: tasks.filter((t) => t.status === "active").length,
+                completedTasks: tasks.filter((t) => t.status === "completed").length,
+                failedTasks: tasks.filter((t) => t.status === "failed").length,
+                totalCostUsd: cost, reasonerCallsTotal: reasonerStats.totalCalls,
+                reasonerCostTotal: reasonerStats.totalCostUsd,
+                cacheHits: cacheStats.totalHits, cacheMisses: cacheStats.totalMisses,
+                nudgesSent: nudgeReport.totalNudges, nudgesEffective: nudgeReport.effectiveNudges,
+                pollIntervalMs: adaptivePollController.intervalMs,
+                uptimeMs: Date.now() - daemonStartedAt,
+            });
+            const text = formatPrometheusMetrics(snapshot);
+            for (const l of text.split("\n").filter(Boolean))
+                tui.log("system", l);
+        });
+        // wire /fleet-grep — search archived outputs
+        input.onFleetGrep((pattern) => {
+            const result = grepArchives(pattern);
+            const lines = formatGrepResult(result);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /runbook-exec — execute/advance runbook
+        input.onRunbookExec(() => {
+            if (!activeRunbookExec) {
+                const runbooks = generateRunbooks();
+                if (runbooks.length === 0) {
+                    tui.log("system", "runbook-exec: no runbooks to execute (need audit data)");
+                    return;
+                }
+                activeRunbookExec = createExecution(runbooks[0]);
+                tui.log("+ action", `runbook-exec: starting "${runbooks[0].title}"`);
+            }
+            const step = advanceExecution(activeRunbookExec);
+            if (step) {
+                tui.log("system", `runbook-exec: executing step — ${step.action}: ${step.detail}`);
+            }
+            else {
+                const lines = formatExecution(activeRunbookExec);
+                for (const l of lines)
+                    tui.log("system", l);
+                activeRunbookExec = null;
+            }
+        });
+        // wire /clone — clone a session
+        input.onClone((args) => {
+            const parts = args.split(/\s+/);
+            const [sourceTitle, cloneTitle, ...goalParts] = parts;
+            if (!sourceTitle || !cloneTitle) {
+                tui.log("system", "clone: usage: /clone <source> <new-name> [goal]");
+                return;
+            }
+            const tasks = taskManager?.tasks ?? [];
+            const source = tasks.find((t) => t.sessionTitle.toLowerCase() === sourceTitle.toLowerCase());
+            if (!source) {
+                tui.log("system", `clone: source "${sourceTitle}" not found`);
+                return;
+            }
+            const goalOverride = goalParts.length > 0 ? goalParts.join(" ") : undefined;
+            const def = cloneSession(source, { sourceTitle, cloneTitle, goalOverride });
+            tui.log("+ action", `cloned "${sourceTitle}" → "${cloneTitle}"`);
+            const lines = formatCloneResult({ original: sourceTitle, clone: cloneTitle, goal: def.goal, tool: def.tool ?? "opencode" });
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /similar-goals — find overlapping goals
+        input.onSimilarGoals(() => {
+            const tasks = taskManager?.tasks ?? [];
+            const pairs = findSimilarGoals(tasks);
+            const lines = formatSimilarGoals(pairs);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /cost-tags — group costs by tag
+        input.onCostTags((tagKey) => {
+            const tasks = taskManager?.tasks ?? [];
+            const sessions = tui.getSessions();
+            const tagged = tasks.map((t) => {
+                const s = sessions.find((s) => s.title === t.sessionTitle);
+                let cost = 0;
+                if (s?.costStr) {
+                    const m = s.costStr.match(/\$(\d+(?:\.\d+)?)/);
+                    if (m)
+                        cost = parseFloat(m[1]);
+                }
+                return { sessionTitle: t.sessionTitle, tags: parseTags(t.tags ?? ""), costUsd: cost };
+            });
+            const report = groupByTag(tagged, tagKey);
+            const lines = formatTagReport(report);
+            for (const l of lines)
+                tui.log("system", l);
+        });
+        // wire /scaling — predictive pool scaling
+        input.onScaling(() => {
+            const tasks = taskManager?.tasks ?? [];
+            const poolStatus = sessionPoolManager.getStatus(tasks);
+            const activeSessions = poolStatus.activeCount;
+            const pendingTasks = poolStatus.pendingCount;
+            const utilPct = poolStatus.maxConcurrent > 0 ? Math.round((activeSessions / poolStatus.maxConcurrent) * 100) : 0;
+            const rec = recommendScaling({
+                currentPoolSize: poolStatus.maxConcurrent,
+                activeSessions, pendingTasks,
+                recentUtilizationPct: utilPct, peakUtilizationPct: utilPct,
+                averageTaskDurationMs: 3_600_000,
+            });
+            const lines = formatScalingRecommendation(rec);
+            for (const l of lines)
+                tui.log("system", l);
+        });
         input.onCostSummary(() => {
             const sessions = tui.getSessions();
             const summary = computeCostSummary(sessions, tui.getAllSessionCosts());

package/dist/input.d.ts

@@ -148,6 +148,13 @@ export type AlertRulesHandler = () => void;
 export type SessionTailHandler = (args: string) => void;
 export type HealthForecastHandler = () => void;
 export type WorkflowVizHandler = () => void;
+export type MetricsHandler = () => void;
+export type FleetGrepHandler = (pattern: string) => void;
+export type RunbookExecHandler = () => void;
+export type CloneHandler = (args: string) => void;
+export type SimilarGoalsHandler = () => void;
+export type CostTagsHandler = (tagKey: string) => void;
+export type ScalingHandler = () => void;
 export interface MouseEvent {
     button: number;
     col: number;
@@ -494,6 +501,20 @@ export declare class InputReader {
     onSessionTail(handler: SessionTailHandler): void;
     onHealthForecast(handler: HealthForecastHandler): void;
     onWorkflowViz(handler: WorkflowVizHandler): void;
+    private metricsHandler;
+    private fleetGrepHandler;
+    private runbookExecHandler;
+    private cloneHandler;
+    private similarGoalsHandler;
+    private costTagsHandler;
+    private scalingHandler;
+    onMetrics(handler: MetricsHandler): void;
+    onFleetGrep(handler: FleetGrepHandler): void;
+    onRunbookExec(handler: RunbookExecHandler): void;
+    onClone(handler: CloneHandler): void;
+    onSimilarGoals(handler: SimilarGoalsHandler): void;
+    onCostTags(handler: CostTagsHandler): void;
+    onScaling(handler: ScalingHandler): void;
     onFleetSearch(handler: FleetSearchHandler): void;
     onNudgeStats(handler: NudgeStatsHandler): void;
     onAllocation(handler: AllocationHandler): void;

package/dist/input.js

@@ -574,6 +574,20 @@ export class InputReader {
     onSessionTail(handler) { this.sessionTailHandler = handler; }
     onHealthForecast(handler) { this.healthForecastHandler = handler; }
     onWorkflowViz(handler) { this.workflowVizHandler = handler; }
+    metricsHandler = null;
+    fleetGrepHandler = null;
+    runbookExecHandler = null;
+    cloneHandler = null;
+    similarGoalsHandler = null;
+    costTagsHandler = null;
+    scalingHandler = null;
+    onMetrics(handler) { this.metricsHandler = handler; }
+    onFleetGrep(handler) { this.fleetGrepHandler = handler; }
+    onRunbookExec(handler) { this.runbookExecHandler = handler; }
+    onClone(handler) { this.cloneHandler = handler; }
+    onSimilarGoals(handler) { this.similarGoalsHandler = handler; }
+    onCostTags(handler) { this.costTagsHandler = handler; }
+    onScaling(handler) { this.scalingHandler = handler; }
     onFleetSearch(handler) { this.fleetSearchHandler = handler; }
     onNudgeStats(handler) { this.nudgeStatsHandler = handler; }
     onAllocation(handler) { this.allocationHandler = handler; }
@@ -2524,6 +2538,62 @@ ${BOLD}other:${RESET}
                 else
                     console.error(`${DIM}workflow-viz not available (no TUI)${RESET}`);
                 break;
+            case "/metrics":
+                if (this.metricsHandler)
+                    this.metricsHandler();
+                else
+                    console.error(`${DIM}metrics not available (no TUI)${RESET}`);
+                break;
+            case "/fleet-grep": {
+                const fgArg = line.slice("/fleet-grep".length).trim();
+                if (!fgArg) {
+                    console.error(`${DIM}usage: /fleet-grep <pattern>${RESET}`);
+                    break;
+                }
+                if (this.fleetGrepHandler)
+                    this.fleetGrepHandler(fgArg);
+                else
+                    console.error(`${DIM}fleet-grep not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/runbook-exec":
+                if (this.runbookExecHandler)
+                    this.runbookExecHandler();
+                else
+                    console.error(`${DIM}runbook-exec not available (no TUI)${RESET}`);
+                break;
+            case "/clone": {
+                const clArg = line.slice("/clone".length).trim();
+                if (!clArg) {
+                    console.error(`${DIM}usage: /clone <source> <new-name> [goal-override]${RESET}`);
+                    break;
+                }
+                if (this.cloneHandler)
+                    this.cloneHandler(clArg);
+                else
+                    console.error(`${DIM}clone not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/similar-goals":
+                if (this.similarGoalsHandler)
+                    this.similarGoalsHandler();
+                else
+                    console.error(`${DIM}similar-goals not available (no TUI)${RESET}`);
+                break;
+            case "/cost-tags": {
+                const ctArg = line.slice("/cost-tags".length).trim() || "team";
+                if (this.costTagsHandler)
+                    this.costTagsHandler(ctArg);
+                else
+                    console.error(`${DIM}cost-tags not available (no TUI)${RESET}`);
+                break;
+            }
+            case "/scaling":
+                if (this.scalingHandler)
+                    this.scalingHandler();
+                else
+                    console.error(`${DIM}scaling not available (no TUI)${RESET}`);
+                break;
             case "/clear":
                 process.stderr.write("\x1b[2J\x1b[H");
                 break;

package/dist/predictive-scaling.d.ts

@@ -0,0 +1,24 @@
+export interface ScalingRecommendation {
+    currentPoolSize: number;
+    recommendedPoolSize: number;
+    action: "scale-up" | "scale-down" | "maintain";
+    reason: string;
+    confidence: "low" | "medium" | "high";
+}
+export interface ScalingInput {
+    currentPoolSize: number;
+    activeSessions: number;
+    pendingTasks: number;
+    recentUtilizationPct: number;
+    peakUtilizationPct: number;
+    averageTaskDurationMs: number;
+}
+/**
+ * Compute a scaling recommendation from current fleet state.
+ */
+export declare function recommendScaling(input: ScalingInput): ScalingRecommendation;
+/**
+ * Format scaling recommendation for TUI display.
+ */
+export declare function formatScalingRecommendation(rec: ScalingRecommendation): string[];
+//# sourceMappingURL=predictive-scaling.d.ts.map

package/dist/predictive-scaling.js

@@ -0,0 +1,60 @@
+// predictive-scaling.ts — auto-adjust pool size based on workload patterns.
+// analyzes historical utilization and upcoming task queue to recommend
+// scaling the concurrent session pool up or down.
+/**
+ * Compute a scaling recommendation from current fleet state.
+ */
+export function recommendScaling(input) {
+    const { currentPoolSize, activeSessions, pendingTasks, recentUtilizationPct, peakUtilizationPct } = input;
+    // scale up if utilization is consistently high and tasks are queued
+    if (recentUtilizationPct > 80 && pendingTasks > 0) {
+        const newSize = Math.min(currentPoolSize * 2, currentPoolSize + pendingTasks);
+        return {
+            currentPoolSize,
+            recommendedPoolSize: Math.ceil(newSize),
+            action: "scale-up",
+            reason: `${recentUtilizationPct}% utilization with ${pendingTasks} pending tasks`,
+            confidence: pendingTasks > 3 ? "high" : "medium",
+        };
+    }
+    // scale up if peak utilization hit 100% (pool was fully saturated)
+    if (peakUtilizationPct >= 100 && pendingTasks > 0) {
+        return {
+            currentPoolSize,
+            recommendedPoolSize: currentPoolSize + Math.ceil(pendingTasks * 0.5),
+            action: "scale-up",
+            reason: `pool saturated (peak ${peakUtilizationPct}%) with ${pendingTasks} waiting`,
+            confidence: "high",
+        };
+    }
+    // scale down if utilization is consistently low
+    if (recentUtilizationPct < 30 && activeSessions < currentPoolSize * 0.5 && currentPoolSize > 2) {
+        const newSize = Math.max(2, Math.ceil(activeSessions * 1.5));
+        return {
+            currentPoolSize,
+            recommendedPoolSize: newSize,
+            action: "scale-down",
+            reason: `${recentUtilizationPct}% utilization, only ${activeSessions}/${currentPoolSize} active`,
+            confidence: recentUtilizationPct < 15 ? "high" : "medium",
+        };
+    }
+    return {
+        currentPoolSize,
+        recommendedPoolSize: currentPoolSize,
+        action: "maintain",
+        reason: `utilization ${recentUtilizationPct}% is within normal range`,
+        confidence: "high",
+    };
+}
+/**
+ * Format scaling recommendation for TUI display.
+ */
+export function formatScalingRecommendation(rec) {
+    const icon = rec.action === "scale-up" ? "⬆" : rec.action === "scale-down" ? "⬇" : "─";
+    const conf = rec.confidence === "high" ? "●" : rec.confidence === "medium" ? "◐" : "○";
+    return [
+        `  ${icon} ${conf} Pool scaling: ${rec.action} (${rec.currentPoolSize} → ${rec.recommendedPoolSize})`,
+        `    ${rec.reason}`,
+    ];
+}
+//# sourceMappingURL=predictive-scaling.js.map

package/dist/session-clone.d.ts

@@ -0,0 +1,23 @@
+import type { TaskState, TaskDefinition } from "./types.js";
+export interface CloneOptions {
+    sourceTitle: string;
+    cloneTitle: string;
+    goalOverride?: string;
+    toolOverride?: string;
+    modeOverride?: string;
+}
+export interface CloneResult {
+    original: string;
+    clone: string;
+    goal: string;
+    tool: string;
+}
+/**
+ * Create a clone task definition from an existing task.
+ */
+export declare function cloneSession(source: TaskState, options: CloneOptions): TaskDefinition;
+/**
+ * Format clone result for TUI display.
+ */
+export declare function formatCloneResult(result: CloneResult): string[];
+//# sourceMappingURL=session-clone.d.ts.map

package/dist/session-clone.js

@@ -0,0 +1,26 @@
+// session-clone.ts — clone a session to try alternative approaches in parallel.
+// creates a new task definition from an existing session's config + goal,
+// allowing A/B experimentation on the same problem.
+/**
+ * Create a clone task definition from an existing task.
+ */
+export function cloneSession(source, options) {
+    return {
+        repo: source.repo,
+        sessionTitle: options.cloneTitle,
+        sessionMode: (options.modeOverride ?? source.sessionMode),
+        tool: options.toolOverride ?? source.tool,
+        goal: options.goalOverride ?? source.goal,
+        dependsOn: undefined, // clone runs independently
+    };
+}
+/**
+ * Format clone result for TUI display.
+ */
+export function formatCloneResult(result) {
+    return [
+        `  Cloned "${result.original}" → "${result.clone}"`,
+        `  Tool: ${result.tool}  Goal: ${result.goal.length > 60 ? result.goal.slice(0, 57) + "..." : result.goal}`,
+    ];
+}
+//# sourceMappingURL=session-clone.js.map

package/package.json

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