@gotgenes/pi-subagents 7.4.0 → 7.5.1

package/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [7.5.1](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v7.5.0...pi-subagents-v7.5.1) (2026-05-26)
+
+
+### Documentation
+
+* plan decompose buildParentContext ([#215](https://github.com/gotgenes/pi-packages/issues/215)) ([9103609](https://github.com/gotgenes/pi-packages/commit/910360991b50c320927c1457bfef6b7cb5624b7b))
+* **retro:** add planning stage notes for issue [#215](https://github.com/gotgenes/pi-packages/issues/215) ([5c534d5](https://github.com/gotgenes/pi-packages/commit/5c534d5efb640ef1d72d6ccf7bf2e15ac2acf755))
+* **retro:** add TDD stage notes for issue [#215](https://github.com/gotgenes/pi-packages/issues/215) ([79064d0](https://github.com/gotgenes/pi-packages/commit/79064d072c36c2f92013dbfba58ce1de1ab01bce))
+
+## [7.5.0](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v7.4.0...pi-subagents-v7.5.0) (2026-05-26)
+
+
+### Features
+
+* add permission bridge for cross-extension registration ([#101](https://github.com/gotgenes/pi-packages/issues/101)) ([1827720](https://github.com/gotgenes/pi-packages/commit/18277203f7ee10e56f90a0d4db587a4aa95376ab))
+* register child sessions with permission system ([#101](https://github.com/gotgenes/pi-packages/issues/101)) ([0487828](https://github.com/gotgenes/pi-packages/commit/04878286d7da6660362360482fb916b1b3743ce3))
+
+
+### Bug Fixes
+
+* resolve pre-existing lint errors in pi-autoformat and pi-permission-system ([68fd516](https://github.com/gotgenes/pi-packages/commit/68fd516e33ddbb9a5e37ef19e949ee9ecdc37252))
+
+
+### Documentation
+
+* document permission-bridge in architecture ([#101](https://github.com/gotgenes/pi-packages/issues/101)) ([d0120ab](https://github.com/gotgenes/pi-packages/commit/d0120abdf049e2aeba14ba75071ed55b24e23dbe))
+* update subagent integration docs for native permission bridge ([#101](https://github.com/gotgenes/pi-packages/issues/101)) ([0bd456b](https://github.com/gotgenes/pi-packages/commit/0bd456befa8ea6918e74f4393d844868795edc77))
+
 ## [7.4.0](https://github.com/gotgenes/pi-packages/compare/pi-subagents-v7.3.2...pi-subagents-v7.4.0) (2026-05-25)
 
 

package/README.md

@@ -421,27 +421,57 @@ disallowed_tools: write, edit
 
 This is useful for creating agents that inherit extension tools but should not have write access.
 
+## Permission System Integration
+
+When [`@gotgenes/pi-permission-system`](https://github.com/gotgenes/pi-permission-system) is installed, this extension integrates automatically:
+
+- **Per-agent permission policies** — define `permission:` in agent YAML frontmatter to set allow/ask/deny rules per agent type.
+  The permission system resolves the agent name from the `<active_agent>` tag in the child system prompt.
+- **Tool filtering** — the permission system's `before_agent_start` handler removes denied tools from the child session before the agent starts.
+- **`ask`-state forwarding** — when a child session triggers an `ask` permission, the prompt forwards to the parent session's UI.
+  The parent approves or denies, and the child resumes.
+- **Deterministic child detection** — every child session registers with the permission system's `SubagentSessionRegistry` before `bindExtensions()` fires, so detection does not rely on env vars or filesystem heuristics.
+
+No configuration is required.
+When `@gotgenes/pi-permission-system` is not installed, the registration calls are silent no-ops.
+
 ## Architecture
 
+See `docs/architecture/architecture.md` for the full architecture document with domain decomposition, Mermaid diagrams, and improvement roadmap.
+
 ```text
 src/
-  index.ts            # Extension entry: tool/command registration, rendering
-  types.ts            # Type definitions (AgentConfig, AgentRecord, etc.)
-  default-agents.ts   # Embedded default agent configs (general-purpose, Explore, Plan)
-  agent-types.ts      # Unified agent registry (defaults + user), tool name resolution
-  agent-runner.ts     # Session creation, execution, graceful max_turns, steer/resume
-  agent-manager.ts    # Agent lifecycle, concurrency queue, completion notifications
-  custom-agents.ts    # Load user-defined agents from .pi/agents/*.md
-  memory.ts           # Persistent agent memory (resolve, read, build prompt blocks)
-  skill-loader.ts     # Preload skills (Pi-standard + Agent Skills spec layouts)
-  output-file.ts      # Streaming output file transcripts for agent sessions
-  worktree.ts         # Git worktree isolation (create, cleanup, prune)
-  prompts.ts          # Config-driven system prompt builder
-  context.ts          # Parent conversation context for inherit_context
-  env.ts              # Environment detection (git, platform)
-  ui/
-    agent-widget.ts       # Persistent widget: spinners, activity, status icons, theming
-    conversation-viewer.ts # Live conversation overlay for viewing agent sessions
+  index.ts                          # Extension entry: tool/command registration, rendering
+  runtime.ts                        # Session-scoped state bag with methods
+  types.ts                          # Shared type definitions
+  settings.ts                       # Persistent settings (concurrency, turn limits)
+  config/                           # Agent type registry and configuration
+    agent-types.ts                  # Unified agent registry (defaults + custom)
+    default-agents.ts               # Embedded default agent configs
+    custom-agents.ts                # Load user-defined agents from .pi/agents/*.md
+    invocation-config.ts            # Per-call merge of tool params + agent config
+  session/                          # Pure session assembly
+    session-config.ts               # Session configuration assembler
+    prompts.ts                      # Config-driven system prompt builder
+    context.ts                      # Parent conversation context for inherit_context
+    skill-loader.ts                 # Preload skills from Pi-standard + Agent Skills spec
+    env.ts                          # Environment detection (git, platform)
+    model-resolver.ts               # Fuzzy model matching
+  lifecycle/                        # Agent execution and state tracking
+    agent-manager.ts                # Spawn, queue, abort, resume, concurrency
+    agent-runner.ts                 # Session creation, turn loop, tool filtering
+    agent-record.ts                 # Status state machine
+    parent-snapshot.ts              # Immutable spawn-time parent state
+    permission-bridge.ts            # Optional bridge to pi-permission-system registry
+    worktree.ts                     # Git worktree isolation
+  observation/                      # Progress tracking and notification
+    record-observer.ts              # Session-event stats observer
+    notification.ts                 # Completion nudges
+  service/                          # Cross-extension API boundary
+    service.ts                      # SubagentsService interface + Symbol.for() accessors
+    service-adapter.ts              # SubagentsService wrapper around AgentManager
+  tools/                            # LLM-facing tools
+  ui/                               # Widget, conversation viewer, /agents menu
 ```
 
 ## Deviations from upstream
@@ -458,6 +488,9 @@ Each has a corresponding upstream PR:
 3. **`<active_agent>` system-prompt tag** (`src/prompts.ts`) — `buildAgentPrompt` prepends `<active_agent name="${config.name}"/>` to every assembled child system prompt (both `replace` and `append` modes).
    Downstream extensions like [`@gotgenes/pi-permission-system`](https://github.com/gotgenes/pi-permission-system) parse this tag to resolve per-agent `permission:` frontmatter inside the child session.
    Upstream PR: [tintinweb/pi-subagents#73](https://github.com/tintinweb/pi-subagents/pull/73).
+4. **Permission-system registration** (`src/lifecycle/permission-bridge.ts`) — `runAgent` registers every child session with `@gotgenes/pi-permission-system`'s `SubagentSessionRegistry` before `bindExtensions()` and unregisters in the `finally` block.
+   This enables deterministic child detection and `ask`-state forwarding to the parent UI.
+   No upstream equivalent — this feature is specific to the `@gotgenes` fork.
 
 The upstream `vitest` suite plus tests added for each patch all pass on every commit.
 

package/docs/architecture/architecture.md

@@ -259,6 +259,7 @@ src/
 │   ├── agent-record.ts             status state machine
 │   ├── parent-snapshot.ts          immutable spawn-time parent state
 │   ├── execution-state.ts          session/output phase state
+│   ├── permission-bridge.ts        optional bridge to pi-permission-system registry
 │   ├── worktree.ts                 git worktree isolation
 │   ├── worktree-state.ts           worktree phase state
 │   └── usage.ts                    token usage tracking
@@ -333,7 +334,8 @@ They declare this package as an optional peer dependency and use dynamic import
 
 - The three tools: `Agent`, `get_subagent_result`, `steer_subagent`.
 - `AgentManager` — spawn, queue, abort, resume, concurrency control.
-- `agent-runner` — session creation, turn loop, tool filtering, extension binding (Patches 2 and 3).
+- `agent-runner` — session creation, turn loop, tool filtering, extension binding (Patches 2 and 3), permission-system registration.
+- `permission-bridge` — optional cross-extension bridge to `@gotgenes/pi-permission-system`; registers each child session with `SubagentSessionRegistry` before `bindExtensions()` so the permission system detects in-process children deterministically.
 - `session-config` — pure configuration assembler (extracted from `agent-runner`).
 - `SubagentRuntime` — session-scoped state bag with methods.
 - `ParentSnapshot` — immutable snapshot of parent session state, captured once at spawn time.

package/docs/plans/0215-decompose-build-parent-context.md

@@ -0,0 +1,166 @@
+---
+issue: 215
+issue_title: "Decompose buildParentContext (cognitive 30) (Phase 13, Step 2)"
+---
+
+# Decompose `buildParentContext`
+
+## Problem Statement
+
+`buildParentContext` in `src/session/context.ts` is the only remaining fallow refactoring target in the package.
+The function has a cognitive complexity of 30, driven by a loop with three type-check branches (`message`, `compaction`, default), each with sub-branches for role (`user` vs `assistant`) and content type (`string` vs array).
+The architecture roadmap (Phase 13, Step 2) targets cognitive complexity < 10 and function body < 15 LOC.
+
+## Goals
+
+- Extract per-entry-type formatters: `formatMessageEntry(entry)` and `formatCompactionEntry(entry)`.
+- Reduce `buildParentContext` to a loop + filter + join orchestrator (< 15 LOC).
+- Achieve cognitive complexity < 10 for all functions in the file.
+- Add unit tests for the extracted formatters and the orchestrator.
+
+## Non-Goals
+
+- Changing the public API surface (`buildParentContext`, `extractText`) — signatures stay the same.
+- Moving `extractText` to another module (noted as a follow-up in prior plans but out of scope).
+- Refactoring callers (`parent-snapshot.ts`) — they are already tested via mocks.
+
+## Background
+
+### Current file: `src/session/context.ts`
+
+The file exports two functions:
+
+1. `extractText(content: unknown[]): string` — filters an array of content blocks to `TextContent` items and joins their `.text` values.
+   Used by `agent-runner.ts`, `message-formatters.ts`, and `buildParentContext` itself.
+2. `buildParentContext(ctx: SessionContext): string` — iterates session branch entries, formatting `message` entries (user/assistant) and `compaction` entries into a text representation prefixed with a header.
+
+The file also defines three local types (`MessageEntry`, `CompactionEntry`, `BranchEntry`) and one helper (`isTextContent`).
+
+### Callers
+
+- `buildParentContext` is called only from `parent-snapshot.ts` (where it is mocked in tests).
+- `extractText` is called from `agent-runner.ts`, `message-formatters.ts`, and internally within `buildParentContext`.
+
+### Existing tests
+
+There are no direct unit tests for `context.ts`.
+`parent-snapshot.test.ts` mocks `buildParentContext` entirely, so the formatting logic is currently untested.
+
+## Design Overview
+
+### Extracted formatters
+
+Each formatter takes a typed entry and returns `string | undefined` (undefined when the entry should be skipped):
+
+```typescript
+function formatMessageEntry(entry: MessageEntry): string | undefined {
+  const msg = entry.message;
+  const text =
+    typeof msg.content === "string"
+      ? msg.content
+      : extractText(msg.content);
+  if (!text.trim()) return undefined;
+  if (msg.role === "user") return `[User]: ${text.trim()}`;
+  if (msg.role === "assistant") return `[Assistant]: ${text.trim()}`;
+  return undefined; // skip toolResult and other roles
+}
+
+function formatCompactionEntry(entry: CompactionEntry): string | undefined {
+  return entry.summary ? `[Summary]: ${entry.summary}` : undefined;
+}
+```
+
+### Simplified orchestrator
+
+```typescript
+export function buildParentContext(ctx: SessionContext): string {
+  const entries = ctx.sessionManager.getBranch();
+  if (!entries || entries.length === 0) return "";
+
+  const parts = (entries as BranchEntry[])
+    .map(formatBranchEntry)
+    .filter((p): p is string => p !== undefined);
+
+  if (parts.length === 0) return "";
+
+  return `# Parent Conversation Context
+The following is the conversation history from the parent session that spawned you.
+Use this context to understand what has been discussed and decided so far.
+
+${parts.join("\n\n")}
+
+---
+# Your Task (below)
+`;
+}
+```
+
+A thin dispatcher (`formatBranchEntry`) routes by `type`:
+
+```typescript
+function formatBranchEntry(entry: BranchEntry): string | undefined {
+  if (entry.type === "message") return formatMessageEntry(entry as MessageEntry);
+  if (entry.type === "compaction") return formatCompactionEntry(entry as CompactionEntry);
+  return undefined;
+}
+```
+
+### Complexity analysis
+
+- `formatMessageEntry`: 3 branches (string-vs-array, empty check, role) — estimated cognitive complexity ~4.
+- `formatCompactionEntry`: 1 branch — estimated cognitive complexity ~1.
+- `formatBranchEntry`: 2 branches — estimated cognitive complexity ~2.
+- `buildParentContext`: 2 branches (empty entries, empty parts) — estimated cognitive complexity ~3.
+
+All well under the < 10 target.
+
+## Module-Level Changes
+
+### `src/session/context.ts`
+
+1. Add `formatMessageEntry(entry: MessageEntry): string | undefined` — private helper.
+2. Add `formatCompactionEntry(entry: CompactionEntry): string | undefined` — private helper.
+3. Add `formatBranchEntry(entry: BranchEntry): string | undefined` — private dispatcher.
+4. Simplify `buildParentContext` body to use `map(formatBranchEntry).filter(...)`.
+5. No changes to exports — `buildParentContext` and `extractText` signatures are unchanged.
+6. No changes to local types (`MessageEntry`, `CompactionEntry`, `BranchEntry`) or `isTextContent`.
+
+### `test/session/context.test.ts` (new)
+
+Unit tests for:
+
+- `extractText` — string extraction from mixed content arrays.
+- `buildParentContext` — end-to-end formatting with user, assistant, compaction, and skipped entries.
+
+The formatters are private, so they are tested indirectly through `buildParentContext`.
+
+## Test Impact Analysis
+
+1. The new `context.test.ts` enables direct testing of formatting logic that was previously untested (mocked away in `parent-snapshot.test.ts`).
+2. No existing tests become redundant — `parent-snapshot.test.ts` tests snapshot assembly, not formatting.
+3. No existing tests need modification — the public API is unchanged.
+
+## TDD Order
+
+1. **Red → Green:** Add `test/session/context.test.ts` with tests for `extractText` — empty array, text-only, mixed content types, no text content.
+   Commit: `test: add extractText unit tests (#215)`
+
+2. **Red → Green:** Add tests for `buildParentContext` — empty branch, user messages, assistant messages, compaction entries with/without summary, mixed entry types, entries with empty text (skipped), non-message/non-compaction entries (skipped), string vs array content.
+   Commit: `test: add buildParentContext unit tests (#215)`
+
+3. **Refactor:** Extract `formatMessageEntry`, `formatCompactionEntry`, and `formatBranchEntry` from `buildParentContext`.
+   Simplify `buildParentContext` to map/filter/join.
+   All tests from steps 1–2 must still pass.
+   Commit: `refactor: decompose buildParentContext into per-entry formatters (#215)`
+
+## Risks and Mitigations
+
+| Risk                                                                                               | Mitigation                                                           |
+| -------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| Behavioral regression in formatting                                                                | Steps 1–2 lock in current behavior with tests before refactoring     |
+| Extracted helpers expose implementation details                                                    | Helpers are private (not exported); tested indirectly via public API |
+| `eslint-disable` comment for `no-unnecessary-condition` on `getBranch()` check may need adjustment | Preserve the comment — runtime nullability is documented             |
+
+## Open Questions
+
+None — the decomposition target and strategy are specified by the architecture roadmap.

package/docs/retro/0215-decompose-build-parent-context.md

@@ -0,0 +1,35 @@
+---
+issue: 215
+issue_title: "Decompose buildParentContext (cognitive 30) (Phase 13, Step 2)"
+---
+
+# Retro: #215 — Decompose buildParentContext
+
+## Stage: Planning (2026-05-25T12:00:00Z)
+
+### Session summary
+
+Produced a 3-step TDD plan to decompose `buildParentContext` in `src/session/context.ts`.
+Steps 1–2 add tests locking current behavior for `extractText` and `buildParentContext`; step 3 extracts three private helpers (`formatMessageEntry`, `formatCompactionEntry`, `formatBranchEntry`) and simplifies the orchestrator to map/filter/join.
+
+### Observations
+
+- No existing unit tests cover `context.ts` — `parent-snapshot.test.ts` mocks `buildParentContext` entirely, so the formatting logic is currently untested.
+- The decomposition is straightforward with no design ambiguity; the architecture roadmap specifies the exact extraction targets.
+- All extracted helpers remain private (not exported), keeping the public API surface unchanged.
+- The `eslint-disable` comment on the `getBranch()` nullability check must be preserved through the refactoring step.
+
+## Stage: Implementation — TDD (2026-05-25T22:36:00Z)
+
+### Session summary
+
+Completed all 3 TDD steps: 2 test-only commits locking `extractText` (5 tests) and `buildParentContext` (14 tests) behavior, then a refactor commit extracting `formatMessageEntry`, `formatCompactionEntry`, and `formatBranchEntry`.
+Test count increased from 939 to 958 (+19).
+All checks green: full suite, `pnpm run check`, `pnpm run lint`, `pnpm fallow dead-code`.
+
+### Observations
+
+- Because `extractText` and `buildParentContext` already existed, both test steps passed immediately (no red phase) — this is correct for behavior-locking tests before a refactor.
+- The `makeCtx` helper in the test file creates a minimal `SessionContext` satisfying only `sessionManager.getBranch()`; the extra required fields (`cwd`, `model`, `modelRegistry`, `getSystemPrompt`) are satisfied with stubs.
+- The `eslint-disable` comment on the `getBranch()` nullability check was preserved unchanged through the refactor.
+- No deviations from the plan.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotgenes/pi-subagents",
-  "version": "7.4.0",
+  "version": "7.5.1",
   "type": "module",
   "exports": {
     ".": "./src/service.ts"

package/src/lifecycle/agent-runner.ts

@@ -11,6 +11,7 @@ import {
 import type { AgentConfigLookup } from "#src/config/agent-types";
 import type { ParentSessionInfo } from "#src/lifecycle/agent-manager";
 import type { ParentSnapshot } from "#src/lifecycle/parent-snapshot";
+import { registerChildSession, unregisterChildSession } from "#src/lifecycle/permission-bridge";
 import { extractAssistantContent } from "#src/session/content-items";
 import { extractText } from "#src/session/context";
 import type { EnvInfo } from "#src/session/env";
@@ -347,6 +348,15 @@ export async function runAgent(
     session.setActiveToolsByName(filtered);
   }
 
+  // Register with pi-permission-system's SubagentSessionRegistry before
+  // bindExtensions() so isSubagentExecutionContext() hits the registry on the
+  // first check during child extension initialization. Unregistered in the
+  // finally block below to guarantee cleanup on both success and error paths.
+  registerChildSession(sessionDir, {
+    agentName: type,
+    parentSessionId: options.context.parentSession?.parentSessionId,
+  });
+
   // Bind extensions so that session_start fires and extensions can initialize
   // (e.g. loading credentials, setting up state). Placed after tool filtering
   // so extension-provided skills/prompts from extendResourcesFromExtensions()
@@ -406,6 +416,7 @@ export async function runAgent(
     unsubTurns();
     collector.unsubscribe();
     cleanupAbort();
+    unregisterChildSession(sessionDir);
   }
 
   const responseText =

package/src/lifecycle/permission-bridge.ts

@@ -0,0 +1,63 @@
+/**
+ * permission-bridge.ts — Cross-extension bridge to @gotgenes/pi-permission-system.
+ *
+ * pi-subagents does not import pi-permission-system directly. Instead it
+ * accesses the published PermissionsService via a process-global Symbol.for()
+ * key, the same mechanism pi-permission-system uses to publish itself.
+ *
+ * When pi-permission-system is not installed, getPermissionsService() returns
+ * undefined and all registration calls are silent no-ops.
+ */
+
+/**
+ * The two PermissionsService methods pi-subagents needs.
+ *
+ * Follows ISP — does not expose the full PermissionsService surface
+ * (checkPermission, getToolPermission, etc.) to avoid coupling.
+ */
+interface PermissionsServiceConsumer {
+	registerSubagentSession(
+		sessionKey: string,
+		info: { parentSessionId?: string; agentName: string },
+	): void;
+	unregisterSubagentSession(sessionKey: string): void;
+}
+
+const PERMISSION_SERVICE_KEY = Symbol.for(
+	"@gotgenes/pi-permission-system:service",
+);
+
+function getPermissionsService(): PermissionsServiceConsumer | undefined {
+	return (globalThis as Record<symbol, unknown>)[
+		PERMISSION_SERVICE_KEY
+	] as PermissionsServiceConsumer | undefined;
+}
+
+/**
+ * Register a child session with pi-permission-system's SubagentSessionRegistry.
+ *
+ * Must be called after deriving sessionDir but before session.bindExtensions()
+ * so isSubagentExecutionContext() hits the registry on the first check during
+ * child extension initialization.
+ *
+ * @param sessionKey - The session directory path (unique per session).
+ * @param info       - Agent name and optional parent session ID for forwarding.
+ */
+export function registerChildSession(
+	sessionKey: string,
+	info: { parentSessionId?: string; agentName: string },
+): void {
+	getPermissionsService()?.registerSubagentSession(sessionKey, info);
+}
+
+/**
+ * Unregister a child session from pi-permission-system's SubagentSessionRegistry.
+ *
+ * Must be called in a finally block so cleanup happens on both success and
+ * error paths.
+ *
+ * @param sessionKey - The session directory path used during registration.
+ */
+export function unregisterChildSession(sessionKey: string): void {
+	getPermissionsService()?.unregisterSubagentSession(sessionKey);
+}

package/src/session/context.ts

@@ -30,6 +30,28 @@ export function extractText(content: unknown[]): string {
     .join("\n");
 }
 
+/** Format a message entry (user/assistant); returns undefined for roles to skip. */
+function formatMessageEntry(entry: MessageEntry): string | undefined {
+  const msg = entry.message;
+  const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
+  if (!text.trim()) return undefined;
+  if (msg.role === "user") return `[User]: ${text.trim()}`;
+  if (msg.role === "assistant") return `[Assistant]: ${text.trim()}`;
+  return undefined; // skip toolResult and other roles
+}
+
+/** Format a compaction entry; returns undefined when no summary is present. */
+function formatCompactionEntry(entry: CompactionEntry): string | undefined {
+  return entry.summary ? `[Summary]: ${entry.summary}` : undefined;
+}
+
+/** Dispatch a branch entry to the appropriate formatter. */
+function formatBranchEntry(entry: BranchEntry): string | undefined {
+  if (entry.type === "message") return formatMessageEntry(entry as MessageEntry);
+  if (entry.type === "compaction") return formatCompactionEntry(entry as CompactionEntry);
+  return undefined;
+}
+
 /**
  * Build a text representation of the parent conversation context.
  * Used when inherit_context is true to give the subagent visibility
@@ -40,30 +62,9 @@ export function buildParentContext(ctx: SessionContext): string {
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- getBranch() may return undefined at runtime despite its type
   if (!entries || entries.length === 0) return "";
 
-  const parts: string[] = [];
-
-  for (const rawEntry of entries as BranchEntry[]) {
-    if (rawEntry.type === "message") {
-      const entry = rawEntry as MessageEntry;
-      const msg = entry.message;
-      if (msg.role === "user") {
-        const text = typeof msg.content === "string"
-          ? msg.content
-          : extractText(msg.content);
-        if (text.trim()) parts.push(`[User]: ${text.trim()}`);
-      } else if (msg.role === "assistant") {
-        const text = typeof msg.content === "string" ? msg.content : extractText(msg.content);
-        if (text.trim()) parts.push(`[Assistant]: ${text.trim()}`);
-      }
-      // Skip toolResult messages — too verbose for context
-    } else if (rawEntry.type === "compaction") {
-      // Include compaction summaries — they're already condensed
-      const entry = rawEntry as CompactionEntry;
-      if (entry.summary) {
-        parts.push(`[Summary]: ${entry.summary}`);
-      }
-    }
-  }
+  const parts = (entries as BranchEntry[])
+    .map(formatBranchEntry)
+    .filter((p): p is string => p !== undefined);
 
   if (parts.length === 0) return "";
 

package/src/ui/agent-menu.ts

@@ -72,9 +72,9 @@ export class AgentsMenuHandler {
     private readonly registry: AgentTypeRegistry,
     private readonly agentActivity: AgentActivityReader,
     private readonly settings: AgentMenuSettings,
-    private readonly fileOps: AgentFileOps,
-    private readonly personalAgentsDir: string,
-    private readonly projectAgentsDir: string,
+    fileOps: AgentFileOps,
+    personalAgentsDir: string,
+    projectAgentsDir: string,
   ) {
     this.editor = new AgentConfigEditor(
       fileOps,