@aragon-agent/cli 0.6.11 → 0.6.13

package/dist/session/validate-session.js

@@ -0,0 +1,207 @@
+import { isAdapterProvider } from '../config/schema.js';
+import { normalizeTodos } from '../todo/normalize.js';
+import { TODO_LIMITS } from '../todo/limits.js';
+function fail(path, expected) {
+    throw new Error(`Invalid session file: ${path} must be ${expected}.`);
+}
+function record(value, path) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        fail(path, 'an object');
+    }
+    return value;
+}
+const string = (value, path) => {
+    if (typeof value !== 'string')
+        fail(path, 'a string');
+};
+const nonempty = (value, path) => {
+    if (typeof value !== 'string' || value.trim().length === 0)
+        fail(path, 'a non-empty string');
+};
+const number = (value, path) => {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        fail(path, 'a finite number');
+};
+const boolean = (value, path) => {
+    if (typeof value !== 'boolean')
+        fail(path, 'a boolean');
+};
+const object = (value, path) => { record(value, path); };
+function optional(check) {
+    return (value, path) => { if (value !== undefined)
+        check(value, path); };
+}
+function enumeration(...values) {
+    return (value, path) => {
+        if (typeof value !== 'string' || !values.includes(value))
+            fail(path, values.join(' | '));
+    };
+}
+function array(check) {
+    return (value, path) => {
+        if (!Array.isArray(value))
+            fail(path, 'an array');
+        value.forEach((item, index) => check(item, `${path}[${index}]`));
+    };
+}
+function shape(fields) {
+    return (value, path) => {
+        const source = record(value, path);
+        for (const [key, check] of Object.entries(fields))
+            check(source[key], `${path}.${key}`);
+    };
+}
+const usage = shape({
+    inputTokens: number, outputTokens: number, cacheReadTokens: optional(number),
+    cacheWriteTokens: optional(number), cost: optional(number),
+});
+function contentPart(value, path) {
+    const part = record(value, path);
+    enumeration('text', 'image')(part.type, `${path}.type`);
+    if (part.type === 'text')
+        string(part.text, `${path}.text`);
+    else
+        shape({ mediaType: string, data: string })(part, path);
+}
+function contentBlock(value, path) {
+    const block = record(value, path);
+    enumeration('text', 'thinking', 'tool_call')(block.type, `${path}.type`);
+    if (block.type === 'tool_call') {
+        shape({ toolCallId: string, toolName: string, args: object })(block, path);
+        return;
+    }
+    string(block.text, `${path}.text`);
+    if (block.type === 'thinking')
+        optional(string)(block.signature, `${path}.signature`);
+}
+function message(value, path) {
+    const source = record(value, path);
+    enumeration('user', 'assistant', 'tool_result')(source.role, `${path}.role`);
+    if (source.role === 'assistant') {
+        shape({ content: array(contentBlock), usage: optional(usage),
+            stopReason: optional(enumeration('end_turn', 'tool_use', 'max_tokens', 'stop_sequence')),
+        })(source, path);
+        return;
+    }
+    if (source.role === 'tool_result') {
+        shape({ toolCallId: string, isError: optional(boolean) })(source, path);
+    }
+    else
+        optional(number)(source.timestamp, `${path}.timestamp`);
+    if (typeof source.content !== 'string')
+        array(contentPart)(source.content, `${path}.content`);
+}
+const patchLine = shape({
+    kind: enumeration('ctx', 'add', 'del'), text: string,
+    oldLine: optional(number), newLine: optional(number),
+});
+const patch = shape({
+    path: string, kind: enumeration('create', 'update'), added: number, removed: number,
+    truncated: boolean, lineCount: number,
+    degraded: optional(enumeration('binary', 'too-large', 'unreadable')),
+    hunks: array(shape({ oldStart: number, oldCount: number, newStart: number, newCount: number,
+        lines: array(patchLine) })),
+});
+const todo = shape({
+    content: string, activeForm: string, status: enumeration('pending', 'in_progress', 'completed'),
+});
+const subagent = shape({
+    label: string, description: string,
+    // Old team archives predate tier; renderers already treat absence as main.
+    tier: optional(enumeration('main', 'fast')),
+    phase: enumeration('queued', 'starting', 'thinking', 'tool', 'waiting', 'done', 'failed', 'aborted'),
+    startedAt: optional(number), endedAt: optional(number), turns: number, toolCalls: number,
+    lastTool: optional(string), usage, filesTouched: array(string), messagesSent: number,
+    summary: optional(string), error: optional(string), truncated: optional(boolean),
+    compactions: optional(number), activity: optional(string),
+    activityArgs: optional(shape({ path: optional(string), pattern: optional(string),
+        command: optional(string), to: optional(string), from: optional(string) })),
+    blockedWaits: optional(number), retries: optional(number), retryable: optional(boolean),
+    retry: optional(shape({ attempt: number, maxRetries: number })),
+});
+const ENTRY_FIELDS = {
+    user: { text: string },
+    queued: { text: string, queueId: optional(nonempty) },
+    notice: { text: string, level: enumeration('info', 'warn', 'error') },
+    assistant: {
+        text: string, thinking: optional(string), thinkingOpen: boolean, streaming: boolean,
+        aborted: optional(boolean), usage: optional(usage),
+        thinkingStartedAt: optional(number), thinkingMs: optional(number),
+    },
+    tool: {
+        toolCallId: string, name: string, label: string, argsRaw: string, args: optional(object),
+        status: enumeration('pending', 'running', 'done', 'error'), preview: optional(string),
+        durationMs: optional(number), isError: optional(boolean), patch: optional(patch),
+        live: optional(array(string)), liveSeq: optional(number), lastOutputAt: optional(number),
+    },
+    team: { dispatchId: string, requested: number, runs: array(subagent), aborted: boolean,
+        durationMs: optional(number), active: boolean },
+    todo: { items: array(todo), doneCount: number, total: number, live: boolean,
+        interrupted: optional(boolean) },
+    retry: {
+        attempt: number, maxRetries: number, errorType: string, message: string, delayMs: number,
+        resumeAt: optional(number), startedAt: number, totalRetries: optional(number),
+        elapsedMs: optional(number),
+        phase: enumeration('waiting', 'retrying', 'recovered', 'exhausted', 'interrupted'),
+    },
+    fast: { reviewIndex: number, model: string,
+        status: enumeration('running', 'ok', 'advice', 'empty', 'failed', 'dropped'),
+        text: optional(string), detail: optional(string), turn: number,
+        durationMs: optional(number), live: boolean },
+    compaction: {
+        index: number, trigger: enumeration('pressure', 'overflow', 'manual'),
+        mode: enumeration('summarized', 'truncated', 'relieved', 'none'), applied: boolean,
+        reason: optional(string), messagesBefore: number, messagesAfter: number,
+        tokensBefore: number, tokensAfter: number, summary: optional(string), model: string,
+        durationMs: optional(number), startedAt: optional(number), live: boolean,
+        tailRelief: optional(shape({ messages: number, charsRemoved: number })),
+    },
+    service: {
+        serviceId: string, command: string,
+        status: enumeration('starting', 'ready', 'running', 'exited', 'failed', 'stopped'),
+        url: optional(string), port: optional(number),
+        exitCode: (value, path) => { if (value !== null)
+            number(value, path); },
+        startedAt: number, readyAt: optional(number), endedAt: optional(number), rows: array(string),
+        rowsSeen: number, terminal: optional(boolean), killIncomplete: optional(boolean),
+    },
+};
+function validateEntries(value) {
+    const ids = new Set();
+    const queues = new Set();
+    array((item, path) => {
+        const entry = record(item, path);
+        nonempty(entry.id, `${path}.id`);
+        if (ids.has(entry.id))
+            fail(`${path}.id`, 'unique');
+        ids.add(entry.id);
+        enumeration(...Object.keys(ENTRY_FIELDS))(entry.kind, `${path}.kind`);
+        shape(ENTRY_FIELDS[entry.kind])(entry, path);
+        if (entry.kind !== 'queued' || entry.queueId === undefined)
+            return;
+        if (queues.has(entry.queueId))
+            fail(`${path}.queueId`, 'unique');
+        queues.add(entry.queueId);
+    })(value, 'entries');
+}
+function validateModel(value) {
+    const model = record(value, 'model');
+    shape({ providerId: nonempty, modelId: nonempty, baseUrl: optional(string) })(model, 'model');
+    if (typeof model.providerId !== 'string' || !isAdapterProvider(model.providerId)) {
+        fail('model.providerId', 'a supported adapter');
+    }
+}
+/** Return a prepared copy, preserving extensions; throw with the corrupt field path. */
+export function validateSession(value) {
+    const source = record(value, 'session');
+    array(message)(source.messages, 'messages');
+    validateEntries(source.entries);
+    if (source.model !== undefined)
+        validateModel(source.model);
+    // Missing fields remain missing in old files, including exec metadata.
+    const prepared = { ...source };
+    if (source.todos !== undefined) {
+        prepared.todos = normalizeTodos(source.todos, TODO_LIMITS.maxItems).items;
+    }
+    return prepared;
+}

