aiden-runtime 4.0.2 → 4.1.1

package/dist/cli/v4/commands/status.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/status.ts — Tier-3.1 (v4.1-tier3.1)
+ *
+ * `/status` — full environment + capability table that the v4.0 boot
+ * card used to print inline. Slim boot now ships a 3-4 line summary;
+ * users who want the full picture (provider table, skill counts, MCP
+ * details, channel adapter list) call `/status` on demand.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.status = void 0;
+const chatSession_1 = require("../chatSession");
+const display_1 = require("../display");
+exports.status = {
+    name: 'status',
+    description: 'Detailed runtime status (env, providers, skills, channels).',
+    category: 'system',
+    icon: 'i',
+    handler: async (ctx) => {
+        const display = ctx.display;
+        // Provider / model — drawn from the live session when available.
+        const provider = ctx.session?.getCurrentProvider() ?? '(unset)';
+        const model = ctx.session?.getCurrentModel() ?? '(unset)';
+        // Tools / skills counts.
+        const toolsCount = ctx.toolRegistry?.list().length ?? 0;
+        let skillsLoaded = 0;
+        try {
+            if (ctx.skillLoader)
+                skillsLoaded = (await ctx.skillLoader.list()).length;
+        }
+        catch {
+            skillsLoaded = 0;
+        }
+        // Channels — uses the same summariser the boot card used.
+        let channelSummary;
+        const cm = ctx.channelManager;
+        if (cm) {
+            const adapterStatuses = cm.getStatus().map((s) => {
+                const adapter = cm.get(s.name);
+                const botHandle = typeof adapter?.getBotUsername === 'function' ? adapter.getBotUsername() : null;
+                const state = typeof adapter?.getState === 'function' ? adapter.getState() : undefined;
+                return { id: s.name, healthy: s.healthy, botHandle, state };
+            });
+            channelSummary = (0, display_1.summarizeChannelState)({ adapters: adapterStatuses });
+        }
+        else {
+            channelSummary = (0, display_1.summarizeChannelState)(null);
+        }
+        display.write('\n');
+        display.write(display.twoColumnBlock({
+            title: 'Environment',
+            rows: [
+                { key: 'OS', value: (0, chatSession_1.detectOS)() },
+                { key: 'shell', value: (0, chatSession_1.detectShell)() },
+                { key: 'runtime', value: 'local-first' },
+                { key: 'provider', value: provider },
+                { key: 'model', value: model },
+                { key: 'tools', value: `${toolsCount} loaded` },
+                { key: 'skills', value: `${skillsLoaded} loaded` },
+                { key: 'channels', value: channelSummary },
+            ],
+        }, {
+            title: 'Capabilities',
+            rows: [
+                { key: 'web', value: 'research, extract' },
+                { key: 'browser', value: 'navigate, automate' },
+                { key: 'files', value: 'read, patch, organize' },
+                { key: 'execution', value: 'shell, code, workflows' },
+                { key: 'memory', value: 'persistent recall' },
+            ],
+        }) + '\n');
+        display.write('\n');
+        display.write(`  ${display.rule()}\n`);
+        display.write(display.bottomPromptHint() + '\n');
+        display.write('\n');
+        return {};
+    },
+};

