@aragon-agent/cli 0.6.11 → 0.6.13

package/dist/fast/resolve.d.ts

@@ -18,6 +18,7 @@
  * at construction is a tier that can be describing a provider the session no
  * longer uses.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import { type CliConfig } from '../config/schema.js';
 import type { FastTier } from './types.js';
 /**
@@ -29,7 +30,7 @@ import type { FastTier } from './types.js';
  *   `--api-key` override. Injected rather than reimplemented, because a second
  *   key resolver is a second answer to "why does it say no key?".
  */
-export declare function resolveFastTier(config: CliConfig, hasKey: (providerId: string) => boolean): FastTier;
+export declare function resolveFastTier(config: CliConfig, hasKey: (providerId: string, role?: ModelRole) => boolean): FastTier;
 /**
  * The one-line notice for a tier the user switched on that cannot resolve, or
  * `null` when there is nothing worth saying.

package/dist/fast/resolve.js

@@ -47,7 +47,7 @@ export function resolveFastTier(config, hasKey) {
     //        different settings.
     if (!isAdapterProvider(provider))
         return { ok: false, reason: 'no_adapter' };
-    if (!hasKey(provider))
+    if (!hasKey(provider, 'fast'))
         return { ok: false, reason: 'no_key' };
     // 6. A fast tier on the SAME provider inherits the session's base URL: a user
     //    pointing the CLI at a gateway means both models, not one. A fast tier on
@@ -56,9 +56,11 @@ export function resolveFastTier(config, hasKey) {
     const explicitBaseUrl = fast.baseUrl.trim();
     const baseUrl = explicitBaseUrl.length > 0
         ? explicitBaseUrl
-        : provider === config.provider
-            ? config.baseUrl
-            : undefined;
+        : config.modelProfiles?.fastId && !config.modelProfileState?.fast.invalid
+            ? undefined
+            : provider === config.provider
+                ? config.baseUrl
+                : undefined;
     const ref = {
         providerId: provider,
         modelId,

package/dist/fast/wiring.d.ts

@@ -30,6 +30,7 @@
  * inside its own loop with an error naming neither the tier nor the setting that
  * caused it (`agent-loop.ts:140-145`).
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import { type AgentEvent, type AssistantMessage, type LLMRequest, type ModelRef, type ThinkingLevel } from '@aragon-agent/core';
 import type { CliConfig } from '../config/schema.js';
 import type { NoticeLevel } from '../agent/reducer.js';
@@ -38,8 +39,8 @@ export interface FastWiringDeps {
     /** Read LIVE on every call - the controller replaces the object on mutation. */
     getConfig: () => CliConfig;
     /** `AgentController.hasApiKey`, so there is exactly one key resolver. */
-    hasKey: (providerId: string) => boolean;
-    getApiKey: (providerId: string) => string | undefined;
+    hasKey: (providerId: string, role?: ModelRole) => boolean;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     /** Whether the static price table knows this model (C-11 / RV-4). */
     isPricedModel: (ref: Pick<ModelRef, 'providerId' | 'modelId'>) => boolean;
     /** The lead agent's event stream and steering surface. */