package/dist/team/runtime.d.ts

@@ -17,6 +17,7 @@
  * queue class, no event-loop trickery — every path is observable from the event
  * stream.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import type { ProviderRegistry, SkillRegistry, ToolPolicyDecision, ToolPolicyVerdict } from '@aragon-agent/core';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { CliConfig } from '../config/schema.js';
@@ -30,7 +31,7 @@ export interface TeamRuntimeDeps {
     providerRegistry: ProviderRegistry;
     getCwd: () => string;
     getMode: () => AgentMode;
-    getApiKey: (providerId: string) => string | undefined;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     skillRegistry?: SkillRegistry;
     alwaysBlock?: () => string;
     toolPolicy?: () => ToolPolicyDecision;

package/dist/team/subagent.d.ts

@@ -10,6 +10,7 @@
  * them (§3.11 / R-6). What a child does NOT get is spelled out below, and each
  * omission has a reason that is a correctness boundary rather than caution.
  */
+import type { ModelRole } from '../config/model-profiles.js';
 import { type AgentConfig, type AgentEvent, type AgentTool, type Message, type ModelRef, type ProviderRegistry, type SkillRegistry, type ThinkingLevel, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
 import type { AgentMode } from '../agent/agent-mode.js';
 import type { ChildContextManagerProvider } from '../compaction/child.js';
@@ -60,7 +61,7 @@ export interface SubagentDeps {
     getCwd: () => string;
     /** The lead's live session mode. Read at CALL time, never cached. */
     getMode: () => AgentMode;
-    getApiKey: (providerId: string) => string | undefined;
+    getApiKey: (providerId: string, role?: ModelRole) => string | undefined;
     /**
      * The lead's `SkillRegistry`, used for `skill_find` ONLY.
      *
@@ -109,6 +110,7 @@ export interface SubagentDeps {
     resolveTier?: (tier: FastTierName) => {
         ref: ModelRef;
         thinkingLevel: ThinkingLevel;
+        role?: ModelRole;
     };
     /**
      * Build this child its own context manager

package/dist/team/subagent.js

@@ -181,6 +181,7 @@ export function createSubagent(spec, deps, hooks) {
                 ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
             },
             thinkingLevel: deps.config.thinkingLevel,
+            role: 'main',
         };
     const model = resolved.ref;
     // HOISTED TO A LOCAL, AND THAT IS WHAT MAKES W3 POSSIBLE AT ALL. This was built
@@ -209,6 +210,7 @@ export function createSubagent(spec, deps, hooks) {
     const contextManager = deps.contextManagerFor?.({
         label: spec.label,
         model,
+        role: resolved.role ?? 'main',
         getMessages: () => agentRef?.state.messages ?? [],
         getSystemPrompt: () => systemPrompt,
         onCompacted: () => {
@@ -224,7 +226,7 @@ export function createSubagent(spec, deps, hooks) {
         // constructing five of them per dispatch is pure waste.
         providerRegistry: deps.providerRegistry,
         // The lead's closure, so a settings-screen key edit reaches children too.
-        getApiKey: deps.getApiKey,
+        getApiKey: (id) => deps.getApiKey(id, resolved.role ?? 'main'),
         ...(deps.config.maxTokens !== undefined ? { maxTokens: deps.config.maxTokens } : {}),
         timeouts: {
             toolTimeout: deps.config.toolTimeoutMs,

package/dist/ui/ActivityLine.d.ts

@@ -1,85 +1,21 @@
-/**
- * The live working line (agent-activity-presentation §3.2.2).
- *
- * Exactly one row, immediately above the composer, while a run is in flight:
- *
- *     * Percolating...
- *
- * THE ROW CARRIES THE PHRASE AND NOTHING ELSE, AND THAT IS THE WHOLE OF ITS
- * DESIGN (D-5 / P1-1). No elapsed clock, no token count, no `esc abort`, at any
- * width. Every one of those is already on screen while running: the status bar
- * renders `formatDuration(elapsedMs)` under exactly the `running` condition that
- * mounts this row and the token cluster at `cols >= 72`, and both composers carry
- * the abort hint. Duplicated rows are precisely what the v0.4.0 removal of the
- * status bar's hint cluster was for, and that rule does not distinguish between a
- * duplicated string and a duplicated number.
- *
- * Because there are no clusters there is NO WIDTH LADDER: one row, one
- * truncating `<Text>`, identical at 200 columns and at 40. `cols` is therefore
- * not a prop — nothing on the row depends on width, and a prop that changed on
- * every resize but was never read would be a false dependency on a memo boundary.
- *
- * What is left is the one thing the status bar cannot say: THAT THE SILENCE IS
- * WORK. The bar shows state; this row shows life.
- *
- * THIS ROW OWNS THE ONLY ANIMATED SPINNER WHILE IT IS MOUNTED
- * (single-spinner-while-running D-1). Seven other sites can animate — the
- * streaming assistant marker, the tool badge, the team/fast/retry cards, and the
- * two panels' rows — and each was independently right to. Emergently they put up
- * to five braille animations on adjacent rows, each on its own 80 ms timer: one
- * piece of information rendered five times and out of phase, which is the same
- * duplication the paragraph above legislates against for text. So `App` widens
- * the `reducedMotion` it hands those seven to `cfg.reducedMotion || (running &&
- * !overlay)`, and they all fall back to the static glyphs they already had.
- *
- * THIS COMPONENT KEEPS THE RAW CONFIG FLAG, and that asymmetry is deliberate
- * (D-5). It reads the flag TWICE: once for the spinner below, and once for
- * `pickActivityPhrase`'s rotation. Handing it the widened value would freeze the
- * phrase at the first word of every run — a second, unrelated regression, and
- * one nobody would connect to a change about icons.
+/** Legacy activity presentation. Explicit facts share the global status label mapping.
+ * StatusBar owns the application's sole live spinner via the factory below.
  */
 import React from 'react';
 import type { Theme } from './theme.js';
 import type { TermCapabilities } from './capabilities.js';
 import { pickGlyphs } from './glyphs.js';
 import type { RunActivity } from './run-status-row.js';
-/**
- * The animated spinner this row draws while it is live, or `null` when it would
- * be STATIC — an ASCII terminal, or a user who asked for stillness.
- *
- * A FACTORY, NOT A COMPONENT, and the distinction is load-bearing. A
- * `<LiveSpinner/>` element whose own render returned `null` would still be
- * truthy at the call site — the exact trap `BottomStatusRow`'s `update` prop
- * documents at length. Callers test the RETURN VALUE and get a real answer.
- *
- * It is exported so `BottomStatusRow` can put the bare glyph beside a toast
- * without importing `ink-spinner` itself: `spinner-census.test.ts` enumerates
- * every file under `src/ui/**` that imports it, and that list is the checklist
- * for "who is allowed to animate". One more importer is one more site a future
- * reader has to reason about; one more caller of this function is not.
- */
+/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
 export declare function liveSpinner(reducedMotion: boolean, caps: TermCapabilities): React.ReactElement | null;
-/**
- * The label ladder, MOST SPECIFIC FIRST: `Compacting context` outranks a tool name
- * because compaction can be the only thing happening, and the tool name outranks
- * the rotating phrase for the reason `runningTool` exists at all. One
- * implementation, because the fixed bottom row and the run status row above the
- * input must never disagree about what the agent is doing.
- *
- * `Running ${name}` rather than a per-tool verb table: a table would be a SECOND
- * registry of tool names, and `toolGlyph` is already the one place that knows
- * them. ASCII only, and the ellipsis comes from `pickGlyphs` like every other one.
- */
+/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
 export declare function resolveActivityLabel(activity: RunActivity, glyphs: ReturnType<typeof pickGlyphs>): string;
 export interface ActivityLabelProps extends RunActivity {
     /**
-     * False draws the STATIC glyph even when motion is allowed. The run status row
-     * uses it when it has scrolled out of the viewport (the fixed bottom row owns
-     * the animation then) or an overlay covers the chat. The phrase still rotates
-     * from the RAW `reducedMotion`, so a still icon never freezes the wording.
+     * False forces a static glyph. Compatibility phrases still follow reducedMotion.
      */
     spinnerLive?: boolean;
-    /** Prefix one space (the fixed bottom row's indent); the run row indents itself. */
+    /** Prefix one space for compatibility line consumers. */
     leadingSpace?: boolean;
     theme: Theme;
     caps: TermCapabilities;

package/dist/ui/ActivityLine.js

@@ -3,36 +3,19 @@ import { Box, Text } from 'ink';
 import Spinner from 'ink-spinner';
 import { pickGlyphs } from './glyphs.js';
 import { pickActivityPhrase } from './activity-phrases.js';
-/**
- * The animated spinner this row draws while it is live, or `null` when it would
- * be STATIC — an ASCII terminal, or a user who asked for stillness.
- *
- * A FACTORY, NOT A COMPONENT, and the distinction is load-bearing. A
- * `<LiveSpinner/>` element whose own render returned `null` would still be
- * truthy at the call site — the exact trap `BottomStatusRow`'s `update` prop
- * documents at length. Callers test the RETURN VALUE and get a real answer.
- *
- * It is exported so `BottomStatusRow` can put the bare glyph beside a toast
- * without importing `ink-spinner` itself: `spinner-census.test.ts` enumerates
- * every file under `src/ui/**` that imports it, and that list is the checklist
- * for "who is allowed to animate". One more importer is one more site a future
- * reader has to reason about; one more caller of this function is not.
- */
+import { phaseLabels } from './layout/status-layout.js';
+/** Shared animation factory; returns null for ASCII or reduced-motion terminals. */
 export function liveSpinner(reducedMotion, caps) {
     return caps.unicode && !reducedMotion ? _jsx(Spinner, { type: "dots" }) : null;
 }
-/**
- * The label ladder, MOST SPECIFIC FIRST: `Compacting context` outranks a tool name
- * because compaction can be the only thing happening, and the tool name outranks
- * the rotating phrase for the reason `runningTool` exists at all. One
- * implementation, because the fixed bottom row and the run status row above the
- * input must never disagree about what the agent is doing.
- *
- * `Running ${name}` rather than a per-tool verb table: a table would be a SECOND
- * registry of tool names, and `toolGlyph` is already the one place that knows
- * them. ASCII only, and the ellipsis comes from `pickGlyphs` like every other one.
- */
+/** Explicit execution facts outrank compatibility tool names and rotating phrases. */
 export function resolveActivityLabel(activity, glyphs) {
+    if (activity.phase !== undefined || activity.activeTool !== undefined || activity.outcome !== undefined) {
+        return phaseLabels({
+            phase: activity.phase ?? (activity.activeTool ? 'tool' : 'idle'),
+            activeTool: activity.activeTool, runOutcome: activity.outcome, compacting: activity.compacting,
+        })[1];
+    }
     if (activity.compacting)
         return `Compacting context${glyphs.ellipsis}`;
     if (activity.runningTool)
@@ -47,14 +30,9 @@ export function resolveActivityLabel(activity, glyphs) {
 export function ActivityLabel({ spinnerLive = true, leadingSpace = false, theme, caps, ...activity }) {
     const glyphs = pickGlyphs(caps);
     const label = resolveActivityLabel(activity, glyphs);
-    // The IDENTICAL branch `Transcript.tsx` uses for the assistant role marker, and
-    // it must stay identical: braille dots are both an animation AND a Unicode-only
-    // glyph, so reduced motion and an ASCII terminal fall back to the same marker.
-    //
-    // Through `liveSpinner` rather than inline, so this row and the glyph
-    // `BottomStatusRow` composes beside a toast can never disagree about WHEN the
-    // spinner is live - the same reason `App` names its mount condition once.
-    const spinner = (spinnerLive ? liveSpinner(activity.reducedMotion, caps) : null) ??
+    const settled = activity.phase === 'idle' || (activity.phase === undefined
+        && activity.outcome !== undefined && activity.outcome !== 'none' && !activity.activeTool);
+    const spinner = (spinnerLive && (!settled || activity.compacting) ? liveSpinner(activity.reducedMotion, caps) : null) ??
         glyphs.spinnerStill;
     return (_jsxs(Text, { wrap: "truncate", color: theme.thinking, children: [leadingSpace ? ' ' : '', spinner, " ", label] }));
 }

package/dist/ui/App.d.ts

@@ -88,6 +88,7 @@ export interface TerminalBridge {
     scrollbar?: ScrollbarBridge;
     /** Whether drag-select is on for this session (`mouseSelect` + a filter). */
     mouseSelect: boolean;
+    deleteDisambiguated?: boolean;
     /** Release the mouse to the terminal, or take it back (`/mouse`, G3). */
     setMouseCapture?: (on: boolean) => void;
     /** Whether the mouse is captured right now — read at command time. */