aiden-runtime 4.1.4 → 4.5.0

package/dist/cli/v4/chatSession.js

@@ -69,6 +69,11 @@ exports.renderProgressBar = renderProgressBar;
 exports.formatTokens = formatTokens;
 exports.formatDuration = formatDuration;
 exports.renderMemoryConfirmations = renderMemoryConfirmations;
+// v4.1.5+ Path A: env-var-gated loop trace logger. Captures tool-call
+// sequence + system prompt + memory hashes when a turn shows loop
+// symptoms (10+ calls OR 5+ consecutive same-name). Default off via
+// `AIDEN_DEBUG_LOOP=1` env-var. Zero overhead when disabled.
+const loopTrace_1 = require("../../core/v4/loopTrace");
 const display_1 = require("./display");
 // v4.1.4 Part 1.6 — per-turn token progress bar. Fed by `onProgress`
 // events from the streaming adapter; hidden when the adapter doesn't
@@ -867,6 +872,21 @@ class ChatSession {
         }
     }
     async runAgentTurn(userInput) {
+        // v4.5 Phase 8b — daemon-scheduling intent check on the user's
+        // initial message. Classifies regex hits like "every day at",
+        // "watch this folder", "when an email arrives" — and queues a
+        // tip to render at the END of the agent's response (so it
+        // doesn't crowd the agent's actual reply). Engine handles
+        // budget + dismissal.
+        let _deferredTip = null;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { getSuggestionEngine } = require('../../core/v4/suggestionEngine');
+            const t = getSuggestionEngine().checkInitialMessage(userInput);
+            if (t)
+                _deferredTip = t;
+        }
+        catch { /* defensive — never block a turn on a suggestion */ }
         // Phase 30.2.1 — explore mode: short-circuit BEFORE building the
         // turn-status spinner / agent call. The wizard skipped, so there's
         // no real provider to talk to. Print a friendly redirect to /setup
