pi-landstrip 0.17.16 → 0.17.18

package/README.md

@@ -1,26 +1,26 @@
 # pi-landstrip
 
-`pi-landstrip` is an extension for [pi](https://pi.dev/) providing sandbox-aware
-subagents and a sandbox defined with a policy compatible with Anthropic's JSON
-format. It uses [`landstrip`](https://github.com/landstrip/landstrip) to
-implement the sandbox.
+`pi-landstrip` is a [Pi](https://pi.dev/) extension that provides sandboxed Bash
+execution, OpenCode-compatible primary agents, and sandbox-aware subagents. It
+uses an Anthropic-compatible policy and delegates OS-level enforcement to
+[`landstrip`](https://github.com/landstrip/landstrip).
 
-`pi-landstrip` has a shared sandbox policy [sandbox.json](./sandbox.json) and a
-separate [subagents.json](./subagents.json) for primary-agent and subagent
-configuration. Global and trusted project files can override both.
+The extension includes a shared [sandbox policy](./sandbox.json) and separate
+[agent configuration](./subagents.json). Global and trusted-project files can
+override both.
 
-Pi >=0.80.6 <0.81.0 and Node.js >=22.19.0 are required for process-backed subagents.
+Process-backed subagents require Pi >= 0.80.6 and < 0.81.0, and Node.js >= 22.19.0.
 
-## Installing the extension
+## Installation
 
 ### Automatic install
 
-```
+```sh
 pi install npm:pi-landstrip
 ```
 
 This installs `pi-landstrip` and its `@landstrip/landstrip` dependency. Native
-binaries are currently published for Linux x64, Windows x64, and macOS x64/arm64.
+binaries are published for Linux, macOS, and Windows on x64 and Arm64.
 
 ### Manual install
 
@@ -33,13 +33,13 @@ Add the extension to `~/.pi/agent/settings.json` (global) or
 }
 ```
 
-Alternatively, drop the extension under `~/.pi/agent/extensions/` (global) or
-`.pi/extensions/` (project). See the pi
-[extensions](https://pi.dev/docs/latest/extensions) documentation for details.
+Alternatively, place the extension under `~/.pi/agent/extensions/` (global) or
+`.pi/extensions/` (project). See Pi's
+[extension documentation](https://pi.dev/docs/latest/extensions) for details.
 
 On unsupported platforms the extension loads but leaves sandboxing disabled.
 
-## Disable
+## Disabling
 
 Use the `--no-sandbox` flag, or set `enabled` to `false` in `sandbox.json`:
 
@@ -60,23 +60,23 @@ without a project-trust API use only global configuration.
 
 ## Behavior
 
-When pi asks for a sandboxed permission, the extension emits a host
-notification. After that the extension opens a dialog with the choices to allow
-once, allow for the session, persist for the project, persist globally, or
-reject. The dialog shows the exact path or domain being approved.
+When Pi requests a sandboxed permission, the extension sends a host notification
+and opens a dialog. The user can allow once, allow for the session, persist for
+the project or globally, or reject. The dialog shows the exact path or domain
+being approved.
 
 Project approvals are written to `.pi/sandbox.json`; global approvals are
 written to `~/.pi/agent/sandbox.json`.
 
-The main agent remains a normal Pi process. Pi performs its usual filesystem
-tool and plugin composition; `pi-landstrip` replaces Bash execution, including
-AI `bash` calls and manually typed shell-mode commands (`!` and `!!`), with a
-Landstrip-wrapped implementation. Network traffic is routed through an
-allowlist proxy when network access is off. Main-agent filesystem tools and
-plugin callbacks remain trusted Pi code and are not confined by Landstrip. The
-default policy for Bash and subagent processes is strict: network access is off
-unless domains are allowed, reads are limited to the project, `~/.gitconfig`,
-and `/dev/null`, and writes are limited to the project and `/dev/null`.
+The main agent remains a normal Pi process. `pi-landstrip` replaces Bash
+execution, including AI `bash` calls and manually typed shell commands (`!` and
+`!!`), with a Landstrip-wrapped implementation. Network traffic uses an
+allowlist proxy when direct access is disabled. Pi's filesystem tools and plugin
+callbacks remain trusted code outside the Landstrip sandbox.
+
+By default, Bash and subagent processes have no direct network access. Reads are
+limited to the project, Git configuration, and `/dev/null`; writes are limited
+to the project and `/dev/null`.
 
 Subagent startup adds read-only bootstrap access to the selected Pi runtime,
 global settings, model/auth configuration, installed plugins, skills, and the
@@ -84,32 +84,30 @@ task's dedicated session directory. These paths are required to construct a
 normal Pi worker and are not persisted into `sandbox.json`. The worker receives
 write access only to its own session and temporary directories.
 
-Use `/sandbox` inside Pi to inspect the active policy and toggle sandboxing. Use
-`/agents` to select the primary role; its Settings tab controls the global and
-trusted-project maximum number of concurrent subagents.
+Use `/sandbox` to inspect the active policy and toggle sandboxing. Use `/agents`
+to select the primary role, inspect worker configuration and status, and set the
+global or trusted-project concurrency limit.
 
 ## Primary agents
 
-The `/agents` selector provides OpenCode-compatible `build` and `plan` roles by default.
-Build has normal development access; plan asks before shell commands and file
-changes. The selection controls the root system prompt and permissions and is
-restored with the session.
+The `/agents` selector provides OpenCode-compatible `build` and `plan` roles by
+default. Build has normal development access; plan asks before shell commands
+and file changes. The selection controls the root system prompt and permissions
+and is restored with the session.
 
 ## Subagents
 
-Landstrip provides an OpenCode-compatible `task` tool. Each active task is a
-full `pi --mode rpc` process under one outer Landstrip instance. The sandbox
-covers Pi itself, its plugins and tools, model requests, and every descendant
-process. The root Pi supervises RPC, permissions, nesting, persistence, and
-completion delivery.
+Landstrip provides an OpenCode-compatible `task` tool. Each active task runs as a
+full `pi --mode rpc` process inside an outer Landstrip sandbox. The sandbox
+covers Pi, its plugins and tools, model requests, and descendant processes. The
+root Pi process supervises RPC, permissions, nesting, persistence, and result
+delivery.
 
-The worker uses normal Pi resource discovery and plugin loading from the Pi
-filesystem, plus the pi-landstrip worker extension. Its requested active tool
-names come from the parent, but their implementations are composed normally in
-the worker: plugins can add or replace tools, including replacements such as
-`pi-readseek`. Every task run starts a fresh Pi process and fresh plugin
-instances. Continuing a `task_id` restores its persisted Pi session in a new
-worker process.
+Workers use normal Pi resource discovery and plugin loading, plus the
+`pi-landstrip` worker extension. Requested tools are composed inside the worker,
+so plugins can add or replace implementations. Each task starts a fresh Pi
+process and plugin instances; continuing a `task_id` restores its persisted Pi
+session in a new process.
 
 The tool accepts the OpenCode task fields:
 
@@ -125,21 +123,24 @@ The tool accepts the OpenCode task fields:
 ```
 
 Foreground tasks return the child result directly. Background tasks return a
-running result while the worker continues, then deliver completion to the
-parent automatically. The process exits when the run settles; its Pi session
-remains on disk and can be continued with `task_id`. While tasks are active, Pi
-shows their parent-child tree automatically above the editor.
+queued result and deliver completion automatically. Task rows show lifecycle
+state, current activity, tool-call count, elapsed time, and expandable output.
+Use `/subagents` or the task row's `/subagents <id>` command to inspect a child
+transcript. Completed and failed task metadata remains available after reload,
+and persisted sessions can be continued with `task_id`.
+
 Session switching or shutdown stops live workers. After an unclean restart,
-unfinished work is marked interrupted rather than silently rerun; a completed
-but undelivered background result is delivered when the root session resumes.
+unfinished work is marked interrupted; completed but undelivered background
+results are delivered when the root session resumes.
 
-OpenCode-style worker permissions are enforced around the worker's composed
-tools: `deny` blocks a call, `ask` suspends that worker and asks in the root UI,
-and `allow` lets the tool run. Other workers may continue while a prompt is
-open. An "Allow for this session" worker-permission decision applies to the
-root session and its descendants. These permissions are separate from the
-outer Landstrip policy and cannot widen it. Sandbox approvals continue to use
-`.pi/sandbox.json` and `~/.pi/agent/sandbox.json`.
+OpenCode-style permissions wrap each worker's composed tools: `deny` blocks,
+`ask` prompts in the root UI, and `allow` runs the tool. Other workers may
+continue while a prompt is open. Forwarded worker dialogs identify the agent,
+task summary, and task ID. An "Allow for this session" decision applies to the
+root session and its descendants.
+
+Tool permissions cannot widen the outer Landstrip policy. Sandbox approvals
+continue to use `.pi/sandbox.json` and `~/.pi/agent/sandbox.json`.
 
 Subagents fail closed when sandboxing is expected but unavailable, unsupported,
 or missing. An explicit `--no-sandbox` flag or `enabled: false` configuration is
@@ -172,13 +173,14 @@ first.
 
 ## Configuration
 
-Subagent configuration is read from `~/.pi/agent/subagents.json` and, for
-trusted projects, `.pi/subagents.json`. Project values override global values;
-both are merged over the packaged [default](./subagents.json). Sandbox policy
-continues to use `~/.pi/agent/sandbox.json` and `.pi/sandbox.json`. Pi's
-`settings.json` contains only normal Pi settings such as the `pi-landstrip`
-package entry. `subagents.json` accepts only top-level `maxSubagents` and
-`subagents`; sandbox fields belong only in `sandbox.json`.
+Subagent configuration is read from `~/.pi/agent/subagents.json` and, for trusted
+projects, `.pi/subagents.json`. Project values override global values; both are
+merged over the packaged [defaults](./subagents.json). Sandbox policy remains in
+`~/.pi/agent/sandbox.json` and `.pi/sandbox.json`. Pi's `settings.json` contains
+only normal Pi settings, such as the `pi-landstrip` package entry.
+
+`subagents.json` accepts only top-level `maxSubagents` and `subagents`; sandbox
+fields belong in `sandbox.json`.
 
 ```json
 {
@@ -205,10 +207,10 @@ package entry. `subagents.json` accepts only top-level `maxSubagents` and
 }
 ```
 
-`maxSubagents` is an integer from 0 through 16 controlling concurrent worker
-processes. Setting it to zero removes the `task` tool while retaining the primary
-roles. There is no separate subagent enable switch. The Settings tab in `/agents`
-edits this limit separately for global and trusted-project configuration.
+`maxSubagents` is an integer from 0 through 16 controlling concurrent workers.
+The packaged default is 0, which removes the `task` tool while retaining primary
+roles. There is no separate subagent enable switch. The Settings tab in
+`/agents` edits this limit for global and trusted-project configuration.
 
 Agent modes, hidden/disabled agents, prompts, and ordered `allow`/`ask`/`deny`
 permissions apply to primary agents and subagents. Subagent workers also honor
@@ -218,7 +220,7 @@ matching permission rules win. Put provider-specific values under `options`;
 unknown agent fields are rejected. Agent permissions cannot weaken an enabled
 OS sandbox, grant filesystem access, or grant network access.
 
-## Migrating configuration
+## Configuration migration
 
 There is no compatibility loader for previous subagent configuration sources.
 Legacy keys in `settings.json` produce a migration warning. Move configuration as
@@ -234,22 +236,23 @@ follows, then remove the old fields:
 - Leave sandbox policy in `~/.pi/agent/sandbox.json` and `.pi/sandbox.json`;
   those files are unchanged.
 
-Do not put `subagents`, `agent`, `permission`, or `maxSubagents` in Pi's
-`settings.json`; Pi-Landstrip does not read them there.
+Do not put these fields in Pi's `settings.json`; `pi-landstrip` does not read
+them there.
 
 ## Limits
 
-Pi-Landstrip runs at most `maxSubagents` worker processes concurrently and
-allows nesting to three levels. A foreground parent hands its scheduler permit to a child
-while waiting, preventing nested-task deadlocks. A worker receives a nested
-`task` tool only when its agent has an explicit `task` permission. Nested tasks
-are separate Pi processes supervised by the root and Landstrip-wrapped unless
-sandboxing is explicitly disabled. Persisted sessions remain resumable by `task_id`.
+`pi-landstrip` grants at most `maxSubagents` scheduler permits to active
+subagent work and allows nesting to three levels. A foreground parent returns
+its permit while waiting for a child and reacquires it before resuming,
+preventing nested-task deadlocks. A worker receives a nested `task` tool only
+when its agent has an explicit `task` permission. Nested tasks are separate Pi
+processes supervised by the root and Landstrip-wrapped unless sandboxing is
+explicitly disabled, so an inactive parent process can remain alive during the
+handoff. Persisted sessions remain resumable by `task_id`.
 
 ## License
 
-`pi-landstrip` is licensed under `Apache-2.0`. See [LICENSE](LICENSE) for more
-information.
+`pi-landstrip` is licensed under `Apache-2.0`. See [LICENSE](LICENSE).
 
 The bundled `@landstrip/landstrip` package is licensed separately as
 `Apache-2.0 AND LGPL-2.1-or-later`.

package/index.ts

@@ -60,7 +60,7 @@ import {
   registerSubagentWorker,
   workerConfigFromEnvironment,
 } from './subagents.ts';
-import { availablePrimaryAgents } from './agents.ts';
+import { availablePrimaryAgents, availableSubagents } from './agents.ts';
 import { loadLandstripConfig, MAX_SUBAGENTS, setMaxSubagentsConfigForScope } from './config.ts';
 
 interface SandboxFilesystemConfig {
@@ -2366,41 +2366,116 @@ export function createLandstripIntegration(
         if (!ctx.hasUI) return;
         const config = loadConfig(ctx.cwd);
         const { globalPath, projectPath } = getConfigPaths(ctx.cwd);
-        const status = noSandboxFlag
-          ? 'disabled by --no-sandbox'
-          : config.enabled && sandboxEnabled && sandboxReady
-            ? 'active'
-            : config.enabled
-              ? 'inactive'
-              : 'disabled by config';
-        const list = (values: string[]): string => values.join(', ') || 'none';
-        const summary = [
-          `Status: ${status}`,
-          `landstrip package binary: ${landstripDisplayPath()}`,
-          '',
-          'Config files',
-          `${projectPath} ${existsSync(projectPath) ? '(found)' : '(missing)'}`,
-          `${globalPath} ${existsSync(globalPath) ? '(found)' : '(missing)'}`,
-          '',
-          `Network: ${config.network.allowNetwork ? 'unrestricted' : 'proxied'}`,
-          `allow network: ${config.network.allowNetwork ? 'yes' : 'no'}`,
-          `allowed: ${list(config.network.allowedDomains)}`,
-          `denied: ${list(config.network.deniedDomains)}`,
-          `unix sockets: ${config.network.allowAllUnixSockets ? 'all' : list(config.network.allowUnixSockets)}`,
-          '',
-          'Filesystem',
-          `deny read: ${list(config.filesystem.denyRead)}`,
-          `allow read: ${list(config.filesystem.allowRead)}`,
-          `allow write: ${list(config.filesystem.allowWrite)}`,
-          `deny write: ${list(config.filesystem.denyWrite)}`,
-        ].join('\n');
-        const enabled = !config.enabled;
-        const confirmed = await ctx.ui.confirm(
-          'Sandbox',
-          `${summary}\n\n${enabled ? 'Enable' : 'Disable'} the sandbox?`,
+        const shouldToggle = await ctx.ui.custom<boolean>(
+          (_tui, theme, _kb, done) => {
+            const dim = (value: string) => theme.fg('dim', value);
+            const muted = (value: string) => theme.fg('muted', value);
+            const accent = (value: string) => theme.fg('accent', value);
+            const text = (value: string) => theme.fg('text', value);
+
+            function sandboxStatus(): { color: 'success' | 'warning'; label: string } {
+              if (noSandboxFlag) return { color: 'warning', label: 'Disabled (--no-sandbox)' };
+              if (!config.enabled) return { color: 'warning', label: 'Disabled' };
+              if (!sandboxEnabled || !sandboxReady) return { color: 'warning', label: 'Inactive' };
+              return { color: 'success', label: 'Active' };
+            }
+
+            function boolValue(value: boolean): string {
+              return value ? theme.fg('warning', 'yes') : theme.fg('success', 'no');
+            }
+
+            return {
+              render(width: number): string[] {
+                const innerWidth = Math.max(1, width - 4);
+                const row = (content = '') => boxRow(theme, width, content);
+                const lines = [boxTop(theme, width, 'Sandbox')];
+                const status = sandboxStatus();
+                const statusDot = theme.fg(status.color, '●');
+                const pathSnippet = text(
+                  truncateToWidth(landstripDisplayPath(), Math.max(20, innerWidth - 28)),
+                );
+                const section = (title: string, detail?: string): void => {
+                  lines.push(row(''));
+                  lines.push(row(`${accent(title)}${detail ? dim(` · ${detail}`) : ''}`));
+                };
+                const item = (label: string, value: string): void => {
+                  lines.push(row(`  ${dim('•')} ${muted(label.padEnd(13))} ${value}`));
+                };
+                const listValue = (values: string[]): string => {
+                  const value = values.join(', ') || 'none';
+                  return text(truncateToWidth(value, Math.max(10, innerWidth - 17)));
+                };
+
+                lines.push(
+                  row(
+                    `${statusDot} ${text(status.label)} ${dim('·')} ${muted('landstrip')} ${pathSnippet}`,
+                  ),
+                );
+
+                section('Config');
+                item('project', text(projectPath));
+                item('global', text(globalPath));
+
+                const networkMode = config.network.allowNetwork ? 'unrestricted' : 'proxied';
+                section('Network', networkMode);
+                item('allow network', boolValue(config.network.allowNetwork));
+                item('allowed', listValue(config.network.allowedDomains));
+                item('denied', listValue(config.network.deniedDomains));
+                item(
+                  'unix sockets',
+                  config.network.allowAllUnixSockets
+                    ? text('all')
+                    : listValue(config.network.allowUnixSockets),
+                );
+                if (sessionAllowedDomains.length > 0) {
+                  item('session', theme.fg('accent', sessionAllowedDomains.join(', ')));
+                }
+
+                section('Filesystem');
+                item('deny read', listValue(config.filesystem.denyRead));
+                item('allow read', listValue(config.filesystem.allowRead));
+                item('allow write', listValue(config.filesystem.allowWrite));
+                item('deny write', listValue(config.filesystem.denyWrite));
+
+                if (sessionAllowedReadPaths.length > 0 || sessionAllowedWritePaths.length > 0) {
+                  section('Session grants');
+                  if (sessionAllowedReadPaths.length > 0) {
+                    item('read', theme.fg('accent', sessionAllowedReadPaths.join(', ')));
+                  }
+                  if (sessionAllowedWritePaths.length > 0) {
+                    item('write', theme.fg('accent', sessionAllowedWritePaths.join(', ')));
+                  }
+                }
+
+                lines.push(
+                  row(''),
+                  row(
+                    `${dim('enter')} ${muted(config.enabled ? 'disable' : 'enable')}  ${dim('esc')} ${muted('close')}`,
+                  ),
+                  boxBottom(theme, width),
+                );
+                return lines;
+              },
+
+              handleInput(data: string): void {
+                if (matchesKey(data, 'return')) {
+                  done(true);
+                  return;
+                }
+                if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c')) done(false);
+              },
+
+              invalidate(): void {},
+            };
+          },
+          {
+            overlay: true,
+            overlayOptions: { anchor: 'center', width: 78, margin: 2 },
+          },
         );
-        if (!confirmed) return;
+        if (!shouldToggle) return;
 
+        const enabled = !config.enabled;
         try {
           const scope = await setSandboxConfigEnabled(ctx.cwd, enabled, projectConfigTrusted);
           if (!enabled) {
@@ -2425,7 +2500,7 @@ export function createLandstripIntegration(
         if (!ctx.hasUI) return;
         await ctx.ui.custom(
           (tui, theme, _kb, done) => {
-            let tab: 'agents' | 'settings' = 'agents';
+            let tab: 'agents' | 'subagents' | 'settings' = 'agents';
             const initialAgents = runtime
               ? availablePrimaryAgents(runtime.getAgentCatalog(ctx))
               : [];
@@ -2433,12 +2508,22 @@ export function createLandstripIntegration(
               0,
               initialAgents.findIndex((agent) => agent.name === runtime?.getPrimaryAgent()?.name),
             );
+            let selectedSubagent = 0;
             let selectedSetting = 0;
             let values = [
               loadLandstripConfig(ctx.cwd, false).maxSubagents,
               loadLandstripConfig(ctx.cwd, projectConfigTrusted).maxSubagents,
             ];
             let editing = false;
+            const supportedVariants = new Set([
+              'off',
+              'minimal',
+              'low',
+              'medium',
+              'high',
+              'xhigh',
+              'max',
+            ]);
             const dim = (value: string) => theme.fg('dim', value);
             const muted = (value: string) => theme.fg('muted', value);
             const accent = (value: string) => theme.fg('accent', value);
@@ -2450,7 +2535,7 @@ export function createLandstripIntegration(
                 const lines = [boxTop(theme, width, 'Agents')];
                 lines.push(
                   row(
-                    ` ${tab === 'agents' ? accent('Agents') : muted('Agents')} ${dim('│')} ${tab === 'settings' ? accent('Settings') : muted('Settings')}`,
+                    ` ${tab === 'agents' ? accent('Agents') : muted('Agents')} ${dim('│')} ${tab === 'subagents' ? accent('Subagents') : muted('Subagents')} ${dim('│')} ${tab === 'settings' ? accent('Settings') : muted('Settings')}`,
                   ),
                   row(''),
                 );
@@ -2466,8 +2551,73 @@ export function createLandstripIntegration(
                     const cursor = selected ? accent('›') : ' ';
                     const active = agent.name === activeAgent ? theme.fg('success', '●') : dim('○');
                     const name = selected ? accent(agent.name) : text(agent.name);
+                    const model = dim(`  ${agent.model ?? 'current model'}`);
                     const description = agent.description ? dim(`  ${agent.description}`) : '';
-                    lines.push(row(`${cursor} ${active} ${name}${description}`));
+                    lines.push(row(`${cursor} ${active} ${name}${model}${description}`));
+                  }
+                } else if (tab === 'subagents') {
+                  const catalog = runtime?.getAgentCatalog(ctx);
+                  const agents = catalog ? availableSubagents(catalog) : [];
+                  selectedSubagent = Math.min(selectedSubagent, Math.max(0, agents.length - 1));
+                  if (agents.length === 0) lines.push(row(muted('No subagents configured')));
+                  const start = Math.max(0, Math.min(selectedSubagent - 3, agents.length - 7));
+                  for (const [offset, agent] of agents.slice(start, start + 7).entries()) {
+                    const index = start + offset;
+                    const selected = index === selectedSubagent;
+                    const cursor = selected ? accent('›') : ' ';
+                    const name = selected ? accent(`@${agent.name}`) : text(`@${agent.name}`);
+                    const flags = [agent.model ?? 'current model', agent.mode];
+                    if (agent.hidden) flags.push('hidden');
+                    lines.push(row(`${cursor} ${name} ${dim(flags.join(' · '))}`));
+                  }
+
+                  const agent = agents[selectedSubagent];
+                  if (agent) {
+                    lines.push(row(''));
+                    const details = [
+                      `model ${agent.model ?? 'current model'}`,
+                      agent.variant ? `variant ${agent.variant}` : undefined,
+                      agent.steps ? `${agent.steps} steps` : undefined,
+                    ].filter(Boolean);
+                    lines.push(row(`  ${text(details.join(' · '))}`));
+                    const permissions = [...(catalog?.permissions ?? []), ...agent.permissions];
+                    lines.push(row(`  ${dim('Permissions')}`));
+                    if (permissions.length === 0) lines.push(row(`    ${muted('default: ask')}`));
+                    for (const rule of permissions.slice(0, 4)) {
+                      lines.push(
+                        row(
+                          `    ${text(`${rule.permission}:${rule.pattern}`)} ${dim('→')} ${theme.fg(
+                            rule.action === 'deny'
+                              ? 'error'
+                              : rule.action === 'allow'
+                                ? 'success'
+                                : 'warning',
+                            rule.action,
+                          )}`,
+                        ),
+                      );
+                    }
+                    if (permissions.length > 4) {
+                      lines.push(row(`    ${muted(`… ${permissions.length - 4} more`)}`));
+                    }
+                    const unsupported = Object.keys(agent.providerOptions);
+                    if (agent.variant && !supportedVariants.has(agent.variant)) {
+                      unsupported.push(`variant=${agent.variant}`);
+                    }
+                    const unsupportedText =
+                      unsupported.length > 0 ? unsupported.join(', ') : 'none';
+                    lines.push(
+                      row(`  ${dim('Unsupported RPC options:')} ${text(unsupportedText)}`),
+                    );
+                  }
+                  if ((catalog?.diagnostics.length ?? 0) > 0) {
+                    lines.push(row(`  ${theme.fg('error', 'Catalog diagnostics')}`));
+                    for (const diagnostic of catalog?.diagnostics.slice(0, 3) ?? []) {
+                      lines.push(row(`    ${theme.fg('error', diagnostic)}`));
+                    }
+                  }
+                  for (const warning of catalog?.warnings.slice(0, 2) ?? []) {
+                    lines.push(row(`  ${theme.fg('warning', warning)}`));
                   }
                 } else {
                   const scopes = ['Global', 'Project'] as const;
@@ -2492,8 +2642,10 @@ export function createLandstripIntegration(
                   row(''),
                   row(
                     tab === 'agents'
-                      ? `${dim('↑↓')} ${muted('select')}  ${dim('enter')} ${muted('activate')}  ${dim('tab')} ${muted('settings')}  ${dim('esc')} ${muted('close')}`
-                      : `${dim('↑↓')} ${muted('scope')}  ${dim('0-9/+/-')} ${muted('change')}  ${dim('enter')} ${muted('save')}  ${dim('tab')} ${muted('agents')}  ${dim('esc')} ${muted('close')}`,
+                      ? `${dim('↑↓')} ${muted('select')}  ${dim('enter')} ${muted('activate')}  ${dim('tab')} ${muted('subagents')}  ${dim('esc')} ${muted('close')}`
+                      : tab === 'subagents'
+                        ? `${dim('↑↓')} ${muted('inspect')}  ${dim('tab')} ${muted('settings')}  ${dim('esc')} ${muted('close')}`
+                        : `${dim('↑↓')} ${muted('scope')}  ${dim('0-9/+/-')} ${muted('change')}  ${dim('enter')} ${muted('save')}  ${dim('tab')} ${muted('agents')}  ${dim('esc')} ${muted('close')}`,
                   ),
                   boxBottom(theme, width),
                 );
@@ -2510,7 +2662,10 @@ export function createLandstripIntegration(
                   matchesKey(data, 'left') ||
                   matchesKey(data, 'right')
                 ) {
-                  tab = tab === 'agents' ? 'settings' : 'agents';
+                  const tabs = ['agents', 'subagents', 'settings'] as const;
+                  const current = tabs.indexOf(tab);
+                  const offset = matchesKey(data, 'left') ? -1 : 1;
+                  tab = tabs[(current + offset + tabs.length) % tabs.length] ?? 'agents';
                   editing = false;
                   tui.requestRender();
                   return;
@@ -2528,6 +2683,20 @@ export function createLandstripIntegration(
                   tui.requestRender();
                   return;
                 }
+                if (tab === 'subagents') {
+                  const catalog = runtime?.getAgentCatalog(ctx);
+                  const agents = catalog ? availableSubagents(catalog) : [];
+                  if (matchesKey(data, 'up')) {
+                    selectedSubagent = Math.max(0, selectedSubagent - 1);
+                  } else if (matchesKey(data, 'down')) {
+                    selectedSubagent = Math.min(
+                      Math.max(0, agents.length - 1),
+                      selectedSubagent + 1,
+                    );
+                  } else return;
+                  tui.requestRender();
+                  return;
+                }
 
                 if (matchesKey(data, 'up')) {
                   selectedSetting = Math.max(0, selectedSetting - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.17.16",
+  "version": "0.17.18",
   "description": "Sandbox-aware Pi subagents and interactive command permissions",
   "keywords": [
     "landstrip",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.80.6",
-    "@landstrip/landstrip": "^0.17.16",
+    "@landstrip/landstrip": "^0.17.18",
     "minimatch": "^10.2.5"
   },
   "devDependencies": {