aiden-runtime 3.16.0

package/dist/core/spawnManager.js

@@ -0,0 +1,197 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActiveSpawns = getActiveSpawns;
+exports.killSpawn = killSpawn;
+exports.spawnSubagent = spawnSubagent;
+// core/spawnManager.ts — Spawn isolated subagent sessions.
+//
+// A spawned subagent gets:
+//   - Fresh conversation history (context isolation)
+//   - Half the parent's remaining iteration budget (budget inheritance)
+//   - Provider chain inherited from parent config via router
+//   - Memory writes that do NOT propagate to parent session
+//
+// Usage:
+//   const result = await spawnSubagent({ task, context, timeout, parentBudget })
+const agentLoop_1 = require("./agentLoop");
+const router_1 = require("../providers/router");
+const index_1 = require("../providers/index");
+const _activeSpawns = new Map();
+/** Returns all active/recent spawns. */
+function getActiveSpawns() {
+    return Array.from(_activeSpawns.values()).sort((a, b) => b.startedAt - a.startedAt);
+}
+/** Abort a running spawn by ID. Returns true if killed, false if not found. */
+function killSpawn(id) {
+    const spawn = _activeSpawns.get(id);
+    if (!spawn)
+        return false;
+    if (spawn.status === 'running' || spawn.status === 'pending') {
+        spawn.abort?.();
+        spawn.status = 'aborted';
+        return true;
+    }
+    return false;
+}
+// ── Core spawn implementation ─────────────────────────────────
+/**
+ * Spawns an isolated subagent to handle a sub-task.
+ *
+ * Budget inheritance: subagent gets at most floor(parentBudget.remaining / 2)
+ * iterations, capped at 10. This prevents runaway subagents from exhausting
+ * the parent's budget.
+ *
+ * Provider inheritance: uses the same provider chain (same config) so fallback
+ * behaviour is consistent with the parent.
+ */
+async function spawnSubagent(opts) {
+    const spawnId = `spawn_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const t0 = Date.now();
+    // Budget inheritance: half of parent's remaining, max 10
+    const _subBudget = Math.max(1, Math.min(Math.floor(opts.parentBudget.remaining / 2), 10));
+    // Build task message with optional injected context
+    const taskMessage = opts.context
+        ? `${opts.task}\n\n--- Injected Context ---\n${opts.context}`
+        : opts.task;
+    // Abort flag for timeout / kill
+    let abortFlag = false;
+    const entry = {
+        id: spawnId,
+        task: opts.task.slice(0, 80),
+        startedAt: t0,
+        status: 'pending',
+        abort: () => { abortFlag = true; },
+    };
+    _activeSpawns.set(spawnId, entry);
+    // Collect provider names for the result (inherited from parent config)
+    const providerChain = (() => {
+        try {
+            const cfg = (0, index_1.loadConfig)();
+            return (cfg.providers?.apis ?? [])
+                .filter((a) => a.enabled)
+                .map((a) => String(a.provider));
+        }
+        catch {
+            return [];
+        }
+    })();
+    entry.status = 'running';
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Spawn timeout after ${opts.timeout}ms`)), opts.timeout));
+    const workPromise = (async () => {
+        if (abortFlag)
+            throw new Error('Spawn aborted before start');
+        // Resolve provider credentials via router (inherits parent chain)
+        const next = (0, router_1.getNextAvailableAPI)();
+        if (!next) {
+            return {
+                success: false,
+                error: 'No available API provider for subagent',
+                iterationsUsed: 0,
+                duration: Date.now() - t0,
+                providerChain,
+            };
+        }
+        const apiKey = next.entry.key.startsWith('env:')
+            ? (process.env[next.entry.key.replace('env:', '')] ?? '')
+            : next.entry.key;
+        // Plan in isolated context (empty history = no parent session context)
+        let plan;
+        try {
+            plan = await (0, agentLoop_1.planWithLLM)(taskMessage, [], // empty conversation history — context isolation
+            apiKey, next.entry.model, next.entry.provider);
+        }
+        catch (e) {
+            return {
+                success: false,
+                error: `Subagent planning failed: ${e?.message ?? String(e)}`,
+                iterationsUsed: 0,
+                duration: Date.now() - t0,
+                providerChain,
+            };
+        }
+        if (abortFlag)
+            throw new Error('Spawn aborted after planning');
+        // Direct answer — no tools needed
+        if (!plan.requires_execution || plan.plan.length === 0) {
+            const directAnswer = (plan.reason || plan.goal || 'Task complete.').trim();
+            return {
+                success: true,
+                result: directAnswer,
+                iterationsUsed: 0,
+                duration: Date.now() - t0,
+                providerChain,
+            };
+        }
+        // Execute plan (isolated — no workspace memory propagation)
+        let iterationsUsed = 0;
+        const stepResults = await (0, agentLoop_1.executePlan)(plan, (_step, _result) => { iterationsUsed++; });
+        if (abortFlag)
+            throw new Error('Spawn aborted during execution');
+        // Synthesize step outputs into a real LLM answer
+        const stepSummary = stepResults
+            .filter(r => r.success && r.output)
+            .map(r => `[${r.tool}]: ${String(r.output).slice(0, 2000)}`)
+            .join('\n\n');
+        if (!stepSummary.trim()) {
+            return {
+                success: false,
+                error: 'Subagent steps produced no output',
+                iterationsUsed,
+                duration: Date.now() - t0,
+                providerChain,
+            };
+        }
+        const synthesisPrompt = [
+            'You are completing a sub-task. Synthesize the tool results into a clear, concise answer.',
+            '',
+            `Task: ${taskMessage}`,
+            '',
+            'Tool Results:',
+            stepSummary,
+            '',
+            'Provide a direct answer:',
+        ].join('\n');
+        let synthesized = '';
+        try {
+            synthesized = await (0, agentLoop_1.callLLM)(synthesisPrompt, apiKey, next.entry.model, next.entry.provider);
+        }
+        catch { }
+        return {
+            success: true,
+            result: synthesized.trim() || stepSummary,
+            iterationsUsed,
+            duration: Date.now() - t0,
+            providerChain,
+        };
+    })();
+    try {
+        const outcome = await Promise.race([workPromise, timeoutPromise]);
+        entry.status = 'done';
+        entry.result = outcome;
+        return outcome;
+    }
+    catch (err) {
+        const result = {
+            success: false,
+            error: err?.message ?? String(err),
+            iterationsUsed: 0,
+            duration: Date.now() - t0,
+            providerChain,
+        };
+        entry.status = abortFlag ? 'aborted' : 'done';
+        entry.result = result;
+        return result;
+    }
+    finally {
+        // Cap registry at 20 most recent
+        const all = Array.from(_activeSpawns.entries())
+            .sort((a, b) => b[1].startedAt - a[1].startedAt);
+        if (all.length > 20) {
+            all.slice(20).forEach(([id]) => _activeSpawns.delete(id));
+        }
+    }
+}