@@ -934,6 +954,62 @@ class ChatSession {
         const indicator = this.opts.display.activityIndicator('thinking');
         let indicatorStopped = false;
         let streamingActive = false;
+        // v4.1.5 Issue O — track whether this turn had any tool calls so
+        // we can emit a single muted rule between the tool trail and the
+        // reply header. Set true when the first tool's `before` phase
+        // fires (via the existing beforeFirstToolHook plumbing). Emitted
+        // once per turn — `separatorEmitted` gates idempotency against
+        // both streaming and non-streaming paths reaching the same hook.
+        //
+        // v4.1.5 Phase 1d (Q-OBV-b) — multi-tool separator regression:
+        // the prior v4.1.5 Phase 1c emission point was the streaming
+        // `onFirstDelta` callback, but that fires PER provider call
+        // (the agent resets `firstDeltaFired` each callProvider
+        // invocation), and on multi-tool turns where the model emits
+        // no preamble in early iterations + no preamble in the final
+        // reply iteration either, the relative ordering of "first
+        // delta" vs "first tool" could leave the flag/idempotency
+        // gate in an unexpected state. Definitive fix: tie emission
+        // to the FIRST STREAM BYTE LANDING ON SCREEN, which only
+        // happens once per turn regardless of how many provider
+        // iterations occurred. `firstStreamByteSeen` is the new gate;
+        // separator fires from inside `onDelta` BEFORE `streamPartial`
+        // writes the agent header.
+        let turnHadTools = false;
+        let separatorEmitted = false;
+        let firstStreamByteSeen = false;
+        // v4.1.5+ Path A: per-turn loop tracer (env-var gated, default off).
+        // Captures tool-call sequence + assembled system prompt + memory
+        // hashes + recent skills when a turn trips loop thresholds. The
+        // `onLoopWarning` callback surfaces a one-line dim hint to the
+        // user when consecutive-same-tool count crosses 8 — gives them a
+        // chance to Ctrl+C before the agent burns more budget.
+        const loopTracer = new loopTrace_1.LoopTracer({
+            paths: this.opts.paths,
+            providerId: this.currentProviderId,
+            modelId: this.currentModelId,
+            onLoopWarning: (line) => {
+                try {
+                    this.opts.display.dim(line);
+                }
+                catch { /* defensive */ }
+            },
+        });
+        if (loopTracer.isEnabled()) {
+            loopTracer.setHistory(baseHistory);
+        }
+        const emitToolReplySeparator = () => {
+            if (separatorEmitted || !turnHadTools)
+                return;
+            separatorEmitted = true;
+            // Same chrome pattern as the existing pre-turn rule (line ~1100)
+            // and the post-reply rule (line ~1297): two-space indent + the
+            // body-width muted rule + newline. The 2-space indent is the
+            // legacy convention used by adjacent rules; the v4.1.5 frame
+            // gutter (3) is consciously NOT applied here so all three rules
+            // in a turn share one left edge.
+            this.opts.display.write(`  ${this.opts.display.rule()}\n`);
+        };
         const stopIndicatorOnce = () => {
             if (indicatorStopped)
                 return;
@@ -946,12 +1022,55 @@ class ChatSession {
                 this.opts.callbacks.setActivityIndicatorHooks?.({});
             }
             catch { /* defensive */ }
+            // v4.1.5 Issue K — also clear the phase-verb sink so lifecycle
+            // events fired during async cleanup don't try to update a
+            // stopped indicator.
+            try {
+                this.opts.callbacks.setPhaseVerbHook?.(undefined);
+            }
+            catch { /* defensive */ }
+            // v4.1.5+ Path A — clear the loop-trace sink so subsequent
+            // turns don't fire into a stale tracer. Note: this clears the
+            // HOOK, not the tracer's accumulated state — finalize() still
+            // runs at end-of-try below to write the snapshot if thresholds
+            // tripped.
+            try {
+                this.opts.callbacks.setToolTraceHook?.({});
+            }
+            catch { /* defensive */ }
         };
+        // v4.1.5 Issue K — wire the per-turn phase-verb sink. Each
+        // AidenAgent lifecycle event (memory refresh start, prompt built,
+        // provider request start) flows through CliCallbacks and lands
+        // here as a verb string ("refreshing memory" / "preparing prompt"
+        // / "calling provider"). The closure captures the per-turn
+        // indicator handle so verb mutations stay scoped to this turn.
+        this.opts.callbacks.setPhaseVerbHook?.((verb) => {
+            if (indicatorStopped)
+                return;
+            indicator.setVerb(verb);
+        });
+        // v4.1.5+ Path A — wire the loop-trace sink. Fires for EVERY tool
+        // call (including hidden ones) so the trace captures the full
+        // agent loop. Defensive — when AIDEN_DEBUG_LOOP is unset, the
+        // tracer's `startTool`/`endTool` short-circuit immediately.
+        this.opts.callbacks.setToolTraceHook?.({
+            before: (id, name) => loopTracer.startTool(id, name),
+            after: (id, name, args) => loopTracer.endTool(id, name, args),
+        });
         // Phase 23.5 carried forward: stop the indicator the moment the
         // first tool row prints — the row itself is the activity surface
         // during a tool. Part 1.6 then resumes via `afterEachTool` so the
         // post-tool gap has its own indicator paint.
-        this.opts.callbacks.setBeforeFirstToolHook?.(stopIndicatorOnce);
+        //
+        // v4.1.5 Issue O — also flip `turnHadTools = true` so the
+        // separator emits before the reply header. Single hook captures
+        // "any tool ran this turn" cleanly (it only fires for the FIRST
+        // tool of the turn — subsequent tools don't re-trigger).
+        this.opts.callbacks.setBeforeFirstToolHook?.(() => {
+            turnHadTools = true;
+            stopIndicatorOnce();
+        });
         // Part 1.6: pause/resume hooks around every tool row. The
         // `beforeTool` hook fires before EACH tool row writes (not just
         // the first), so multi-tool sequences also keep the indicator
@@ -991,10 +1110,32 @@ class ChatSession {
                     ? () => {
                         stopIndicatorOnce();
                         streamingActive = true;
+                        // v4.1.5 Phase 1d (Q-OBV-b) — separator emission MOVED
+                        // out of onFirstDelta because that callback fires per
+                        // provider-call iteration (firstDeltaFired resets each
+                        // callProvider invocation). The separator-emit now
+                        // lives in onDelta below, gated by `firstStreamByteSeen`
+                        // which only flips once per turn.
                     }
                     : undefined,
                 onDelta: streamingEnabled
                     ? (text) => {
+                        // v4.1.5 Phase 1d (Q-OBV-b) — definitive separator
+                        // emission point. This is the FIRST text byte landing
+                        // on screen this turn. Fires the muted rule BEFORE
+                        // streamPartial writes the `┃ Aiden` header so the
+                        // visual order is:
+                        //   ┊ tool rows...
+                        //   ────────────  ← separator
+                        //   ┃ Aiden
+                        //   {text}
+                        // Idempotent via `firstStreamByteSeen` + the
+                        // `separatorEmitted` flag inside emitToolReplySeparator.
+                        // No-op when no tool fired (turnHadTools=false).
+                        if (!firstStreamByteSeen) {
+                            firstStreamByteSeen = true;
+                            emitToolReplySeparator();
+                        }
                         // v4.1.4 Part 1.6: bar lives ABOVE streamed text. Hide
                         // it before each delta writes so the stream output
                         // doesn't land on the bar's line. The bar repaints on
@@ -1052,11 +1193,56 @@ class ChatSession {
             if (result.toolCallTrace && result.toolCallTrace.length > 0) {
                 this.sessionToolTrace.push(...result.toolCallTrace);
             }
-            // When streaming was active and emitted the final content already,
-            // skip the markdown re-render — we'd otherwise duplicate text.
-            if (result.finalContent && !streamingActive) {
+            // v4.1.6 spike (TCE) — tool-loop terminal surface. When the
+            // agent ended the turn via the recovery controller's surface
+            // stage, render a structured-failure card instead of the
+            // (empty) reply. Same chrome as auth / platform capability
+            // cards — fits the established Aiden UX language for
+            // "the action you wanted didn't happen, here's why and what
+            // you can do." Surface BEFORE the tool→reply separator path
+            // below because there's no agent reply to introduce.
+            if (result.finishReason === 'tool_loop' && result.toolLoopCard) {
+                // Emit the muted rule so the card visually separates from
+                // the tool trail above it.
+                emitToolReplySeparator();
+                this.opts.display.capabilityCard(result.toolLoopCard);
+            }
+            else if (result.finalContent && !streamingActive) {
+                // When streaming was active and emitted the final content
+                // already, skip the markdown re-render — we'd otherwise
+                // duplicate text.
+                //
+                // v4.1.5 Issue O — non-streaming reply path. Emit the muted
+                // rule between the tool trail and the agent header before
+                // the one-shot reply lands. Idempotent + tool-gated by
+                // `emitToolReplySeparator`.
+                emitToolReplySeparator();
                 this.opts.display.write(this.opts.display.agentTurn(result.finalContent));
             }
+            // v4.1.6 Polish 2 — post-render skill-proposal handler.
+            // The agent loop now SKIPS the inquirer prompt when a
+            // prompt callback is wired, surfacing the SkillProposal
+            // here instead. We fire the prompt AFTER the agent reply
+            // has rendered so the user sees the answer before being
+            // asked "save this as a reusable skill?" — fixing the
+            // v4.1.5 visual-smoke regression where the prompt fired
+            // mid-turn and clobbered the reply.
+            //
+            // Wrapped in try/catch so a buggy proposal flow never
+            // breaks the chat loop. A successful save surfaces a
+            // dim confirmation line that fits the established
+            // memory-confirmation chrome.
+            if (result.skillProposal && this.opts.callbacks?.handleSkillProposal) {
+                try {
+                    const saveResult = await this.opts.callbacks.handleSkillProposal(result.skillProposal);
+                    if (saveResult?.created && saveResult.skillName) {
+                        this.opts.display.dim(`  ✓ Saved as skill: ${saveResult.skillName}`);
+                    }
+                }
+                catch {
+                    /* defensive — never let proposal flow break the chat loop */
+                }
+            }
             if (this.sessionId) {
                 // Only persist the new tail of messages — what got added this turn.
                 const newSlice = this.history.slice(turnStart);
@@ -1064,10 +1250,36 @@ class ChatSession {
             }
             this.setStatusState({ kind: 'ready' });
             this.lastTurnElapsedMs = Date.now() - turnStartedAt;
+            // v4.5 Phase 8b — surface a deferred daemon-scheduling tip
+            // queued at turn start. Renders AFTER the agent's response per
+            // Q-P8b-3(b) — the user reads the answer first, then sees the
+            // ambient capability hint.
+            if (_deferredTip) {
+                try {
+                    this.opts.display.dim(_deferredTip.message);
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    const { getSuggestionEngine } = require('../../core/v4/suggestionEngine');
+                    getSuggestionEngine().recordFired(_deferredTip.slot);
+                }
+                catch { /* defensive */ }
+                _deferredTip = null;
+            }
             // Tier-3.1a: dim full-width rule between the agent reply and the
             // post-turn status footer.
             this.opts.display.write(`  ${this.opts.display.rule()}\n`);
             this.renderStatusLine();
+            // v4.1.5+ Path A — finalize the loop trace. No-op if the env
+            // var is unset OR if the turn didn't trip any threshold. When
+            // it DOES emit, the snapshot path goes to a dim status line so
+            // the user (and any teammate they're sharing the log with)
+            // knows where to grab the diagnostic file.
+            try {
+                const snapPath = await loopTracer.finalize();
+                if (snapPath) {
+                    this.opts.display.dim(`[loop-trace] wrote ${snapPath}`);
+                }
+            }
+            catch { /* defensive */ }
         }
         catch (err) {
             stopIndicatorOnce();
@@ -1116,6 +1328,16 @@ class ChatSession {
             }
             this.setStatusState({ kind: 'ready' });
             this.lastTurnElapsedMs = Date.now() - turnStartedAt;
+            // v4.1.5+ Path A — finalize the loop trace on the error path
+            // too. Loop patterns that ended in an error are exactly the
+            // ones most worth capturing for diagnosis.
+            try {
+                const snapPath = await loopTracer.finalize();
+                if (snapPath) {
+                    this.opts.display.dim(`[loop-trace] wrote ${snapPath}`);
+                }
+            }
+            catch { /* defensive */ }
         }
     }
     // ── Startup card (Phase 26.2.4: neofetch-style sectioned) ──────────
@@ -1196,6 +1418,9 @@ class ChatSession {
             providerOk: !this.opts.unconfigured,
             version: version_1.VERSION,
         }) + '\n');
+        // v4.5 TUI polish — blank line so the status pills row doesn't
+        // crowd the muted source annotation right beneath it.
+        display.write('\n');
         // v4.1.3-prebump: dim source annotation under the pills row so the
         // user can see WHY this provider/model was chosen — closes the
         // information gap that made Case 3 (persisted-config) look like a
@@ -1255,10 +1480,73 @@ class ChatSession {
         }
         // Scroll footer (parchment at ≥80 cols, single-line credits below).
         display.write(display.scrollFooter() + '\n');
+        // v4.5 update system — boxed three-option prompt rendered AFTER
+        // the boot card / status pills (Q-U5b less-intrusive position),
+        // BEFORE the bottomPromptHint. Fires only when:
+        //   - update check came back with `updateAvailable && !skipped`
+        //   - stdin is a TTY (non-interactive boots short-circuit to 'later')
+        // 5-second timeout defaults to 'later' so a user away from
+        // keyboard isn't held up. Skip-on-'n' writes the version to the
+        // .update_check.json cache so subsequent boots stay quiet until
+        // a newer release ships.
+        try {
+            await this.maybeShowBootUpdatePrompt();
+        }
+        catch { /* never let the update prompt crash boot */ }
         // Bottom prompt hint — final line of the boot card.
         display.write('\n');
         display.write(display.bottomPromptHint() + '\n');
     }
+    /**
+     * v4.5 update system — orchestrates the boot prompt. Lazy-imports
+     * the update modules so non-boot code paths (e.g. test harness
+     * sessions constructed without paths wired) don't pay the cost.
+     */
+    async maybeShowBootUpdatePrompt() {
+        if (!this.opts.paths)
+            return;
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const cu = require('../../core/v4/update/checkUpdate');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const md = require('../../core/v4/update/installMethodDetect');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const ss = require('../../core/v4/update/skipState');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const bp = require('./updateBootPrompt');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const ei = require('../../core/v4/update/executeInstall');
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const ver = require('../../core/version');
+        const status = await cu.checkForUpdate({ paths: this.opts.paths, installedVersion: ver.VERSION });
+        if (!status.updateAvailable || !status.latest || status.skipped)
+            return;
+        const method = md.detectInstallMethod();
+        const choice = await bp.showBootUpdatePrompt({
+            status, method,
+            display: { write: (s) => this.opts.display.write(s), dim: (s) => this.opts.display.dim(s) },
+        });
+        if (choice === 'install') {
+            if (method.inProcessInstallSupported) {
+                this.opts.display.write(`Installing aiden-runtime ${status.latest}…\n`);
+                const result = await ei.executeInstall({ packageSpec: `aiden-runtime@${status.latest}` });
+                if (result.success) {
+                    this.opts.display.write(`  ✓ aiden-runtime ${result.installedVersion ?? status.latest} installed.\n`);
+                    this.opts.display.dim('Restart Aiden to apply: type /quit then re-run `aiden`.');
+                }
+                else {
+                    this.opts.display.warn(result.error ?? 'Install failed (no error message).');
+                }
+            }
+            else {
+                this.opts.display.write(`To update, run:\n  ${method.updateCommand(status.latest)}\n`);
+            }
+        }
+        else if (choice === 'skip') {
+            await cu.updateCacheFile(this.opts.paths, (current) => ss.applySkip(current, status.latest));
+            this.opts.display.dim(`  skipped ${status.latest}. Boot prompt resumes when a newer version ships.`);
+        }
+        // 'later' = no-op; prompt fires again next session.
+    }
     /** Phase 22 Task 4: state transitions for the right-most segment. */
     setStatusState(state) {
         this.statusState = state;

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

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/_runtimeToggleHelpers.ts — v4.5 Phase 8a.
+ *
+ * Shared `flip` + `printStatus` helpers used by /sandbox, /tce, and
+ * /browser-depth. Each subsystem command is a tiny wrapper over
+ * these — same on/off/status surface, same status format.
+ *
+ * The persist path goes through `ConfigManager.set()` + `save()` so
+ * the runtime_toggles section is written verbatim to config.yaml.
+ * The runtimeToggles singleton's `set()` then fires onChange
+ * callbacks for cached consumers (sandboxConfig's singleton).
+ *
+ * Test seam: `flip` and `printStatus` accept a `ctx` shaped like
+ * SlashCommandContext (just `display`, optionally `config`). Tests
+ * pass a minimal stub.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flip = flip;
+exports.printStatus = printStatus;
+exports.parseSubcommand = parseSubcommand;
+const runtimeToggles_1 = require("../../../core/v4/runtimeToggles");
+const LABEL = {
+    sandbox: 'Sandbox',
+    tce: 'TCE',
+    browser_depth: 'Browser depth',
+    suggestions: 'Suggestions',
+};
+const CONFIG_DOTTED = {
+    sandbox: 'runtime_toggles.sandbox',
+    tce: 'runtime_toggles.tce',
+    browser_depth: 'runtime_toggles.browser_depth',
+    suggestions: 'runtime_toggles.suggestions',
+};
+/**
+ * Apply a toggle change. When `ctx.config` is wired, persists to
+ * config.yaml. Otherwise the flip is in-process only (current
+ * session sees the new value; next process boot doesn't).
+ *
+ * Returns nothing — prints status via ctx.display.
+ */
+async function flip(key, value, ctx) {
+    const rt = (0, runtimeToggles_1.getRuntimeToggles)();
+    // Persist when a ConfigManager is wired.
+    if (ctx.config) {
+        try {
+            ctx.config.set(CONFIG_DOTTED[key], value);
+            await ctx.config.save();
+        }
+        catch (e) {
+            ctx.display.warn(`[${key}] config.yaml save failed (${e instanceof Error ? e.message : String(e)}); ` +
+                `flip applies to this session only.`);
+        }
+    }
+    await rt.set(key, value, { persist: false });
+    printStatus(key, ctx);
+}
+/**
+ * Print the current state of one toggle. One-line output per
+ * Q-P8a-2(a):
+ *
+ *   `Sandbox: ON   (source: config)`
+ *
+ * `source` reveals which precedence layer provided the value —
+ * critical for debugging "why is it ON when my .env says 0".
+ */
+function printStatus(key, ctx) {
+    const snap = (0, runtimeToggles_1.getRuntimeToggles)().snapshot()[key];
+    const label = LABEL[key];
+    const state = snap.value ? 'ON' : 'OFF';
+    ctx.display.write(`${label}: ${state}   (source: ${snap.source})\n`);
+}
+/**
+ * Parse the on/off/status subcommand. Returns null when the input
+ * is unrecognised (caller prints usage).
+ */
+function parseSubcommand(raw) {
+    const s = (raw ?? 'status').toLowerCase();
+    if (s === 'on' || s === 'enable' || s === '1' || s === 'true')
+        return 'on';
+    if (s === 'off' || s === 'disable' || s === '0' || s === 'false')
+        return 'off';
+    if (s === 'status' || s === '' || s === undefined)
+        return 'status';
+    return null;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/commands/browserDepth.ts — v4.5 Phase 8a.
+ *
+ * `/browser-depth on|off|status` — flip the v4.3 state-aware
+ * browser observer (URL/DOM/iframe-tree capture, stale-ref retry,
+ * manual-blocker detection) without restart. Persists to
+ * config.yaml. Env var AIDEN_BROWSER_DEPTH always wins.
+ *
+ * Q-P8a-5(a): named `/browser-depth` to mirror the env var
+ * exactly. Reserves `/browser` for future browser-navigation
+ * commands so the namespace stays unambiguous.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserDepth = void 0;
+const _runtimeToggleHelpers_1 = require("./_runtimeToggleHelpers");
+exports.browserDepth = {
+    name: 'browser-depth',
+    description: 'Toggle the v4.3 state-aware browser observer.',
+    category: 'system',
+    icon: '🌐',
+    handler: async (ctx) => {
+        const sub = (0, _runtimeToggleHelpers_1.parseSubcommand)(ctx.args[0]);
+        if (sub === 'on') {
+            await (0, _runtimeToggleHelpers_1.flip)('browser_depth', true, ctx);
+            return {};
+        }
+        if (sub === 'off') {
+            await (0, _runtimeToggleHelpers_1.flip)('browser_depth', false, ctx);
+            return {};
+        }
+        if (sub === 'status') {
+            (0, _runtimeToggleHelpers_1.printStatus)('browser_depth', ctx);
+            return {};
+        }
+        ctx.display.printError('Usage: /browser-depth on|off|status');
+        return {};
+    },
+};