@@ -145,7 +146,7 @@ export declare class FastWiring {
      * resolved model id and a prompt naming a model the tier will not use is worse
      * than no prompt at all.
      */
-    onConfigChanged(): void;
+    onConfigChanged(refreshPrompt?: boolean, enabled?: boolean): void;
     /**
      * The startup notice for a configuration mistake that is otherwise invisible
      * (§3.3). Raised once, at construction, through the controller's `notify`.
@@ -162,6 +163,7 @@ export declare class FastWiring {
     resolveTier(tier: FastTierName): {
         ref: ModelRef;
         thinkingLevel: ThinkingLevel;
+        role?: ModelRole;
     };
     /** The resolved fast `ModelRef`, or `null` - for per-tier cost lookup (§3.6). */
     fastRef(): ModelRef | null;

package/dist/fast/wiring.js

@@ -114,7 +114,7 @@ export class FastWiring {
             getTier: () => this.tier,
             getConfig: () => this.deps.getConfig().fast,
             available: () => this.available(),
-            getApiKey: deps.getApiKey,
+            getApiKey: (id) => deps.getApiKey(id, 'fast'),
             emit: (event) => this.emit(event),
             // The reviewer announces its own self-disable with a `tier_changed`, and
             // only the wiring can build the snapshot that carries it.
@@ -202,7 +202,9 @@ export class FastWiring {
      * resolved model id and a prompt naming a model the tier will not use is worse
      * than no prompt at all.
      */
-    onConfigChanged() {
+    onConfigChanged(refreshPrompt = true, enabled) {
+        if (enabled !== undefined)
+            this.enabled = enabled;
         const next = resolveFastTier(this.deps.getConfig(), this.deps.hasKey);
         const before = this.tier;
         this.tier = next;
@@ -219,7 +221,8 @@ export class FastWiring {
                     this.deps.notify('warn', text);
             }
         }
-        this.deps.onPromptChanged();
+        if (refreshPrompt)
+            this.deps.onPromptChanged();
         this.emit({ type: 'tier_changed', snapshot: this.snapshot() });
     }
     /**
@@ -243,7 +246,7 @@ export class FastWiring {
     resolveTier(tier) {
         const config = this.deps.getConfig();
         if (tier === 'fast' && this.delegationAvailable() && this.tier.ok) {
-            return { ref: this.tier.ref, thinkingLevel: this.tier.thinkingLevel };
+            return { ref: this.tier.ref, thinkingLevel: this.tier.thinkingLevel, role: 'fast' };
         }
         return {
             ref: {
@@ -252,6 +255,7 @@ export class FastWiring {
                 ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
             },
             thinkingLevel: config.thinkingLevel,
+            role: 'main',
         };
     }
     /** The resolved fast `ModelRef`, or `null` - for per-tier cost lookup (§3.6). */

package/dist/input/enter-sequences.d.ts

@@ -38,16 +38,17 @@ export interface EnterSequenceSpec {
  * `'\r'` rather than to a newline.
  */
 export declare const ENTER_SEQUENCES: readonly EnterSequenceSpec[];
-/**
- * Rewrite every recognized Enter-family sequence to its normalized token.
- *
- * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
- * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
- * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
- * and other unknown modifiers are deliberately left untouched -- rewriting an
- * unrecognized sequence would be guessing at a terminal dialect we have not
- * seen.
- */
+export type EnterSequenceSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'newline';
+} | {
+    kind: 'submit';
+};
+/** Split explicit keys using the recognition table; bare CR/LF remain text. */
+export declare function splitEnterSequences(text: string): EnterSequenceSegment[];
+/** Normalize explicit Enter keys without changing unknown sequences. */
 export declare function rewriteEnterSequences(text: string): string;
 /**
  * Length of the trailing run of `text` that is a proper prefix of an

package/dist/input/enter-sequences.js

@@ -30,6 +30,7 @@ import { ENTER_NEWLINE_FRAME } from './limits.js';
  * `'\r'` rather than to a newline.
  */
 export const ENTER_SEQUENCES = [
+    { seq: '\x1b[13;1u', meaning: 'enter', to: '\r' },
     {
         seq: '\x1b[13;2u',
         meaning: 'shift+enter',
@@ -88,34 +89,35 @@ export const ENTER_SEQUENCES = [
  * up to 6 of them.
  */
 const MAX_ENTER_PREFIX = Math.max(...ENTER_SEQUENCES.map((s) => s.seq.length)) - 1;
-/** `\x1b[13;2u` .. `\x1b[13;8u`, or `\x1b[13u` when the modifier is absent. */
-const CSI_U_ENTER = /\x1b\[13(?:;[2-8])?u/g;
-/**
- * Rewrite every recognized Enter-family sequence to its normalized token.
- *
- * ONE ANCHORED REGEX, not a per-sequence scan and not a state machine: the
- * CSI-u family shares one shape and the two literal Alt+Enter encodings cannot
- * nest inside it, so a single left-to-right pass is unambiguous. `\x1b[13;9u`
- * and other unknown modifiers are deliberately left untouched -- rewriting an
- * unrecognized sequence would be guessing at a terminal dialect we have not
- * seen.
- */
+/** Split explicit keys using the recognition table; bare CR/LF remain text. */
+export function splitEnterSequences(text) {
+    const segments = [];
+    let start = 0;
+    let index = 0;
+    while (index < text.length) {
+        const match = text[index] === '\x1b'
+            ? ENTER_SEQUENCES.find((spec) => text.startsWith(spec.seq, index)) : undefined;
+        if (!match) {
+            index += 1;
+            continue;
+        }
+        if (index > start)
+            segments.push({ kind: 'text', text: text.slice(start, index) });
+        segments.push({ kind: match.to === '\r' ? 'submit' : 'newline' });
+        index += match.seq.length;
+        start = index;
+    }
+    if (start < text.length)
+        segments.push({ kind: 'text', text: text.slice(start) });
+    return segments;
+}
+/** Normalize explicit Enter keys without changing unknown sequences. */
 export function rewriteEnterSequences(text) {
-    if (!text.includes('\x1b'))
-        return text;
-    // ONE PASS, TWO TARGETS: a MODIFIED Enter is a newline intent, while the
-    // modifier-less CSI-u Enter a leftover kitty mode emits is a PLAIN Enter
-    // and must still submit (`\r`). The `;` is the discriminator the table
-    // above records in each entry's `to` field.
-    let out = text.replace(CSI_U_ENTER, (seq) => (seq.includes(';') ? ENTER_NEWLINE_FRAME : '\r'));
-    // Only the two literal Alt+Enter encodings remain. `\x1b\n` is checked
-    // before `\x1b\r` is replaced; they share no bytes, so order is free, but
-    // splitting the escapes keeps each replacement self-evident.
-    if (out.includes('\x1b\n'))
-        out = out.split('\x1b\n').join(ENTER_NEWLINE_FRAME);
-    if (out.includes('\x1b\r'))
-        out = out.split('\x1b\r').join(ENTER_NEWLINE_FRAME);
-    return out;
+    return splitEnterSequences(text).map((segment) => {
+        if (segment.kind === 'text')
+            return segment.text;
+        return segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME;
+    }).join('');
 }
 /** True when `s` is a PROPER prefix of some recognized sequence (never whole). */
 function isEnterPrefix(s) {

package/dist/input/stdin-filter.js

@@ -33,9 +33,9 @@
  */
 import { PassThrough } from 'node:stream';
 import { MAX_PENDING_MOUSE_CHARS, splitMouseEvents, isMousePrefix, } from './mouse-events.js';
-import { PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
+import { ENTER_NEWLINE_FRAME, PASTE_ASSEMBLY_MAX_MS, PASTE_BURST_MS, PASTE_CLOSE, PASTE_MAX_BYTES, PASTE_OPEN, formatPasteSize, } from './limits.js';
 import { PASTE_BEGIN_MARK, PASTE_END_MARK, classifyChunk, sanitisePaste, trailingPastePrefixLength, } from './paste-parse.js';
-import { rewriteEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
+import { splitEnterSequences, trailingEnterPrefixLength } from './enter-sequences.js';
 /**
  * How long a possible-prefix tail is held before being flushed as text.
  *
@@ -89,7 +89,18 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     let burstTimer = null;
     let assemblyTimer = null;
     let disposed = false;
+    let finished = false;
     let paste = { kind: 'idle' };
+    let discardBracketed = false;
+    let outputBatch = null;
+    const writeInput = (text) => {
+        if (disposed || outputBatch?.refused)
+            return;
+        if (outputBatch)
+            outputBatch.chunks.push(text);
+        else
+            wrapper.write(text);
+    };
     // --- The surface Ink reads off the stream it is handed. ------------------
     // `isRawModeSupported()` reads `props.stdin.isTTY` (App.js:34), so this has
     // to be a DELEGATING GETTER rather than a snapshot: a stdin that is not a TTY
@@ -122,6 +133,8 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     };
     /** `.unref()` so a held tail can never keep the process alive on its own. */
     const arm = (fn, ms) => {
+        if (finished || disposed)
+            return null;
         const t = setTimeout(fn, ms);
         t.unref?.();
         return t;
@@ -143,6 +156,10 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (disposed)
             return;
         if (overflow || bytes > PASTE_MAX_BYTES) {
+            if (outputBatch?.refused)
+                return;
+            if (outputBatch)
+                outputBatch.refused = true;
             const text = `Paste too large (${formatPasteSize(bytes)}); limit is ` +
                 `${formatPasteSize(PASTE_MAX_BYTES)}. Nothing was inserted.`;
             onWarn?.(text);
@@ -153,7 +170,7 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (payload.length === 0)
             return;
         // ONE `write()` call, at the position the paste occupied in the stream.
-        wrapper.write(PASTE_OPEN + payload + PASTE_CLOSE);
+        writeInput(PASTE_OPEN + payload + PASTE_CLOSE);
     };
     const flushBurst = () => {
         burstTimer = clearTimer(burstTimer);
@@ -169,6 +186,12 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             return;
         const { body, bytes, overflow } = paste;
         paste = { kind: 'idle' };
+        if (discardBracketed) {
+            discardBracketed = false;
+            if (outputBatch)
+                outputBatch.refused = true;
+            return;
+        }
         if (reason === 'timeout') {
             // I-4: an unterminated marker must never wedge input. Emitting what
             // arrived is strictly better than holding the keyboard hostage.
@@ -190,20 +213,9 @@ export function createStdinFilter(real, features, bridge, onWarn) {
      * those would corrupt their data silently. v1 covered only Tier 1, which left
      * the loss in place for exactly the terminals Tier 2 exists to serve (P1-7).
      */
-    const handleOutsidePaste = (text, holdTail) => {
+    const handleText = (text, holdTail) => {
         if (text.length === 0)
             return;
-        // ENTER-FAMILY REWRITE, AND IT IS FIRST FOR A REASON
-        // (tui-shift-enter-copy-queue 3.4). The Alt+Enter encoding contains a CR,
-        // and `classifyChunk`'s primary rule -- "longer than one character AND
-        // contains a line break" -- would buffer that two-byte key as a Tier 2
-        // paste body whose sanitiser then strips the ESC, silently swallowing the
-        // keystroke. After the rewrite the frame is NUL-led and classifies as
-        // `keys` under both rules. The cost is that an UNBRACKETED paste whose
-        // body happens to contain the literal Alt+Enter bytes loses that one
-        // pair's newline; a bracketed body never reaches this function at all
-        // (I-3), and losing two bytes of a heuristic tier beats eating the key.
-        text = rewriteEnterSequences(text);
         if (paste.kind === 'burst') {
             paste = { kind: 'burst', body: paste.body + text, bytes: paste.bytes + byteLength(text) };
             burstTimer = clearTimer(burstTimer);
@@ -216,15 +228,16 @@ export function createStdinFilter(real, features, bridge, onWarn) {
             burstTimer = arm(flushBurst, PASTE_BURST_MS);
             return;
         }
-        // Step 0: with `mouse` false this degenerates to "pass the text on", which
-        // is byte-identical to the unwrapped stream.
+        // Ink conflates DEL Backspace with CSI Delete. Normalize only keyboard
+        // text, after burst classification, preserving ESC for Alt+Backspace.
+        text = text.replace(/\x7f/g, '\x08');
         if (!features.mouse) {
-            wrapper.write(text);
+            writeInput(text);
             return;
         }
         const split = splitMouseEvents(text);
         if (split.text.length > 0)
-            wrapper.write(split.text);
+            writeInput(split.text);
         for (const event of split.events)
             emit(event);
         if (split.pending.length === 0)
@@ -236,10 +249,23 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         if (holdTail)
             pending += split.pending;
         else
-            wrapper.write(split.pending);
+            writeInput(split.pending);
+    };
+    const handleOutsidePaste = (text, holdTail) => {
+        const segments = splitEnterSequences(text);
+        for (let index = 0; index < segments.length; index += 1) {
+            const segment = segments[index];
+            if (segment.kind === 'text') {
+                handleText(segment.text, holdTail && index === segments.length - 1);
+                continue;
+            }
+            // A key terminates the heuristic paste before its internal frame is written.
+            flushBurst();
+            writeInput(segment.kind === 'submit' ? '\r' : ENTER_NEWLINE_FRAME);
+        }
     };
     const appendBracketed = (text) => {
-        if (paste.kind !== 'bracketed' || text.length === 0)
+        if (paste.kind !== 'bracketed' || text.length === 0 || discardBracketed)
             return;
         const bytes = paste.bytes + byteLength(text);
         const overflow = paste.overflow || bytes > PASTE_MAX_BYTES;
@@ -315,13 +341,39 @@ export function createStdinFilter(real, features, bridge, onWarn) {
         handleOutsidePaste(text, false);
     };
     const onData = (chunk) => {
-        if (disposed)
+        if (disposed || finished)
             return;
         flushTimer = clearTimer(flushTimer);
         const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
         const carried = pending;
         pending = '';
-        feed(carried + decoded);
+        // A rejected paste must not leave earlier text or a later Enter executable.
+        const batch = { chunks: [], refused: false };
+        outputBatch = batch;
+        try {
+            feed(carried + decoded.replace(/\u0000/g, ''));
+        }
+        finally {
+            outputBatch = null;
+        }
+        if (batch.refused) {
+            burstTimer = clearTimer(burstTimer);
+            if (paste.kind === 'bracketed') {
+                // Keep consuming an unfinished body so its next chunk cannot become keys.
+                discardBracketed = true;
+                paste = { kind: 'bracketed', body: '', bytes: 0, overflow: false };
+            }
+            else {
+                pending = '';
+                paste = { kind: 'idle' };
+                assemblyTimer = clearTimer(assemblyTimer);
+            }
+            return;
+        }
+        if (disposed || finished)
+            return;
+        for (const text of batch.chunks)
+            wrapper.write(text);
         if (paste.kind === 'bracketed' || pending.length === 0)
             return;
         if (pending.length > MAX_PENDING_CHARS) {
@@ -337,11 +389,24 @@ export function createStdinFilter(real, features, bridge, onWarn) {
     // P2-7: a closed stdin must still terminate Ink's reader, or it waits forever
     // on a stream that will never produce another byte.
     const onEnd = () => {
-        flushBracketed('timeout');
-        flushBurst();
-        flushPending();
-        if (!wrapper.writableEnded)
-            wrapper.end();
+        if (finished || disposed)
+            return;
+        finished = true;
+        flushTimer = clearTimer(flushTimer);
+        burstTimer = clearTimer(burstTimer);
+        assemblyTimer = clearTimer(assemblyTimer);
+        const tail = pending;
+        pending = '';
+        if (paste.kind === 'bracketed') {
+            appendBracketed(tail);
+            flushBracketed('timeout');
+        }
+        else {
+            // The pending prefix belongs to the currently open burst, if any.
+            handleOutsidePaste(tail, false);
+            flushBurst();
+        }
+        wrapper.end();
     };
     // `setEncoding('utf8')` on the REAL stream so Node's StringDecoder handles
     // multi-byte boundaries for us -- the scan works on characters, and a UTF-8

package/dist/logging/install.d.ts

@@ -144,6 +144,9 @@ export interface AgentEventSource {
  */
 export type AgentLogEvent = {
     type: 'agent_start';
+} | {
+    type: 'steering_accepted';
+    ids: readonly string[];
 } | {
     type: 'agent_end';
     messages: unknown[];

package/dist/logging/install.js

@@ -42,7 +42,7 @@ import { readConfigFile } from '../config/store.js';
 import { clampLogConfig } from '../config/schema.js';
 import { clampLogLevel } from './levels.js';
 import { Logger, setActiveLogger } from './logger.js';
-import { registerSecretsFrom } from './secret-registry.js';
+import { registerProfileSecrets, registerSecretsFrom } from './secret-registry.js';
 /** POSIX signal numbers for the `128 + signo` exit-code convention. */
 const SIGNAL_NUMBERS = { SIGINT: 2, SIGTERM: 15, SIGHUP: 1 };
 let screenRestore = () => { };
@@ -213,7 +213,9 @@ export function installLogging(opts = {}) {
     // Registration site 1 (§4.4.3): whatever the config file already holds. Sites
     // 2, 3, 4 and 5 add the env, the merged view plus `--api-key`, the settings
     // screen, and every persisted write respectively.
-    registerSecretsFrom(readConfigFile().config?.apiKeys ?? undefined);
+    const persisted = readConfigFile().config;
+    registerSecretsFrom(persisted?.apiKeys ?? undefined);
+    registerProfileSecrets(persisted);
     const warning = getHomeResolutionWarning();
     if (warning)
         logger.warn('cli', 'home_resolution_fallback', { reason: warning });

package/dist/logging/secret-registry.d.ts

@@ -18,6 +18,8 @@
 export declare function registerSecret(value: string | undefined | null): void;
 /** Convenience for the `apiKeys` maps every registration site happens to hold. */
 export declare function registerSecretsFrom(keys: Record<string, string | null | undefined> | undefined): void;
+/** Register dedicated credentials in untrusted parsed config before schema validation. */
+export declare function registerProfileSecrets(value: unknown): void;
 /**
  * Every known secret, LONGEST FIRST.
  *

package/dist/logging/secret-registry.js

@@ -39,6 +39,24 @@ export function registerSecretsFrom(keys) {
     for (const value of Object.values(keys))
         registerSecret(value);
 }
+/** Register dedicated credentials in untrusted parsed config before schema validation. */
+export function registerProfileSecrets(value) {
+    if (!value || typeof value !== 'object')
+        return;
+    const profiles = value.modelProfiles;
+    if (!profiles || typeof profiles !== 'object')
+        return;
+    const entries = profiles.entries;
+    if (!Array.isArray(entries))
+        return;
+    for (const entry of entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const key = entry.apiKey;
+        if (typeof key === 'string')
+            registerSecret(key);
+    }
+}
 /**
  * Every known secret, LONGEST FIRST.
  *

package/dist/session/persist.d.ts

@@ -39,14 +39,13 @@ export interface SessionMeta {
 export interface SavedSession {
     version: number;
     savedAt: number;
-    model: ModelRef;
+    model?: ModelRef;
     messages: Message[];
     entries: Entry[];
     /**
      * The live todo list at save time (todo-plan-execution §3.13).
      *
-     * `SESSION_VERSION` STAYS 1: the field is additive and optional, `loadSession`
-     * validates only that `messages` and `entries` are arrays, and an older file
+     * `SESSION_VERSION` STAYS 1: the field is additive and optional, and an older file
      * simply yields `undefined` — which `restoreTodos` treats as "clear", the
      * right answer for a session that predates the feature (D-20 / D-22).
      */
@@ -56,8 +55,8 @@ export interface SavedSession {
      *
      * `SESSION_VERSION` STAYS 1 for the reason `todos?` records above, and this is
      * the precedent that file's own comments already set: the field is additive
-     * and optional, and `loadSession` validates only array-ness of `messages` /
-     * `entries`. A TUI `/save` file simply has no `meta`, which is exactly how
+     * and optional. Boundary validation preserves it without changing its shape.
+     * A TUI `/save` file simply has no `meta`, which is exactly how
      * `sessions list` tells the two apart.
      */
     meta?: SessionMeta;
@@ -88,8 +87,8 @@ export declare function saveSession(filePath: string, data: {
  * Settle any team entry that was saved mid-dispatch (team-subagents §5.3 / P1-5),
  * and any todo card that was saved mid-run (todo-plan-execution §3.8 / C-5).
  *
- * `saveSession` writes `entries` verbatim and `loadSession` validates only
- * array-ness, so a session saved while a dispatch was in flight resumes with a
+ * Structural validation cannot settle live state: a session saved while a
+ * dispatch was in flight can contain a valid
  * `kind: 'team'` entry claiming `active: true` while nothing is running. TWO
  * things then go wrong at once: the card spins forever, and `Transcript`'s
  * settled boundary is MONOTONIC — an entry that never settles never reaches

package/dist/session/persist.js

@@ -8,6 +8,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { getSessionsDir } from '../config/store.js';
+import { validateSession } from './validate-session.js';
 const SESSION_VERSION = 1;
 /** Resolve a `/save` target: absolute/relative path, or a name in the data dir. */
 export function resolveSessionPath(nameOrPath, cwd) {
@@ -109,8 +110,8 @@ export function saveSession(filePath, data) {
  * Settle any team entry that was saved mid-dispatch (team-subagents §5.3 / P1-5),
  * and any todo card that was saved mid-run (todo-plan-execution §3.8 / C-5).
  *
- * `saveSession` writes `entries` verbatim and `loadSession` validates only
- * array-ness, so a session saved while a dispatch was in flight resumes with a
+ * Structural validation cannot settle live state: a session saved while a
+ * dispatch was in flight can contain a valid
  * `kind: 'team'` entry claiming `active: true` while nothing is running. TWO
  * things then go wrong at once: the card spins forever, and `Transcript`'s
  * settled boundary is MONOTONIC — an entry that never settles never reaches
@@ -196,7 +197,7 @@ export function normalizeLoadedEntries(entries) {
         // THE SEVENTH CLAUSE (tui-shift-enter-copy-queue 5.2.5). Core's steering
         // queue is memory-only, so a `queued` entry on disk is a promise this
         // process can no longer keep: the message was never accepted into any
-        // conversation. Downgrade to a WARN NOTICE carrying the first line
+        // conversation. Downgrade to a WARN NOTICE carrying the full text
         // rather than to a `user` entry -- pretending it was sent is the lie
         // that loses the user's words with a straight face.
         //
@@ -204,12 +205,11 @@ export function normalizeLoadedEntries(entries) {
         // live transcript, and a fresh id here would collide with the next
         // `e<n>` the reducer allocates.
         if (entry.kind === 'queued') {
-            const firstLine = entry.text.split('\n', 1)[0] ?? '';
             const downgraded = {
                 id: entry.id,
                 kind: 'notice',
                 level: 'warn',
-                text: `Queued but never sent: ${firstLine}`,
+                text: `Queued but never sent: ${entry.text}`,
             };
             return downgraded;
         }
@@ -218,9 +218,6 @@ export function normalizeLoadedEntries(entries) {
 }
 export function loadSession(filePath) {
     const raw = readFileSync(filePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || !Array.isArray(parsed.messages) || !Array.isArray(parsed.entries)) {
-        throw new Error('Invalid session file (missing messages/entries).');
-    }
+    const parsed = validateSession(JSON.parse(raw));
     return { ...parsed, entries: normalizeLoadedEntries(parsed.entries) };
 }

package/dist/session/store.d.ts

@@ -18,6 +18,7 @@
  * command the docs recommend. `list` and `prune` therefore see only files
  * carrying `meta.id`; `show` and `rm` accept any id, because the user named it.
  */
+import type { ModelRef } from '@aragon-agent/core';
 import { type SavedSession, type SessionMeta } from './persist.js';
 /**
  * The id is a FILENAME under the user's home directory, and the caller supplying
@@ -84,7 +85,9 @@ export declare function readSessionFile(path: string): SavedSession | null;
 export declare function resolveSessionRef(idOrPath: string, cwd: string): string | null;
 export interface WriteSessionInput {
     id: string;
-    session: Omit<SavedSession, 'version' | 'savedAt' | 'meta'>;
+    session: Omit<SavedSession, 'version' | 'savedAt' | 'meta' | 'model'> & {
+        model: ModelRef;
+    };
     meta: SessionMeta;
 }
 /**

package/dist/session/validate-session.d.ts

@@ -0,0 +1,3 @@
+import type { SavedSession } from './persist.js';
+/** Return a prepared copy, preserving extensions; throw with the corrupt field path. */
+export declare function validateSession(value: unknown): SavedSession;