@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/session/persist.js

@@ -59,6 +59,24 @@ function stripLiveToolOutput(entries) {
         ? { ...e, live: undefined, liveSeq: undefined, lastOutputAt: undefined }
         : e);
 }
+/**
+ * Drop the service tail on the way to disk, beside `stripLiveToolOutput` and for
+ * the same three reasons (background-service-supervision §6).
+ *
+ * A resumed card's tail describes a PROCESS THAT NO LONGER EXISTS - it died with
+ * the session, because nothing in this package outlives the CLI by design. The
+ * tail is also the only unbounded field a service entry carries, and dropping it
+ * keeps a saved session's size a function of how many services ran rather than
+ * of how chatty they were.
+ *
+ * `rowsSeen` IS KEPT. It is the revision cursor, not display data, and a
+ * restored card that reported 0 rows seen while `normalizeLoadedEntries` was
+ * flipping its status would produce a revision collision with a live card that
+ * genuinely has none.
+ */
+function stripServiceTail(entries) {
+    return entries.map((e) => (e.kind === 'service' && e.rows.length > 0 ? { ...e, rows: [] } : e));
+}
 /**
  * `data` GAINS `todos`, AND WIDENING `SavedSession` ALONE IS NOT ENOUGH (P0-2):
  * the writer below builds its payload from THIS parameter, not from the type, so
@@ -81,7 +99,7 @@ export function saveSession(filePath, data) {
         savedAt: Date.now(),
         model: data.model,
         messages: data.messages,
-        entries: stripLiveToolOutput(data.entries),
+        entries: stripServiceTail(stripLiveToolOutput(data.entries)),
         todos: data.todos,
         ...(data.meta ? { meta: data.meta } : {}),
     };
@@ -139,6 +157,42 @@ export function normalizeLoadedEntries(entries) {
                 detail: 'interrupted (session resumed)',
             };
         }
+        // THE FIFTH CLAUSE (context-auto-compaction §5.5 / C-8 / AC-19). A compaction
+        // card saved while its summarization was open resumes claiming to be running
+        // while nothing is, and — the part that actually costs — it never settles, so
+        // `Transcript`'s MONOTONIC boundary never advances past it and every frame for
+        // the rest of the session re-renders the whole tail.
+        //
+        // `applied: false` is also simply TRUE: whatever the call was going to
+        // return died with the process, and the history on disk is the PRE-compaction
+        // one. A card that claimed otherwise would tell the user their session had
+        // been compacted when it had not.
+        if (entry.kind === 'compaction' && entry.live) {
+            return {
+                ...entry,
+                live: false,
+                applied: false,
+                mode: 'none',
+                reason: 'interrupted (session resumed)',
+            };
+        }
+        // THE SIXTH CLAUSE (background-service-supervision §6 / R-7). A card saved
+        // while its service was up resumes claiming to be running while nothing is -
+        // the process died with the session, because nothing here outlives the CLI.
+        //
+        // AND `starting` IS THE ONE THAT ACTUALLY COSTS: it is the single service
+        // status that blocks `Transcript`'s MONOTONIC settled boundary (D-11), so a
+        // restored `starting` card would never settle and every frame for the rest of
+        // the session would re-render the whole tail. `ready` / `running` would
+        // "only" be a lie; this one is a lie that gets slower.
+        //
+        // `stopped` rather than `exited`: we did not observe an exit code, and
+        // claiming one would be inventing a number. The terminal record the session
+        // may also carry is already terminal and is left alone.
+        if (entry.kind === 'service' &&
+            (entry.status === 'starting' || entry.status === 'ready' || entry.status === 'running')) {
+            return { ...entry, status: 'stopped', rows: [] };
+        }
         return entry;
     });
 }

package/dist/team/report.js

@@ -143,9 +143,15 @@ function buildSection(run) {
     // bytes, and it is the only place the lead learns which of its children were
     // cheap — the fact the whole second cost line is about.
     const tier = run.tier === 'fast' ? ' [fast]' : '';
+    // `compacted N` in the same position `retried Nx` uses, and for the same
+    // reason (context-auto-compaction-hardening §3.4.4 / W3): this is the ONLY
+    // place the lead learns that a child's own history was summarized mid-task, so
+    // a summary that reads thinner than the turn count suggests has a stated cause
+    // rather than an unexplained one. Absent when it never happened.
+    const compacted = run.compactions ? `, compacted ${run.compactions}` : '';
     const head = [
         `### ${run.label}${tier} "${run.description}"  ${statusBadge(run)}  ${elapsed(run)}, ` +
-            `${run.turns} turns, ${run.toolCalls} tools${retried}`,
+            `${run.turns} turns, ${run.toolCalls} tools${retried}${compacted}`,
     ];
     if (run.filesTouched.length > 0)
         head.push(`files: ${run.filesTouched.join(', ')}`);

package/dist/team/runtime.d.ts

@@ -60,6 +60,16 @@ export interface TeamRuntimeDeps {
      * is the pre-feature behaviour.
      */
     resolveTier?: SubagentDeps['resolveTier'];