package/dist/cli/v4/commands/subagent.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/subagent.ts — Phase v4.1-subagent
+ *
+ * `aiden subagent <action>` subcommand. Two actions:
+ *
+ *   status — print build fingerprint + env config + provider count.
+ *   tools  — list the subagent_fanout schema (debug).
+ *
+ * Lightweight diagnostics surface — no provider resolution, no
+ * agent runtime build. The point is "what would my fanout look like
+ * before I run it?" — useful for triaging "no providers configured"
+ * errors and verifying env-var allowlists before pointing a client
+ * at the binary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDEN_SUBAGENT_BUILD = void 0;
+exports.runSubagentSubcommand = runSubagentSubcommand;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const toolRegistry_1 = require("../../../core/v4/toolRegistry");
+const index_1 = require("../../../tools/v4/index");
+const diagnostics_1 = require("../../../core/v4/subagent/diagnostics");
+Object.defineProperty(exports, "AIDEN_SUBAGENT_BUILD", { enumerable: true, get: function () { return diagnostics_1.AIDEN_SUBAGENT_BUILD; } });
+const budget_1 = require("../../../core/v4/subagent/budget");
+const merger_1 = require("../../../core/v4/subagent/merger");
+async function runSubagentSubcommand(action, opts = {}) {
+    const writeOut = opts.writeOut ?? ((t) => process.stdout.write(t));
+    const writeErr = opts.writeErr ?? ((t) => process.stderr.write(t));
+    switch (action) {
+        case 'status': {
+            const budget = (0, budget_1.resolveBudget)();
+            const allowDestructive = process.env.AIDEN_SUBAGENT_ALLOW_DESTRUCTIVE === '1' ||
+                process.env.AIDEN_SUBAGENT_ALLOW_DESTRUCTIVE === 'true';
+            const aggOverride = (0, merger_1.resolveAggregatorOverride)();
+            writeOut(`Aiden subagent fanout\n`);
+            writeOut(`  build:                   ${diagnostics_1.AIDEN_SUBAGENT_BUILD}\n`);
+            writeOut(`  default n:               ${budget_1.DEFAULT_FANOUT_N}\n`);
+            writeOut(`  hard cap n:              ${budget_1.MAX_FANOUT_N}\n`);
+            writeOut(`  per-subagent timeout ms: ${budget.perSubagentTimeoutMs}\n`);
+            writeOut(`  wall-clock cap ms:       ${budget.wallClockCapMs}\n`);
+            writeOut(`  max iterations:          ${budget.maxIterations}\n`);
+            writeOut(`  allowDestructive:        ${allowDestructive ? 'yes' : 'no'}\n`);
+            writeOut(`  aggregator override:     ${aggOverride
+                ? `${aggOverride.providerId}:${aggOverride.modelId}`
+                : '(unset — use parent active model)'}\n`);
+            return 0;
+        }
+        case 'tools': {
+            const registry = new toolRegistry_1.ToolRegistry();
+            (0, index_1.registerAllTools)(registry);
+            const handler = registry.get('subagent_fanout');
+            if (!handler) {
+                writeErr('subagent_fanout not registered (this is a build bug)\n');
+                return 1;
+            }
+            writeOut(`Aiden subagent — tool schema\n`);
+            writeOut(`  name:        ${handler.schema.name}\n`);
+            writeOut(`  category:    ${handler.category}\n`);
+            writeOut(`  mutates:     ${handler.mutates}\n`);
+            writeOut(`  toolset:     ${handler.toolset}\n`);
+            writeOut(`  description: ${handler.schema.description}\n`);
+            writeOut(`\n  inputSchema (JSON):\n`);
+            writeOut(`${JSON.stringify(handler.schema.inputSchema, null, 2)}\n`);
+            return 0;
+        }
+        default: {
+            writeErr(`Unknown 'aiden subagent' action: ${action}\n`);
+            writeErr(`Actions: status | tools\n`);
+            return 1;
+        }
+    }
+}

package/dist/cli/v4/commands/verbose.js