package/dist/core/statusVerbs.js

@@ -0,0 +1,43 @@
+"use strict";
+// core/statusVerbs.ts — Rotating verb vocabulary for streaming status events.
+// Phase 2: same rotating-verb pattern as Claude Code — keeps Aiden feeling alive.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUS_VERBS = void 0;
+exports.getVerb = getVerb;
+exports.STATUS_VERBS = {
+    thinking: [
+        'Pondering...', 'Thinking...', 'Mulling it over...', 'Figuring this out...',
+        'Reasoning through...', 'Working it out...', 'On it...',
+        'Processing...', 'Considering...'
+    ],
+    searching: [
+        'Hunting...', 'Searching...', 'Digging...', 'Looking it up...',
+        'Scouring the web...', 'On the hunt...', 'Tracking it down...',
+        'Scanning...', 'Fetching...'
+    ],
+    reading: [
+        'Reading...', 'Skimming...', 'Studying...', 'Going through this...',
+        'Checking...', 'Scanning the page...', 'Absorbing...'
+    ],
+    coding: [
+        'Coding...', 'Writing the script...', 'Crafting...', 'Building...',
+        'Scripting...', 'Putting it together...', 'Tinkering...',
+        'Hammering it out...'
+    ],
+    browsing: [
+        'Opening...', 'Navigating...', 'Pulling up...', 'Launching...',
+        'Loading the page...', 'Heading there now...'
+    ],
+    writing: [
+        'Writing...', 'Composing...', 'Crafting your response...',
+        'Putting this together...', 'Almost done...', 'Wrapping up...'
+    ],
+    tooling: [
+        'Working on it...', 'Handling this...', 'Running the tool...',
+        'Executing...', 'Taking care of it...'
+    ],
+};
+function getVerb(action) {
+    const verbs = exports.STATUS_VERBS[action] ?? exports.STATUS_VERBS.tooling;
+    return verbs[Math.floor(Math.random() * verbs.length)];
+}