+    /**
+     * Per-child context compaction (context-auto-compaction-hardening §3.4 / W3).
+     *
+     * Passed straight through to `SubagentDeps`; absent means children get none,
+     * which is the pre-hardening behaviour exactly. `AgentController` supplies it
+     * from `CompactionWiring.childFactory()`, and the closure returns `undefined`
+     * when compaction is unregistered or `compaction.subagents` is false - which is
+     * what lets `subagent.ts` spread nothing at all.
+     */
+    contextManagerFor?: SubagentDeps['contextManagerFor'];
 }
 export declare class TeamRuntime {
     private readonly deps;

package/dist/team/runtime.js

@@ -132,6 +132,13 @@ export class TeamRuntime {
             ...(this.deps.humanQueue ? { humanQueue: this.deps.humanQueue } : {}),
             agentFactory: this.deps.agentFactory ?? defaultSubagentFactory,
             ...(this.deps.resolveTier ? { resolveTier: this.deps.resolveTier } : {}),
+            // Site two of two, and the omission is silent in the same way the policy
+            // one above is: declaring it on `TeamRuntimeDeps` and forgetting this line
+            // type-checks and forwards nothing, so every child would quietly run with
+            // no compaction while the config key says it has one.
+            ...(this.deps.contextManagerFor
+                ? { contextManagerFor: this.deps.contextManagerFor }
+                : {}),
         };
         // Hoisted into a factory so a retry can build a fresh child with IDENTICAL
         // wiring (F-4). Replacing the child rather than re-prompting it is the only

package/dist/team/subagent.d.ts

@@ -10,8 +10,9 @@
  * 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 AgentConfig, type AgentEvent, type AgentTool, type ModelRef, type ProviderRegistry, type SkillRegistry, type ThinkingLevel, type TokenUsage, type ToolPolicyDecision, type ToolPolicyVerdict } from '@aragon-agent/core';
+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';
 import type { CliConfig } from '../config/schema.js';
 import type { ToolPermission } from '../exec/permission.js';
 import type { FastTierName } from '../fast/types.js';
@@ -29,6 +30,24 @@ export interface SubagentAgentLike extends WatchdogPausable {
     prompt(text: string): Promise<void>;
     abort(): void;
     subscribe(listener: (event: AgentEvent) => void): () => void;
+    /**
+     * The child's live history, for its own context manager
+     * (context-auto-compaction-hardening §3.4.3 / W3).
+     *
+     * NARROWED ON PURPOSE. `Agent` satisfies this with its full `AgentState`
+     * getter and a stub satisfies it with `{ messages: [] }`. Widening it to
+     * `AgentState` would make every test stub fabricate a systemPrompt, a model and
+     * a phase to compile, for fields none of them use.
+     *
+     * A PROPERTY READ, NOT A METHOD CALL, AND THAT IS NOT A STYLE CHOICE: core's
+     * `Agent` has NO `getMessages()`. It exposes `get state(): AgentState`;
+     * `AgentController.getMessages()` is the CONTROLLER's own one-line forwarder
+     * over `this.agent.state.messages`. Adding a method to the engine to serve a
+     * host-side convenience would move the core export surface for nothing.
+     */
+    readonly state: {
+        readonly messages: readonly Message[];
+    };
 }
 export type SubagentAgentFactory = (config: AgentConfig) => SubagentAgentLike;
 /** The default factory: a real `Agent` from `@aragon-agent/core`. */
@@ -91,6 +110,17 @@ export interface SubagentDeps {
         ref: ModelRef;
         thinkingLevel: ThinkingLevel;
     };