@@ -9,7 +9,7 @@ exports.verbose = {
     name: 'verbose',
     description: 'Set verbosity: compact | normal | verbose.',
     category: 'system',
-    icon: '🔎',
+    icon: '~',
     handler: async (ctx) => {
         const cfg = ctx.config;
         if (!cfg) {

package/dist/cli/v4/commands/voice.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/voice.ts — Phase v4.1-voice-cli
+ *
+ * `/voice` slash command. Subcommands:
+ *
+ *   /voice on            — enable voice mode for this session
+ *   /voice off           — disable
+ *   /voice toggle        — flip on/off
+ *   /voice status        — show fingerprint + backend + provider availability
+ *   /voice mode push     — switch to push-to-talk (default)
+ *   /voice mode continuous — switch to continuous (VAD-driven)
+ *   /voice provider <name> — pin TTS provider (edge | sapi | elevenlabs | voxcpm)
+ *   /voice voice <id>    — pin TTS voice (default: en-US-AriaNeural)
+ *
+ * Persistence: writes to the user's `.aiden/.env` via `upsertEnvVar`
+ * so settings survive REPL restarts. Mirrors the channel slash
+ * command's atomic .env mutation pattern.
+ *
+ * State surfaces via `process.env` keys:
+ *   AIDEN_VOICE_ENABLED   — "1" / "0"
+ *   AIDEN_VOICE_MODE      — "push-to-talk" / "continuous"
+ *   AIDEN_VOICE_TTS_VOICE — voice id
+ *   AIDEN_VOICE_PROVIDER  — provider override
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voice = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const diagnostics_1 = require("../../../core/v4/voice/diagnostics");
+// .env upsert (atomic) — mirrors the channel slash command's
+// pattern. Local to this file so the import surface stays tight.
+async function upsertEnvVar(envFile, key, value) {
+    const k = key.toUpperCase();
+    let body = '';
+    try {
+        body = await node_fs_1.promises.readFile(envFile, 'utf8');
+    }
+    catch { /* fresh file */ }
+    const lines = body.split(/\r?\n/);
+    let replaced = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        if (lines[i].startsWith(`${k}=`)) {
+            lines[i] = `${k}=${value}`;
+            replaced = true;
+        }
+    }
+    if (!replaced)
+        lines.push(`${k}=${value}`);
+    while (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(envFile), { recursive: true });
+    const tmp = `${envFile}.${process.pid}.tmp`;
+    await node_fs_1.promises.writeFile(tmp, `${lines.join('\n')}\n`, 'utf8');
+    await node_fs_1.promises.rename(tmp, envFile);
+}
+async function deleteEnvKey(envFile, key) {
+    const k = key.toUpperCase();
+    let body = '';
+    try {
+        body = await node_fs_1.promises.readFile(envFile, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const lines = body.split(/\r?\n/);
+    const filtered = lines.filter((l) => !l.startsWith(`${k}=`));
+    if (filtered.length === lines.length)
+        return false;
+    while (filtered.length > 0 && filtered[filtered.length - 1] === '')
+        filtered.pop();
+    const tmp = `${envFile}.${process.pid}.tmp`;
+    await node_fs_1.promises.writeFile(tmp, `${filtered.join('\n')}\n`, 'utf8');
+    await node_fs_1.promises.rename(tmp, envFile);
+    return true;
+}
+const USAGE = [
+    'Usage:',
+    '  /voice on | off | toggle',
+    '  /voice status',
+    '  /voice mode push | continuous',
+    '  /voice provider edge | sapi | elevenlabs | voxcpm',
+    '  /voice voice <id>     (e.g. en-US-AriaNeural)',
+].join('\n');
+const handler = async (ctx) => {
+    const display = ctx.display;
+    const action = (ctx.args[0] ?? 'status').toLowerCase();
+    const paths = ctx.paths;
+    switch (action) {
+        case 'on':
+        case 'off':
+        case 'toggle': {
+            const current = process.env.AIDEN_VOICE_ENABLED === '1';
+            const next = action === 'on'
+                ? true
+                : action === 'off'
+                    ? false
+                    : !current;
+            process.env.AIDEN_VOICE_ENABLED = next ? '1' : '0';
+            if (paths) {
+                try {
+                    if (next)
+                        await upsertEnvVar(paths.envFile, 'AIDEN_VOICE_ENABLED', '1');
+                    else
+                        await deleteEnvKey(paths.envFile, 'AIDEN_VOICE_ENABLED');
+                }
+                catch (err) {
+                    display.warn(`Could not persist /voice ${action} to .env: ${err.message}`);
+                }
+            }
+            const tty = !!process.stdin.isTTY && !!process.stdout.isTTY;
+            if (next && !tty) {
+                display.warn('Voice mode requested, but stdin is not a TTY. The next REPL session must run in an interactive terminal.');
+            }
+            display.info(`voice mode ${next ? 'on' : 'off'}`);
+            return;
+        }
+        case 'status': {
+            const diag = await (0, diagnostics_1.collectVoiceDiagnostics)();
+            display.info(`Aiden voice — ${diagnostics_1.AIDEN_VOICE_CLI_BUILD}`);
+            display.info(`  enabled:        ${process.env.AIDEN_VOICE_ENABLED === '1' ? 'yes' : 'no'}`);
+            display.info(`  tty:            ${diag.isTty ? 'yes' : 'no (voice refused — non-TTY stdin)'}`);
+            display.info(`  mic backend:    ${diag.audio.backend}`);
+            display.info(`  mic active:     ${diag.audio.active ? 'yes' : 'no'}`);
+            display.info(`  sox on PATH:    ${diag.audio.soxOnPath ? 'yes' : 'no'}`);
+            display.info(`  mode:           ${diag.config.mode}`);
+            display.info(`  tts voice:      ${diag.config.ttsVoice}`);
+            display.info(`  beeps:          ${diag.config.beepsEnabled ? 'on' : 'off'}`);
+            display.info(`  tts providers:`);
+            for (const p of diag.ttsProviders) {
+                const tag = p.available ? '✓' : '✗';
+                display.info(`    ${tag} ${p.name.padEnd(12)} ${p.note ?? ''}`);
+            }
+            return;
+        }
+        case 'mode': {
+            const sub = (ctx.args[1] ?? '').toLowerCase();
+            if (sub !== 'push' && sub !== 'push-to-talk' && sub !== 'continuous') {
+                display.warn('Mode must be "push" or "continuous"');
+                return;
+            }
+            const value = sub === 'continuous' ? 'continuous' : 'push-to-talk';
+            process.env.AIDEN_VOICE_MODE = value;
+            if (paths) {
+                try {
+                    await upsertEnvVar(paths.envFile, 'AIDEN_VOICE_MODE', value);
+                }
+                catch (err) {
+                    display.warn(`Could not persist mode: ${err.message}`);
+                }
+            }
+            display.info(`voice mode = ${value}`);
+            return;
+        }
+        case 'provider': {
+            const provider = (ctx.args[1] ?? '').toLowerCase();
+            const valid = ['edge', 'sapi', 'elevenlabs', 'voxcpm'];
+            if (!valid.includes(provider)) {
+                display.warn(`Provider must be one of: ${valid.join(', ')}`);
+                return;
+            }
+            process.env.AIDEN_VOICE_PROVIDER = provider;
+            if (paths) {
+                try {
+                    await upsertEnvVar(paths.envFile, 'AIDEN_VOICE_PROVIDER', provider);
+                }
+                catch (err) {
+                    display.warn(`Could not persist provider: ${err.message}`);
+                }
+            }
+            display.info(`tts provider = ${provider}`);
+            return;
+        }
+        case 'voice': {
+            const voiceId = (ctx.args[1] ?? '').trim();
+            if (!voiceId) {
+                display.warn('Voice id required (e.g. en-US-AriaNeural)');
+                return;
+            }
+            process.env.AIDEN_VOICE_TTS_VOICE = voiceId;
+            if (paths) {
+                try {
+                    await upsertEnvVar(paths.envFile, 'AIDEN_VOICE_TTS_VOICE', voiceId);
+                }
+                catch (err) {
+                    display.warn(`Could not persist voice: ${err.message}`);
+                }
+            }
+            display.info(`tts voice = ${voiceId}`);
+            return;
+        }
+        case 'help':
+        case '--help':
+        case '-h':
+            display.info(USAGE);
+            return;
+        default:
+            display.warn(`Unknown action: ${action}`);
+            display.info(USAGE);
+            return;
+    }
+};
+exports.voice = {
+    name: 'voice',
+    description: 'Voice mode (PTT + TTS). Subcommands: on/off/toggle/status/mode/provider/voice',
+    category: 'system',
+    handler,
+};

package/dist/cli/v4/cronCli.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/cronCli.ts — Phase v4.1-cron
+ *
+ * `aiden cron <action>` top-level CLI subcommand. Three actions:
+ *
+ *   status      — print build fingerprint, tick + lock state,
+ *                 last 5 fires (boot-local). No mutation.
+ *   list        — table of jobs (id, schedule, enabled, next run).
+ *   run <id>    — fire a job immediately. Useful for scripted
+ *                 "trigger this scheduled task now" flows from
+ *                 a shell.
+ *
+ * Distinct from the `/cron` slash command (which mutates session
+ * state from inside the REPL). This subcommand is for scripting +
+ * sanity-checking from a non-interactive shell.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDEN_CRON_BUILD = void 0;
+exports.runCronSubcommand = runCronSubcommand;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const cronManager_1 = require("../../core/cronManager");
+Object.defineProperty(exports, "AIDEN_CRON_BUILD", { enumerable: true, get: function () { return cronManager_1.AIDEN_CRON_BUILD; } });
+async function runCronSubcommand(action, args, opts = {}) {
+    const writeOut = opts.writeOut ?? ((t) => process.stdout.write(t));
+    const writeErr = opts.writeErr ?? ((t) => process.stderr.write(t));
+    switch (action) {
+        case 'status': {
+            // Booting may armed timers we don't need for status — but it
+            // also populates the cache. Skip arming side-effect by NOT
+            // calling loadJobs; getDiagnostics works without the cache.
+            const diag = await (0, cronManager_1.getDiagnostics)();
+            writeOut(`Aiden cron — ${cronManager_1.AIDEN_CRON_BUILD}\n`);
+            writeOut(`  schema version : ${diag.schemaVersion}\n`);
+            writeOut(`  tick interval  : ${diag.tickMs}ms\n`);
+            writeOut(`  fire timeout   : ${diag.timeoutMs}ms\n`);
+            writeOut(`  heartbeat      : ${diag.heartbeatActive ? 'active' : 'idle'}\n`);
+            writeOut(`  last heartbeat : ${diag.lastHeartbeatAt ?? 'never'}\n`);
+            writeOut(`  skipped ticks  : ${diag.skippedTicks}\n`);
+            writeOut(`  fires (boot)   : ${diag.firesStarted}\n`);
+            writeOut(`  lock           : ${diag.lock.held ? 'held' : 'free'}\n`);
+            writeOut(`  lock path      : ${diag.lock.path}\n`);
+            if (diag.recentFires.length > 0) {
+                writeOut(`  recent fires:\n`);
+                for (const r of diag.recentFires) {
+                    const tag = r.status === 'ok' ? '✓'
+                        : r.status === 'warn' ? '∼'
+                            : r.status === 'timeout' ? 'T'
+                                : '✗';
+                    writeOut(`    ${tag} [${r.jobId.slice(0, 8)}]  ${r.startedAt}  ${r.durationMs}ms` +
+                        `${r.error ? '  ' + r.error.slice(0, 60) : ''}\n`);
+                }
+            }
+            return 0;
+        }
+        case 'list': {
+            const jobs = await (0, cronManager_1.listJobsAsync)();
+            if (jobs.length === 0) {
+                writeOut(`No cron jobs configured.\n`);
+                return 0;
+            }
+            writeOut(`Aiden cron — ${jobs.length} job(s)\n`);
+            writeOut(`  ID    NAME                            SCHEDULE                          STATE       NEXT RUN\n`);
+            for (const j of jobs) {
+                const id = j.id.padEnd(5).slice(0, 5);
+                const name = (j.description || '(unnamed)').padEnd(31).slice(0, 31);
+                const sched = (j.schedule || '?').padEnd(33).slice(0, 33);
+                const stateLabel = j.state.padEnd(11).slice(0, 11);
+                const next = j.nextRun ?? 'never';
+                writeOut(`  ${id} ${name} ${sched} ${stateLabel} ${next}\n`);
+            }
+            return 0;
+        }
+        case 'run': {
+            const id = args[0];
+            if (!id) {
+                writeErr(`Usage: aiden cron run <id>\n`);
+                return 1;
+            }
+            // loadJobs populates the cache + arms timers. The trigger is
+            // what we actually want; arming is side-effect.
+            await (0, cronManager_1.loadJobs)();
+            const ok = await (0, cronManager_1.triggerJob)(id);
+            if (!ok) {
+                writeErr(`Job not found: ${id}\n`);
+                return 1;
+            }
+            writeOut(`Triggered job ${id}.\n`);
+            return 0;
+        }
+        default: {
+            writeErr(`Unknown 'aiden cron' action: ${action}\n`);
+            writeErr(`Actions: status | list | run <id>\n`);
+            return 1;
+        }
+    }
+}