package/dist/core/swarmManager.js

@@ -0,0 +1,109 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swarmSubagents = swarmSubagents;
+// core/swarmManager.ts — Parallel subagent orchestration with voting/merge/best.
+//
+// Runs N isolated subagents concurrently via Promise.allSettled, then
+// aggregates results using one of three strategies:
+//
+//   vote   — LLM judge picks the best single answer (default)
+//   merge  — Synthesise all successful answers into one
+//   best   — Return ranked list of all successful results
+//
+// Budget: each swarm agent gets floor(parentBudget.remaining / (2 * N)), min 1, max 5.
+const spawnManager_1 = require("./spawnManager");
+const router_1 = require("../providers/router");
+const agentLoop_1 = require("./agentLoop");
+// ── Core swarm implementation ─────────────────────────────────
+/**
+ * Spawns N subagents in parallel for the same task, then aggregates.
+ *
+ * Budget inheritance: each agent gets floor(parentBudget.remaining / (2*N)),
+ * clamped to [1, 5].  Total budget consumed ≤ parentBudget.remaining / 2.
+ */
+async function swarmSubagents(opts) {
+    const t0 = Date.now();
+    const n = Math.max(2, Math.min(opts.n, 5));
+    const agentBudget = Math.max(1, Math.min(Math.floor(opts.parentBudget.remaining / (2 * n)), 5));
+    const agentOpts = Array.from({ length: n }, (_, i) => ({
+        task: `[Swarm agent ${i + 1}/${n}] ${opts.task}`,
+        timeout: opts.timeout,
+        parentBudget: { ...opts.parentBudget, remaining: agentBudget * n },
+    }));
+    // Run all agents in parallel
+    const settled = await Promise.allSettled(agentOpts.map(o => (0, spawnManager_1.spawnSubagent)(o)));
+    const successes = settled
+        .filter((s) => s.status === 'fulfilled' && s.value.success)
+        .map(s => s.value.result ?? '')
+        .filter(r => r.length > 0);
+    const agentsRun = settled.length;
+    if (!successes.length) {
+        return {
+            success: false,
+            error: 'All swarm agents failed',
+            agentsRun,
+            strategy: opts.strategy,
+            duration: Date.now() - t0,
+        };
+    }
+    // ── Aggregation ───────────────────────────────────────────────
+    let finalResult = '';
+    if (opts.strategy === 'best') {
+        // Return all results ranked by length (proxy for completeness)
+        const ranked = [...successes].sort((a, b) => b.length - a.length);
+        finalResult = ranked
+            .map((r, i) => `### Agent ${i + 1}\n${r}`)
+            .join('\n\n---\n\n');
+    }
+    else if (opts.strategy === 'merge') {
+        // Ask an LLM to synthesise
+        finalResult = await aggregateWithLLM(opts.task, successes, 'merge') ?? successes.join('\n\n---\n\n');
+    }
+    else {
+        // vote — pick the single best answer
+        if (successes.length === 1) {
+            finalResult = successes[0];
+        }
+        else {
+            finalResult = await aggregateWithLLM(opts.task, successes, 'vote') ?? successes[0];
+        }
+    }
+    return {
+        success: true,
+        result: finalResult,
+        agentsRun,
+        strategy: opts.strategy,
+        duration: Date.now() - t0,
+    };
+}
+// ── LLM aggregation helper ────────────────────────────────────
+async function aggregateWithLLM(originalTask, answers, mode) {
+    try {
+        const next = (0, router_1.getNextAvailableAPI)();
+        if (!next)
+            return null;
+        const apiKey = next.entry.key.startsWith('env:')
+            ? (process.env[next.entry.key.replace('env:', '')] ?? '')
+            : next.entry.key;
+        const numbered = answers.map((a, i) => `### Answer ${i + 1}\n${a}`).join('\n\n');
+        const prompt = mode === 'vote'
+            ? `You are a judge. The original task was:\n"${originalTask}"\n\nHere are ${answers.length} candidate answers:\n\n${numbered}\n\nSelect the single best answer. Respond with only that answer — no preamble.`
+            : `You are a synthesiser. The original task was:\n"${originalTask}"\n\nHere are ${answers.length} answers:\n\n${numbered}\n\nMerge them into one comprehensive answer. Respond with only the merged answer.`;
+        const budget = (0, agentLoop_1.getBudgetState)() ?? { current: 1, max: 10, remaining: 2 };
+        const plan = await (0, agentLoop_1.planWithLLM)(prompt, [], apiKey, next.entry.model, next.entry.provider);
+        // planWithLLM returns an AgentPlan — extract text from first respond step
+        if (plan?.plan?.length) {
+            const firstStep = plan.plan[0];
+            if (firstStep?.tool === 'respond')
+                return firstStep?.input?.message ?? null;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/taskQueue.js

@@ -0,0 +1,119 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskQueue = void 0;
+// core/taskQueue.ts — Persistent async task queue.
+// Tasks from API, Telegram, or the scheduler are enqueued here
+// and processed sequentially by posting to the chat endpoint.
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ── TaskQueue class ───────────────────────────────────────────
+class TaskQueue {
+    constructor(workspaceDir, chatEndpoint) {
+        this.queue = [];
+        this.isProcessing = false;
+        this.savePath = (0, path_1.join)(workspaceDir, 'task_queue.json');
+        this.chatEndpoint = chatEndpoint;
+        this.load();
+        // Re-queue any tasks that were mid-flight when process stopped
+        for (const task of this.queue) {
+            if (task.status === 'running') {
+                task.status = 'queued';
+            }
+        }
+        if (this.queue.some(t => t.status === 'queued')) {
+            console.log(`[Queue] Resuming ${this.queue.filter(t => t.status === 'queued').length} queued task(s) from previous session`);
+            setTimeout(() => this.processNext(), 2000); // short delay to let server finish starting
+        }
+    }
+    // ── Enqueue ───────────────────────────────────────────────
+    enqueue(task) {
+        const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        this.queue.push({
+            ...task,
+            id,
+            status: 'queued',
+            createdAt: new Date().toISOString(),
+        });
+        this.save();
+        console.log(`[Queue] Enqueued: ${id} from ${task.source}: "${task.message.substring(0, 50)}"`);
+        setTimeout(() => this.processNext(), 100);
+        return id;
+    }
+    // ── Process next queued task ──────────────────────────────
+    async processNext() {
+        if (this.isProcessing)
+            return;
+        const next = this.queue.find(t => t.status === 'queued');
+        if (!next)
+            return;
+        this.isProcessing = true;
+        next.status = 'running';
+        next.startedAt = new Date().toISOString();
+        this.save();
+        console.log(`[Queue] Processing: ${next.id}: "${next.message.substring(0, 50)}"`);
+        try {
+            const response = await fetch(this.chatEndpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: next.message,
+                    sessionId: `dispatch_${next.id}`,
+                }),
+                signal: AbortSignal.timeout(120000), // 2 min cap per queued task
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status} from chat endpoint`);
+            const data = await response.json();
+            next.status = 'completed';
+            next.completedAt = new Date().toISOString();
+            next.result = data.response || data.message || JSON.stringify(data).slice(0, 500);
+            console.log(`[Queue] Completed: ${next.id} — "${String(next.result).slice(0, 60)}"`);
+        }
+        catch (e) {
+            next.status = 'failed';
+            next.completedAt = new Date().toISOString();
+            next.error = e.message;
+            console.log(`[Queue] Failed: ${next.id}: ${e.message}`);
+        }
+        this.save();
+        this.isProcessing = false;
+        // Continue with next item if any
+        setTimeout(() => this.processNext(), 50);
+    }
+    // ── Query helpers ─────────────────────────────────────────
+    getStatus(id) {
+        return this.queue.find(t => t.id === id);
+    }
+    getPending() {
+        return this.queue.filter(t => t.status === 'queued' || t.status === 'running');
+    }
+    getRecent(n = 10) {
+        return [...this.queue]
+            .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+            .slice(0, n);
+    }
+    // ── Persistence ───────────────────────────────────────────
+    load() {
+        try {
+            if ((0, fs_1.existsSync)(this.savePath)) {
+                this.queue = JSON.parse((0, fs_1.readFileSync)(this.savePath, 'utf8'));
+            }
+        }
+        catch {
+            this.queue = [];
+        }
+    }
+    save() {
+        try {
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(this.savePath), { recursive: true });
+            (0, fs_1.writeFileSync)(this.savePath, JSON.stringify(this.queue, null, 2));
+        }
+        catch { }
+    }
+}
+// ── Singleton — chat endpoint matches api/server.ts port default ──
+exports.taskQueue = new TaskQueue((0, path_1.join)(process.cwd(), 'workspace'), 'http://localhost:4200/api/chat');

package/dist/core/taskRecovery.js

@@ -0,0 +1,128 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverTasks = recoverTasks;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const TASKS_DIR = path_1.default.join(process.cwd(), 'workspace', 'tasks');
+const MAX_TASK_AGE_MS = 2 * 60 * 60 * 1000; // 2 hours
+async function recoverTasks() {
+    if (!fs_1.default.existsSync(TASKS_DIR)) {
+        console.log('[Recovery] No task directory found — skipping');
+        return;
+    }
+    let taskDirs;
+    try {
+        taskDirs = fs_1.default.readdirSync(TASKS_DIR).filter(d => {
+            try {
+                return fs_1.default.statSync(path_1.default.join(TASKS_DIR, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch (e) {
+        console.error(`[Recovery] Cannot read tasks directory: ${e.message}`);
+        return;
+    }
+    let recovered = 0;
+    let cleaned = 0;
+    let corrupted = 0;
+    for (const taskId of taskDirs) {
+        const statePath = path_1.default.join(TASKS_DIR, taskId, 'state.json');
+        if (!fs_1.default.existsSync(statePath))
+            continue;
+        let state;
+        try {
+            state = JSON.parse(fs_1.default.readFileSync(statePath, 'utf-8'));
+        }
+        catch {
+            // Corrupt state file — overwrite with failed status
+            corrupted++;
+            try {
+                const tmp = statePath + '.tmp';
+                fs_1.default.writeFileSync(tmp, JSON.stringify({
+                    id: taskId,
+                    status: 'failed',
+                    error: 'Corrupt state file — overwritten on startup',
+                    createdAt: 0,
+                    updatedAt: Date.now(),
+                }, null, 2));
+                // NTFS-safe rename attempt — fall back to direct write on error
+                try {
+                    fs_1.default.renameSync(tmp, statePath);
+                }
+                catch {
+                    fs_1.default.writeFileSync(statePath, fs_1.default.readFileSync(tmp, 'utf-8'));
+                    try {
+                        fs_1.default.unlinkSync(tmp);
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+            continue;
+        }
+        // Skip already-terminal tasks
+        if (state.status === 'completed' || state.status === 'failed')
+            continue;
+        // Only act on tasks stuck in 'running'
+        if (state.status !== 'running')
+            continue;
+        const age = Date.now() - (state.createdAt || 0);
+        if (age > MAX_TASK_AGE_MS) {
+            // Expired — mark failed and move on
+            state.status = 'failed';
+            state.error = `Task expired — exceeded ${MAX_TASK_AGE_MS / 60000} minute limit`;
+            state.completedAt = Date.now();
+            cleaned++;
+            try {
+                const tmp = statePath + '.tmp';
+                fs_1.default.writeFileSync(tmp, JSON.stringify(state, null, 2));
+                try {
+                    fs_1.default.renameSync(tmp, statePath);
+                }
+                catch {
+                    fs_1.default.writeFileSync(statePath, JSON.stringify(state, null, 2));
+                    try {
+                        fs_1.default.unlinkSync(tmp);
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+            console.log(`[Recovery] Expired task cleaned: ${taskId} (age: ${Math.round(age / 60000)}m)`);
+        }
+        else {
+            // Recent interrupted task — log it, don't auto-resume
+            // (User can retry via the API; auto-resume risks duplicate side effects)
+            recovered++;
+            const stepsDone = (state.steps || []).filter((s) => s.status === 'completed').length;
+            const totalSteps = state.totalSteps || 0;
+            console.log(`[Recovery] Interrupted task found: ${taskId}`);
+            console.log(`           Goal: "${(state.goal || '').slice(0, 60)}"`);
+            console.log(`           Progress: ${stepsDone}/${totalSteps} steps, age: ${Math.round(age / 60000)}m`);
+            console.log(`           Status kept as 'running' — user can retry via the API`);
+        }
+    }
+    // Summary
+    if (recovered > 0) {
+        console.log(`[Recovery] ${recovered} interrupted task(s) available for retry`);
+    }
+    if (cleaned > 0) {
+        console.log(`[Recovery] Cleaned ${cleaned} expired/stale task(s)`);
+    }
+    if (corrupted > 0) {
+        console.log(`[Recovery] Reset ${corrupted} corrupt task state file(s)`);
+    }
+    if (recovered === 0 && cleaned === 0 && corrupted === 0) {
+        console.log('[Recovery] No interrupted tasks found');
+    }
+}