+    /**
+     * Build this child its own context manager
+     * (context-auto-compaction-hardening §3.4.3 / W3).
+     *
+     * ABSENT means children get none, and `subagent.ts` then spreads NO
+     * `contextManager` key at all - so the child's loop gate tests a genuinely
+     * undefined field and a `compaction.subagents: false` session is byte-identical
+     * to round 1 (AC-H10). `AgentController` supplies it from
+     * `CompactionWiring.childFactory()`, which returns `null` when the key is off.
+     */
+    contextManagerFor?: ChildContextManagerProvider;
 }
 export interface SubagentHooks {
     /** Coalesced at the source (§5.2); phase transitions always pass. */

package/dist/team/subagent.js

@@ -183,22 +183,40 @@ export function createSubagent(spec, deps, hooks) {
             thinkingLevel: deps.config.thinkingLevel,
         };
     const model = resolved.ref;
-    const agent = deps.agentFactory({
-        systemPrompt: buildSystemPrompt({
-            cwd: deps.getCwd(),
-            tools,
-            skillsBlock: deps.alwaysBlock ?? '',
-            agentMode: spec.readOnly ? 'plan' : deps.getMode(),
-            // A child has no overlay, so the plan block must describe the headless
-            // shape: write the plan as the final message rather than calling tools it
-            // does not have.
-            planInteractive: false,
-            subagentBlock: buildSubagentBlock({
-                label: spec.label,
-                description: spec.description,
-                peers: deps.bus.peersOf(spec.label),
-            }),
+    // HOISTED TO A LOCAL, AND THAT IS WHAT MAKES W3 POSSIBLE AT ALL. This was built
+    // INLINE inside the `agentFactory({...})` argument, so there was nothing for the
+    // child manager's `getSystemPrompt` accessor to close over - and the accessor
+    // cannot read it back off the agent, because `SubagentAgentLike` is narrowed to
+    // `state.messages` on purpose.
+    const systemPrompt = buildSystemPrompt({
+        cwd: deps.getCwd(),
+        tools,
+        skillsBlock: deps.alwaysBlock ?? '',
+        agentMode: spec.readOnly ? 'plan' : deps.getMode(),
+        // A child has no overlay, so the plan block must describe the headless
+        // shape: write the plan as the final message rather than calling tools it
+        // does not have.
+        planInteractive: false,
+        subagentBlock: buildSubagentBlock({
+            label: spec.label,
+            description: spec.description,
+            peers: deps.bus.peersOf(spec.label),
         }),
+    });
+    // LAZY ACCESSORS OVER `agentRef`, WHICH IS ASSIGNED AFTER THIS RETURNS. A
+    // non-lazy read here is `undefined` at construction and the child's estimate
+    // branch would silently measure an empty history - CR-1 one module over.
+    const contextManager = deps.contextManagerFor?.({
+        label: spec.label,
+        model,
+        getMessages: () => agentRef?.state.messages ?? [],
+        getSystemPrompt: () => systemPrompt,
+        onCompacted: () => {
+            run.compactions = (run.compactions ?? 0) + 1;
+        },
+    });
+    const agent = deps.agentFactory({
+        systemPrompt,
         model,
         tools,
         thinkingLevel: resolved.thinkingLevel,
@@ -217,6 +235,11 @@ export function createSubagent(spec, deps, hooks) {
             // explicitly.
             idleTimeout: deps.config.idleTimeoutMs,
         },
+        // SPREAD CONDITIONALLY, never `contextManager: deps.contextManagerFor?.(...)`.
+        // With the feature off the options bag has no such key, so the loop's gate
+        // tests a field that is genuinely `undefined` rather than a property holding
+        // one - the identical argument `AgentController` makes for the lead (AC-H10).
+        ...(contextManager ? { contextManager } : {}),
     });
     agentRef = agent;
     let lastEmit = 0;
@@ -289,6 +312,10 @@ export function createSubagent(spec, deps, hooks) {
                     outputTokens: run.usage.outputTokens + event.usage.outputTokens,
                 };
                 hooks.onUsage(spec.label, event.usage);
+                // W1's delta needs the history LENGTH the measurement covered, and the
+                // port carries no turn hook. `turn_end` is emitted BEFORE the assistant
+                // push, so this is exactly the history the reported `usage` describes.
+                contextManager?.onTurnEnd(event.usage, agentRef?.state.messages ?? [], systemPrompt);
                 const text = assistantText(event.message);
                 // The LAST non-empty assistant text wins, which is exactly the child's
                 // final message once the loop stops calling tools. Capturing it here

package/dist/team/types.d.ts

@@ -78,6 +78,14 @@ export interface SubagentRun {
     error?: string;
     /** Hit `team.maxTurnsPerSubagent` and was stopped mid-work. */
     truncated?: boolean;
+    /**
+     * Compactions this child performed on its OWN history
+     * (context-auto-compaction-hardening §3.4.4 / W3).
+     *
+     * OPTIONAL, so every existing construction site and fixture compiles
+     * unchanged. Absent and `0` mean the same thing to every reader.
+     */
+    compactions?: number;
     /**
      * Prose the child is writing right now, sanitized and clamped to
      * `TEAM_LIMITS.activityChars`. Set only between tool calls; cleared on

package/dist/tools/bash-tool.d.ts

@@ -1,12 +1,61 @@
 /**
- * bash tool — run a shell command at full permission (spec §3.6).
+ * bash tool — run a shell command at full permission (spec §3.6), and, since
+ * background-service-supervision, supervise the ones that do not exit.
  *
  * Shell selection: Windows uses `process.env.ComSpec` (cmd.exe by default);
  * POSIX uses `/bin/sh -c`. The command's stdout+stderr and exit code are
  * captured. The `timeout?` param can only SHRINK within the executor ceiling
  * (the core ToolExecutor owns the real timeout + 100 KB truncation — R4), so
  * this tool does not re-implement an output cap.
+ *
+ * I-1 — THIS TOOL NEVER LEAVES ITS PROMISE PENDING. Every exit path goes through
+ * `settle`, and `settle` is reachable from FIVE places: `'error'`, `'close'`,
+ * `'exit'` plus a drain timer, an abort plus a kill grace, and the `timeout`
+ * param plus the same grace. That is the whole of W1, and each of the five
+ * closes a way the old implementation could hang:
+ *
+ *   1. It settled on `'close'`, which fires only when the process has exited AND
+ *      every stdio stream is closed. A child that spawns a detached grandchild
+ *      inheriting the pipe — `Start-Process`, `&`, `nohup`, and every
+ *      `npm run dev` that re-execs — keeps that pipe open after the shell is
+ *      long gone. The shell exited; the promise did not.
+ *   2. `stdio` defaulted to `'pipe'` for stdin, so a command that PROMPTS —
+ *      `npm init`, a package manager asking to install something, `sudo`, a git
+ *      credential prompt — blocked on a read that could never be satisfied.
+ *   3. An abort killed the tree and then went on waiting for a `'close'` that a
+ *      detached grandchild was still holding.
+ *
+ * The happy path is BYTE-IDENTICAL to the pre-change build: `$ cmd\n<output>\n
+ * [exit code N]`, same truncation, same footer. That is what keeps the existing
+ * `bash` assertions meaningful rather than rewritten.
  */
 import { type AgentTool } from '@aragon-agent/core';
+import type { ProcSupervisorPort } from '../proc/types.js';
 import type { ToolDeps } from './fs-tools.js';
-export declare function makeBash(deps: ToolDeps): AgentTool;
+export interface BashToolOptions {
+    /**
+     * Present only when background launches are on for this session.
+     *
+     * ITS ABSENCE IS WHAT MAKES I-2 CHECKABLE: no `background` property in the
+     * schema, no supervisor call, no readiness timer, and a description string
+     * identical to the pre-feature one.
+     */
+    supervisor?: ProcSupervisorPort;
+    /** `cfg.bash.autoBackground`, read LIVE. */
+    autoBackground?: () => boolean;
+    /** `cfg.bash.startupSettleMs`, read LIVE. */
+    startupSettleMs?: () => number;
+    /**
+     * Whether a card can be rendered and a user can keep a service alive (D-15 /
+     * P1-8).
+     *
+     * FALSE IN `aragon exec` AND `-p`. It suppresses only the CLASSIFIER: an
+     * explicit `background: true` is still honoured — the model asked for it —
+     * and the result then carries one extra line saying the service dies with the
+     * run. Without this rule `aragon -p "npm run dev"` would background a server,
+     * return in `startupSettleMs`, and reap it at process exit with no card, no
+     * `/bg`, no event and nothing in the result saying so.
+     */
+    interactive?: boolean;
+}
+export declare function makeBash(deps: ToolDeps, options?: BashToolOptions): AgentTool;