pi-landstrip 0.18.0 → 0.18.2

package/README.md

@@ -1,21 +1,14 @@
 # pi-landstrip
 
-```
-Subagents  3 active
-├─ ● running  @explore  Design Pi entry parsing
-├─ ● running  @general  Design trigger serialization
-└─ ● running  @general  Design bounded summaries
-```
+<img alt="Screenshot of Pi running pi-landstrip" src="screenshot.png" width="800">
 
-`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
+`pi-landstrip` adds sandboxed Bash, primary agents, and sandboxed subagents to
+[Pi](https://pi.dev/). OS isolation is provided by
 [`landstrip`](https://github.com/landstrip/landstrip).
 
-The extension includes a shared [sandbox policy](./sandbox.json). Agent definitions,
-worker limits, shared permissions, and OpenCode integration flags live under
-`landstrip` in Pi `settings.json`. Trusted-project settings override global settings
-and built-in agent defaults.
+The package includes a default [sandbox policy](./sandbox.json). Configure agents,
+subagent limits, permissions, and OpenCode imports under `landstrip` in Pi
+`settings.json`. Trusted project settings override global settings.
 
 Process-backed subagents require Pi >= 0.82.0, and Node.js >= 22.19.0.
 
@@ -47,14 +40,11 @@ Alternatively, place the extension under `~/.pi/agent/extensions/` (global) or
 
 On unsupported platforms the extension loads but leaves sandboxing disabled.
 
-On Windows, Pi's Git Bash/MSYS shell cannot run under LPAC. The packaged policy
-therefore selects standard AppContainer explicitly. This is weaker than LPAC
-because resources granted to `ALL APPLICATION PACKAGES` remain visible;
-`/sandbox` and the status line report the active implementation and mode. There
-is no silent LPAC-to-standard fallback.
+Pi's Git Bash/MSYS shell cannot start in LPAC, so the default Windows policy uses
+standard AppContainer. `/sandbox` and the status line show the active Windows
+isolation. LPAC launch failures return an error.
 
-Optional restricted-user installation supports Git Bash without AppContainer.
-It requires one-time elevation and persistent local accounts and WFP rules; see
+Restricted-user isolation supports Git Bash with restricted local accounts. See
 [Windows restricted-user installation](#windows-restricted-user-installation).
 
 ## Disabling
@@ -78,11 +68,10 @@ without a project-trust API use only global configuration.
 
 ## Behavior
 
-When a sandboxed command requests access not already covered by policy, 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 requested. Project approvals are written to `.pi/sandbox.json`;
-global approvals are written to `~/.pi/agent/sandbox.json`.
+When a command requests additional access, the extension opens an approval dialog.
+The user can allow once, allow for the session, save the approval globally or for the
+project, or reject it. Project approvals go to `.pi/sandbox.json`; global approvals
+go to `~/.pi/agent/sandbox.json`.
 
 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
@@ -101,64 +90,39 @@ 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` to inspect the active policy and toggle sandboxing. `/agents` is the
-single interface for selecting the primary role, inspecting every configured agent
-and task session, and setting the global or trusted-project concurrency limit.
+Use `/sandbox` to inspect or disable the sandbox. Use `/agents` to select a primary
+agent, inspect primary agents, subagents, and tasks, and set subagent limits.
 
 ## Permission model
 
-Agent permissions and sandbox permissions are separate policy layers. They have
-different targets and make decisions at different stages:
-
-| Layer              | Target                                           | Decision point       | Governs                                                             |
-| ------------------ | ------------------------------------------------ | -------------------- | ------------------------------------------------------------------- |
-| Agent permission   | A primary agent or subagent                      | Before tool dispatch | Whether that agent may invoke a tool with the declared arguments    |
-| Sandbox permission | A sandboxed command and its descendant processes | During execution     | The filesystem and network operations the command actually attempts |
+Agent and sandbox permissions apply at different stages:
 
-The execution path is:
+| Layer              | Checked before or during | Controls                                   |
+| ------------------ | ------------------------ | ------------------------------------------ |
+| Agent permission   | Before tool dispatch     | Which tools an agent may call              |
+| Sandbox permission | During process execution | Filesystem and network access for commands |
 
 ```text
-agent → agent permission check → tool command → sandbox → OS resource
+agent → agent permission → tool → sandbox → OS resource
 ```
 
-The two kinds of query are triggered independently. An agent `ask` decision comes
-from the selected primary or subagent definition and holds the tool call before it is
-dispatched. A sandbox query comes from the command reaching the OS boundary. Where
-the platform supports dynamic queries, such as Linux seccomp traps, this can happen
-after the process has started; the broker holds the operation while the user decides.
-
-Neither policy can replace the other:
-
-- An agent `allow` permits tool dispatch but cannot widen the sandbox.
-- A sandbox approval permits a concrete OS operation but does not authorize an agent
-  to invoke a tool denied by its agent policy.
-- Agent policy describes tool requests known before dispatch. Sandbox policy constrains
-  executable behavior, including unexpected or malicious native code.
-- Agent and sandbox approvals are tracked separately and do not imply one another.
-
-For example, an agent may be allowed to invoke Bash, while the launched executable is
-still blocked or queried when it attempts `openat("/home/user/.ssh/config")` or
-`connect("127.0.0.1:5432")`.
+Each layer prompts independently. An agent approval allows tool dispatch; sandbox
+restrictions still apply to the resulting process.
 
 ## Primary agents
 
-The `/agents` dialog provides one catalog for every configured agent. Each entry
-shows whether its mode is `primary`, `subagent`, or `all`; primary-capable entries
-can be activated from the list. OpenCode-compatible `build` and `plan` roles are
-provided by default. Build has normal development access; plan asks before shell
-commands and file changes. Their built-in colors appear in the status line and
-agent catalog.
-The selection controls the root system prompt and permissions and is restored
-with the session. Press `Ctrl+Shift+A` while Pi is idle to cycle through enabled
-primary agents; switching is blocked while an agent run is active.
+`/agents` lists all configured agents and their modes. Press Enter to activate a
+visible primary agent. The built-in primary agents are `build` and `plan`. Build has
+normal development access; plan asks before shell commands and file edits.
+
+The selected prompt and permissions are stored in the session. Press `Ctrl+Shift+A`
+while Pi is idle to cycle through visible primary agents.
 
 ## Subagents
 
-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 `task` tool runs each subagent in a separate `pi --mode rpc` process inside a
+Landstrip sandbox. The root Pi process manages RPC, permissions, nesting, sessions,
+and results.
 
 Workers use normal Pi resource discovery and plugin loading, plus the
 `pi-landstrip` worker extension. Requested tools are composed inside the worker,
@@ -166,7 +130,7 @@ 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:
+The tool accepts these fields:
 
 ```json
 {
@@ -179,28 +143,18 @@ The tool accepts the OpenCode task fields:
 }
 ```
 
-Foreground tasks return the child result directly. Background tasks return a
-queued result and deliver completion automatically. Task rows show lifecycle
-state, current activity, tool-call count, elapsed time, and expandable output.
-The **Sessions** tab in `/agents` inspects child transcripts and supports parent and
-sibling navigation. Open a specific task directly with `/agents <id>`. Completed and
-failed task metadata remains available after reload, and persisted sessions can be
-continued with `task_id`.
+Foreground tasks return their result directly. Background tasks return immediately
+and report completion later. The **Tasks** tab in `/agents` shows task status and
+output. Open a task with `/agents <id>`. Continue a saved session with `task_id`.
 
 Session switching or shutdown stops live workers. After an unclean restart,
 unfinished work is marked interrupted; completed but undelivered background
 results are delivered when the root session resumes.
 
-Agent permissions wrap each worker's composed tools: `deny` blocks dispatch, `ask`
-prompts in the root UI, and `allow` runs the tool. Other workers may continue while
-an agent-permission prompt is open. Forwarded dialogs identify the agent, task
-summary, and task ID. An "Allow for this session" decision applies to the root
-session and its descendants.
-
-Subagents fail closed when sandboxing is expected but unavailable, unsupported,
-or missing. An explicit `--no-sandbox` flag or `enabled: false` configuration is
-treated as an intentional opt-out and uses the warned unsandboxed process path.
-Unsupported Pi versions still fail task startup.
+Workers check agent permissions before tool dispatch: `deny` blocks, `ask` prompts in
+the root UI, and `allow` runs the tool. Required sandbox startup failures stop the
+task. With `--no-sandbox` or `enabled: false`, workers run without OS isolation and
+Pi shows a warning.
 
 ### Platform behavior
 
@@ -236,30 +190,21 @@ first.
 
 ## Configuration
 
-The two permission layers deliberately use different configuration files:
-
-- Agent policy belongs under `landstrip` in Pi `settings.json`. It controls which
-  primary agents and subagents exist and which tools they may dispatch.
-- Sandbox policy belongs in `sandbox.json`. It controls the filesystem and network
-  operations attempted by sandboxed commands and worker processes.
-
-Rules cannot be copied between these files: the schemas, targets, and enforcement
-stages are different, so an agent rule is neither valid nor equivalent as a sandbox
-rule, or vice versa.
+Agent permissions are configured under `landstrip` in Pi `settings.json`. Sandbox
+permissions are configured in `sandbox.json`. The files use different schemas and
+control different stages.
 
 ### Agent policy (`settings.json`)
 
-Agent configuration is read from `landstrip` in `~/.pi/agent/settings.json` and, for
-trusted projects, `.pi/settings.json`. Project values override global values; both
-are merged over internal defaults. The built-in subagents are `code-reviewer`,
-`explore`, `general`, and the OpenCode-compatible `scout` reconnaissance agent.
+Agent settings are read from `~/.pi/agent/settings.json` and, for trusted projects,
+`.pi/settings.json`. Built-in subagents are `explore`, `general`, and `scout`.
 
-The read-only `code-reviewer` is available without additional configuration: delegate
-with `task` using `subagent_type: "code-reviewer"`. It can read and search files and
-run a fixed set of non-mutating Git inspection commands; all other tools are denied.
+Pi Markdown agents are loaded from `~/.pi/agent/agents/*.md` and, for trusted
+projects, `.pi/agents/*.md`. Nested directories are supported. Project Markdown
+agents override global Markdown agents. Settings under `landstrip.agent` override
+Markdown and OpenCode agents with the same name.
 
-An agent configuration example follows. This belongs in Pi `settings.json`, not
-`sandbox.json`:
+Add agent configuration under `landstrip` in Pi `settings.json`:
 
 ```json
 {
@@ -286,30 +231,21 @@ An agent configuration example follows. This belongs in Pi `settings.json`, not
 }
 ```
 
-`landstrip.maxSubagents` is an integer from 0 through 16 controlling concurrent
-workers. The default is 1, making `task` and `code-reviewer` available immediately.
-Set it to 0 to remove 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.
-
-`landstrip.permission` defines the shared baseline inherited by every agent. Each
-`landstrip.agent.<name>.permission` map overrides that baseline. Agent modes,
-hidden/disabled agents, prompts, colors, and ordered `allow`/`ask`/`deny` permissions
-apply to primary agents and subagents. Prompt strings may include OpenCode-style
-`{file:path}` tokens; relative paths resolve against the `settings.json` file that
-defines them. `color` accepts `#RRGGBB` or OpenCode theme names (`primary`,
-`secondary`, `accent`, `success`, `warning`, `error`, `info`). `hidden` removes an
-agent from the user-facing catalog; the model can still invoke a hidden agent whose
-mode supports subagent work via `task`.
-
-Primary agents honor configured models and supported Pi thinking-level variants;
-omitting either preserves the current session setting. A model may use the full
-`provider/model` name or a bare model ID when that ID is unique. Selection fails
-without changing the active primary agent when the model is missing, ambiguous, or
-unavailable for authentication. Subagent workers also honor model selection,
-supported Pi thinking-level variants, and step limits. Later matching permission
-rules win. Put provider-specific values under `options`; unknown agent fields are
-rejected.
+`landstrip.maxSubagents` sets the maximum number of concurrent subagents from 0 to 16. The default is 1; zero disables `task`. The `/agents` **Settings** tab provides
+**Maximum subagents (global)** and **Maximum subagents (local)**.
+
+`landstrip.permission` applies to every agent. Each
+`landstrip.agent.<name>.permission` map adds agent-specific rules; later matching
+rules win. Agent definitions support `mode`, `prompt`, `model`, `variant`, `steps`,
+`color`, `disable`, and `allow`/`ask`/`deny` permissions. `{file:path}` prompt
+references are resolved from the defining `settings.json`. Provider-specific fields
+belong under `options`.
+
+`hidden` removes an agent from `/agents`. A hidden, subagent-capable agent remains
+available to `task`. Agent `mode` controls activation: only `primary` and `all` agents
+can be selected as primary, while only `subagent` and `all` agents can be passed to
+`task`. Missing, ambiguous, or unauthenticated primary-agent models produce an error
+and leave the current agent active.
 
 OpenCode integration flags also live in Pi `settings.json` under
 `landstrip.opencode`; both default to `true`:
@@ -334,25 +270,18 @@ OpenCode integration flags also live in Pi `settings.json` under
   `opencode.jsonc`, `.opencode/opencode.json` and `.opencode/opencode.jsonc`, and
   Markdown agents under `.opencode/agent/` and `.opencode/agents/`.
 
-Project settings override global settings, including each OpenCode flag. Set a flag
-to `false` to disable that source. OpenCode project agents override global OpenCode
-agents. Definitions from `landstrip.agent` (built-in, global, and project) take
-precedence over OpenCode imports with the same name; conflicts are silent. Project
-Pi settings and project OpenCode agents are skipped when the project is untrusted;
-global OpenCode agents still load when `showGlobalAgents` is enabled.
-
-OpenCode JSONC comments and trailing commas are supported. `{file:path}` prompt tokens
-resolve relative to the OpenCode config file or Pi `settings.json` that defines them.
+Set either flag to `false` to disable that OpenCode source. Project OpenCode agents
+override global OpenCode agents. Pi Markdown agents and `landstrip.agent` settings
+take precedence over OpenCode imports. Project sources require a trusted project.
+OpenCode config files support JSONC comments, trailing commas, and `{file:path}`
+prompt references.
 
 ### Sandbox policy (`sandbox.json`)
 
-Sandbox policy is read from `~/.pi/agent/sandbox.json` and, for trusted projects,
-`.pi/sandbox.json`. It grants runtime filesystem and network access to sandboxed
-commands; it does not grant an agent permission to dispatch a tool. Likewise, an
-agent `allow` cannot grant filesystem or network access through the sandbox.
+Sandbox settings are read from `~/.pi/agent/sandbox.json` and, for trusted projects,
+`.pi/sandbox.json`. They control runtime filesystem and network access.
 
-For example, Windows sandbox fields belong in `sandbox.json`, not Pi
-`settings.json`:
+Configure Windows sandbox fields in `sandbox.json`:
 
 ```json
 {
@@ -363,11 +292,9 @@ For example, Windows sandbox fields belong in `sandbox.json`, not Pi
 }
 ```
 
-`appContainerMode` is `"lpac"` or `"standard"`; core Landstrip defaults to LPAC,
-while the Pi package defaults to standard mode for Git Bash compatibility.
-`allowLoopback` is independently opt-in and applies only while AppContainer is
-active. Windows implementation selection is automatic and cannot be changed by
-project configuration.
+`appContainerMode` accepts `"lpac"` or `"standard"`. The Pi package defaults to
+standard mode for Git Bash. `allowLoopback` applies only to AppContainer. Landstrip
+selects Windows isolation automatically.
 
 #### Windows restricted-user installation
 
@@ -378,39 +305,19 @@ npx @landstrip/landstrip windows install
 npx @landstrip/landstrip windows status
 ```
 
-Install requests UAC elevation and defaults to eight restricted-network
-accounts, two unrestricted-network accounts, and proxy ports 60080-60111. Run
-`npx @landstrip/landstrip windows install --help` for pool and port options, then
-restart Pi. Uninstalling returns Landstrip to AppContainer automatically.
+Installation requests elevation and creates eight restricted-network accounts, two
+unrestricted-network accounts, and proxy ports 60080–60111 by default. Use
+`windows install --help` to change these values. Restart Pi after installation.
 
-The extension checks the active implementation and installation health before a
-sandboxed launch. An unhealthy installation fails rather than falling back to
-AppContainer. Restricted-user mode does not support `windows.allowLoopback` or
-`network.allowLocalBinding`. Remove the persistent accounts, WFP rules, runner,
-and recovered per-run ACL grants with:
+Before each launch, the extension checks the installation. A failed health check
+stops the task. Restricted-user isolation does not support `windows.allowLoopback`
+or `network.allowLocalBinding`. Remove the accounts, WFP rules, runner, and ACL
+grants with:
 
 ```powershell
 npx @landstrip/landstrip windows uninstall
 ```
 
-## Configuration migration
-
-`subagents.json` is no longer supported. Move its values into the corresponding
-global or project Pi `settings.json`, then delete the old file:
-
-- Move top-level `maxSubagents` to `landstrip.maxSubagents`.
-- Move `subagents.agent` to `landstrip.agent`.
-- Move `subagents.permission` to `landstrip.permission`.
-- Move top-level `opencode` to `landstrip.opencode`.
-- Convert legacy `tools` booleans to explicit `permission` rules.
-- Move legacy top-level Pi `agent`, `permission`, `subagents`, and `maxSubagents`
-  settings under `landstrip`.
-- Leave sandbox policy in `~/.pi/agent/sandbox.json` and `.pi/sandbox.json`; those
-  files are unchanged.
-
-An existing `~/.pi/agent/subagents.json` or trusted-project `.pi/subagents.json`
-produces an actionable migration diagnostic instead of being loaded.
-
 ## Plugin API
 
 Pi extensions can discover the active Landstrip runtime through the versioned

package/dist/index.ts

@@ -3,10 +3,10 @@ import { spawn as spawn2, spawnSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import {
-  existsSync as existsSync5,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync3,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync5,
   realpathSync as realpathSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync3
@@ -19,7 +19,7 @@ import {
   Socket as NetSocket
 } from "node:net";
 import { homedir as homedir4, tmpdir as tmpdir2 } from "node:os";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute3, join as join6, parse, resolve as resolve3 } from "node:path";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute3, join as join6, parse, resolve as resolve3 } from "node:path";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 import { fileURLToPath as fileURLToPath2, URL } from "node:url";
 import {
@@ -70,18 +70,18 @@ function encodeLandstripContext(context) {
 // subagents.ts
 import { randomUUID } from "node:crypto";
 import {
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   lstatSync,
   mkdirSync as mkdirSync2,
   mkdtempSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync4,
   readlinkSync,
   realpathSync,
   rmSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   getAgentDir as getAgentDir3,
@@ -92,7 +92,6 @@ import { matchesKey, Text, truncateToWidth as truncateToWidth2 } from "@earendil
 import { Type } from "typebox";
 
 // agents.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import { join as join4 } from "node:path";
 import { minimatch } from "minimatch";
 import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
@@ -113,46 +112,20 @@ var BUILT_IN_LANDSTRIP_CONFIG = {
       prompt: "Work in build mode. Implement, test, and complete the requested changes."
     },
     plan: {
-      description: "Planning agent that asks before commands or file changes",
+      description: "Planning agent that asks before shell commands and file edits",
       mode: "primary",
       color: "warning",
       prompt: "Work in plan mode. Analyze the problem and produce a clear plan before making changes.",
       permission: { edit: "ask", bash: "ask", task: "ask" }
     },
-    "code-reviewer": {
-      description: "Read-only reviewer for concrete code defects",
-      mode: "subagent",
-      color: "info",
-      prompt: "Review the requested code without modifying files. Inspect correctness, security, regressions, tests, performance, and maintainability. Report only concrete findings ordered by severity with exact file and line references, explain the impact, and recommend a concise fix. State clearly when there are no findings. Git inspection permits only these exact commands: `git --no-optional-locks -c core.fsmonitor=false status --short`, `git --no-pager diff --no-ext-diff --no-textconv`, `git --no-pager diff --cached --no-ext-diff --no-textconv`, `git --no-pager log -20 --oneline`, and `git --no-pager show --stat --no-ext-diff --no-textconv`.",
-      permission: {
-        "*": "deny",
-        read: {
-          "*": "allow",
-          "**/*.env": "ask",
-          "**/*.env.*": "ask",
-          "**/*.env.example": "allow"
-        },
-        glob: "allow",
-        grep: "allow",
-        list: "allow",
-        bash: {
-          "*": "deny",
-          "git --no-optional-locks -c core.fsmonitor=false status --short": "allow",
-          "git --no-pager diff --no-ext-diff --no-textconv": "allow",
-          "git --no-pager diff --cached --no-ext-diff --no-textconv": "allow",
-          "git --no-pager log -20 --oneline": "allow",
-          "git --no-pager show --stat --no-ext-diff --no-textconv": "allow"
-        }
-      }
-    },
     general: {
-      description: "General-purpose agent for researching and executing complex tasks",
+      description: "General-purpose agent for complex tasks",
       mode: "subagent",
       prompt: "Complete the delegated task autonomously. Return one concise result to the parent.",
       permission: { todowrite: "deny" }
     },
     scout: {
-      description: "Fast codebase reconnaissance with concise handoff findings",
+      description: "Fast codebase reconnaissance",
       mode: "subagent",
       prompt: "Scout the codebase without modifying it. Return concise findings with exact file references, key code, architecture, and a recommended starting point.",
       permission: {
@@ -169,7 +142,7 @@ var BUILT_IN_LANDSTRIP_CONFIG = {
       }
     },
     explore: {
-      description: "Fast agent specialized for exploring codebases",
+      description: "Fast codebase exploration",
       mode: "subagent",
       prompt: "Explore the codebase without modifying it. Report findings with file references. Use bash and network fetch tools when needed for git, PR metadata, or remote docs; do not edit files.",
       permission: {
@@ -448,39 +421,39 @@ function getPiConfigPaths(cwd, fileName, agentDir = getAgentDir()) {
     projectPath: join2(cwd, ".pi", fileName)
   };
 }
-function assertNoSubagentsConfig(path) {
-  if (!existsSync(path))
-    return;
-  const settingsPath = join2(dirname(path), "settings.json");
-  throw new Error(`${path} is no longer supported; move its values to landstrip.maxSubagents, landstrip.agent, landstrip.permission, and landstrip.opencode in ${settingsPath}`);
-}
-async function setMaxSubagentsConfigForScope(cwd, maxSubagents, scope, agentDir = getAgentDir()) {
-  if (!Number.isInteger(maxSubagents) || maxSubagents < 0 || maxSubagents > MAX_SUBAGENTS) {
-    throw new Error(`maxSubagents must be an integer from 0 to ${MAX_SUBAGENTS}`);
-  }
+async function writeMaxSubagentsConfigForScope(cwd, maxSubagents, scope, agentDir) {
   const paths = getPiConfigPaths(cwd, "settings.json", agentDir);
   const path = scope === "global" ? paths.globalPath : paths.projectPath;
-  const legacyPaths = getPiConfigPaths(cwd, "subagents.json", agentDir);
-  assertNoSubagentsConfig(scope === "global" ? legacyPaths.globalPath : legacyPaths.projectPath);
   await withFileMutationQueue(path, async () => {
     const settings = existsSync(path) ? readJsonObject(path) : {};
     if (settings.landstrip !== undefined && !isRecord2(settings.landstrip)) {
       throw new Error(`${path}: landstrip must be a JSON object`);
     }
     const landstrip = isRecord2(settings.landstrip) ? { ...settings.landstrip } : {};
-    landstrip.maxSubagents = maxSubagents;
-    settings.landstrip = landstrip;
+    if (maxSubagents === undefined)
+      delete landstrip.maxSubagents;
+    else
+      landstrip.maxSubagents = maxSubagents;
+    if (Object.keys(landstrip).length === 0)
+      delete settings.landstrip;
+    else
+      settings.landstrip = landstrip;
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
   });
 }
+async function setMaxSubagentsConfigForScope(cwd, maxSubagents, scope, agentDir = getAgentDir()) {
+  if (!Number.isInteger(maxSubagents) || maxSubagents < 0 || maxSubagents > MAX_SUBAGENTS) {
+    throw new Error(`maxSubagents must be an integer from 0 to ${MAX_SUBAGENTS}`);
+  }
+  await writeMaxSubagentsConfigForScope(cwd, maxSubagents, scope, agentDir);
+}
+async function clearMaxSubagentsConfigForScope(cwd, scope, agentDir = getAgentDir()) {
+  await writeMaxSubagentsConfigForScope(cwd, undefined, scope, agentDir);
+}
 function loadLandstripConfig(cwd, includeProject = true, agentDir = getAgentDir()) {
   const settingsPaths = getPiConfigPaths(cwd, "settings.json", agentDir);
-  const legacyPaths = getPiConfigPaths(cwd, "subagents.json", agentDir);
-  assertNoSubagentsConfig(legacyPaths.globalPath);
-  if (includeProject)
-    assertNoSubagentsConfig(legacyPaths.projectPath);
   const builtInConfig = BUILT_IN_LANDSTRIP_CONFIG;
   const globalConfig = readLandstripSettings(settingsPaths.globalPath);
   const projectConfig = includeProject ? readLandstripSettings(settingsPaths.projectPath) : undefined;
@@ -501,11 +474,22 @@ function loadLandstripConfig(cwd, includeProject = true, agentDir = getAgentDir(
   const opencode = { ...DEFAULT_OPENCODE, ...config.opencode };
   return { ...config, maxSubagents, agent: config.agent, opencode, agentSources };
 }
+function loadMaxSubagentsSettings(cwd, includeProject = true, agentDir = getAgentDir()) {
+  const global = loadLandstripConfig(cwd, false, agentDir).maxSubagents;
+  if (!includeProject)
+    return { global };
+  const paths = getPiConfigPaths(cwd, "settings.json", agentDir);
+  const project = readLandstripSettings(paths.projectPath).maxSubagents;
+  if (project !== undefined && (!Number.isInteger(project) || project < 0 || project > MAX_SUBAGENTS)) {
+    throw new Error(`maxSubagents must be an integer from 0 to ${MAX_SUBAGENTS}`);
+  }
+  return { global, project };
+}
 
 // opencode-agents.ts
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { basename, dirname as dirname2, extname, join as join3, relative, sep } from "node:path";
+import { dirname as dirname2, extname, join as join3, relative, sep } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { parse as parseJsonc, printParseErrorCode } from "jsonc-parser";
 var AGENT_DIR_PREFIXES = ["agent/", "agents/"];
@@ -552,9 +536,8 @@ function agentNameFromPath(dir, filePath) {
       return extension2.length > 0 ? candidate.slice(0, -extension2.length) : candidate;
     }
   }
-  const base = basename(filePath);
-  const extension = extname(base);
-  return extension.length > 0 ? base.slice(0, -extension.length) : base;
+  const extension = extname(relativePath);
+  return extension.length > 0 ? relativePath.slice(0, -extension.length) : relativePath;
 }
 function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/);
@@ -689,26 +672,36 @@ function loadConfigAgentsFromDir(dir, source, agents, diagnostics) {
     loadAgentsFromConfigFile(join3(dir, file), source, agents, diagnostics);
   }
 }
-function loadAgentsFromDir(dir, source, agents, diagnostics) {
-  for (const subdir of ["agent", "agents"]) {
-    const root = join3(dir, subdir);
-    for (const filePath of listMarkdownFiles(root)) {
-      try {
-        const content = readFileSync3(filePath, "utf8");
-        const { data, body } = parseFrontmatter(content);
-        const name = agentNameFromPath(dir, filePath);
-        if (!name) {
-          diagnostics.push(`${filePath}: agent name is empty`);
-          continue;
-        }
-        const raw = normalizeOpenCodeAgentRaw(data, body.trim());
-        agents.set(name, { name, source, path: filePath, raw });
-      } catch (error) {
-        diagnostics.push(`${filePath}: ${formatError(error)}`);
+function loadAgentsFromRoot(root, nameRoot, source, agents, diagnostics) {
+  for (const filePath of listMarkdownFiles(root)) {
+    try {
+      const content = readFileSync3(filePath, "utf8");
+      const { data, body } = parseFrontmatter(content);
+      const name = agentNameFromPath(nameRoot, filePath);
+      if (!name) {
+        diagnostics.push(`${filePath}: agent name is empty`);
+        continue;
       }
+      const raw = normalizeOpenCodeAgentRaw(data, body.trim());
+      agents.set(name, { name, source, path: filePath, raw });
+    } catch (error) {
+      diagnostics.push(`${filePath}: ${formatError(error)}`);
     }
   }
 }
+function loadAgentsFromDir(dir, source, agents, diagnostics) {
+  for (const subdir of ["agent", "agents"]) {
+    loadAgentsFromRoot(join3(dir, subdir), dir, source, agents, diagnostics);
+  }
+}
+function loadPiMarkdownAgents(options) {
+  const agents = new Map;
+  const diagnostics = [];
+  for (const directory of options.directories) {
+    loadAgentsFromRoot(directory.path, directory.path, directory.source, agents, diagnostics);
+  }
+  return { agents, diagnostics };
+}
 function loadOpenCodeAgents(options) {
   const agents = new Map;
   const diagnostics = [];
@@ -773,24 +766,6 @@ function normalizePermissions(value) {
     throw new Error("permission must be allow, ask, deny, or a map");
   return Object.entries(value).flatMap(([permission, rules]) => permissionEntries(permission, rules));
 }
-function legacyConfigWarnings(piAgentDir) {
-  const path = join4(piAgentDir, "settings.json");
-  if (!existsSync3(path))
-    return [];
-  try {
-    const value = JSON.parse(readFileSync4(path, "utf8"));
-    if (!isRecord2(value))
-      return [];
-    const fields = ["agent", "permission", "subagents", "maxSubagents"].filter((field) => value[field] !== undefined);
-    if (fields.length === 0)
-      return [];
-    return [
-      `${path}: legacy ${fields.join(", ")} configuration is ignored; move it under landstrip`
-    ];
-  } catch {
-    return [];
-  }
-}
 function normalizeAgent(name, raw, source) {
   for (const field of ["description", "prompt", "model", "variant", "color"]) {
     if (raw[field] !== undefined && typeof raw[field] !== "string") {
@@ -846,10 +821,6 @@ function normalizeAgent(name, raw, source) {
   };
 }
 function loadAgentCatalog(cwd, piAgentDir = getAgentDir2(), includeProject = true) {
-  const warnings = [
-    ...legacyConfigWarnings(piAgentDir),
-    ...includeProject ? legacyConfigWarnings(join4(cwd, ".pi")) : []
-  ];
   const diagnostics = [];
   let maxSubagents = 0;
   let configuredAgents = {};
@@ -884,6 +855,22 @@ function loadAgentCatalog(cwd, piAgentDir = getAgentDir2(), includeProject = tru
       diagnostics.push(`${imported.path}: ${formatError(error)}`);
     }
   }
+  const piMarkdown = loadPiMarkdownAgents({
+    directories: [
+      { path: join4(piAgentDir, "agents"), source: "global" },
+      ...includeProject ? [{ path: join4(cwd, ".pi", "agents"), source: "local" }] : []
+    ]
+  });
+  diagnostics.push(...piMarkdown.diagnostics);
+  for (const imported of piMarkdown.agents.values()) {
+    try {
+      const agent = normalizeAgent(imported.name, imported.raw, imported.source);
+      if (agent)
+        normalized.set(imported.name, agent);
+    } catch (error) {
+      diagnostics.push(`${imported.path}: ${formatError(error)}`);
+    }
+  }
   for (const name of Object.keys(configuredAgents).sort()) {
     const value = configuredAgents[name];
     if (!isRecord2(value)) {
@@ -906,7 +893,7 @@ function loadAgentCatalog(cwd, piAgentDir = getAgentDir2(), includeProject = tru
   } catch (error) {
     diagnostics.push(formatError(error));
   }
-  return { agents: normalized, permissions, diagnostics, warnings, maxSubagents };
+  return { agents: normalized, permissions, diagnostics, maxSubagents };
 }
 function permissionDecision(rules, permission, resource = "*") {
   let decision = "ask";
@@ -1407,7 +1394,7 @@ function resolvePiPackage() {
     let dir2 = dirname3(entry);
     for (;; ) {
       const pkgPath = join5(dir2, "package.json");
-      if (existsSync4(pkgPath)) {
+      if (existsSync3(pkgPath)) {
         const pkg = readPiPackage(pkgPath);
         if (pkg)
           return pkg;
@@ -1421,7 +1408,7 @@ function resolvePiPackage() {
   let dir = packageDir;
   for (;; ) {
     const pkgPath = join5(dir, "node_modules", "@earendil-works", "pi-coding-agent", "package.json");
-    if (existsSync4(pkgPath)) {
+    if (existsSync3(pkgPath)) {
       const pkg = readPiPackage(pkgPath);
       if (pkg)
         return pkg;
@@ -1434,7 +1421,7 @@ function resolvePiPackage() {
 }
 function readPiPackage(pkgPath) {
   try {
-    const value = JSON.parse(readFileSync5(pkgPath, "utf8"));
+    const value = JSON.parse(readFileSync4(pkgPath, "utf8"));
     if (!isRecord2(value) || value.name !== "@earendil-works/pi-coding-agent" || typeof value.version !== "string") {
       return;
     }
@@ -1445,7 +1432,7 @@ function readPiPackage(pkgPath) {
     if (!binFile)
       return;
     const cliEntry = join5(dirname3(pkgPath), binFile);
-    if (!existsSync4(cliEntry))
+    if (!existsSync3(cliEntry))
       return;
     cachedPiPackage = { cliEntry, version: parts.slice(0, 3) };
     return cachedPiPackage;
@@ -1519,7 +1506,7 @@ function messageContentText(message) {
 `);
 }
 function taskTranscript(task) {
-  if (!task.sessionFile || !existsSync4(task.sessionFile)) {
+  if (!task.sessionFile || !existsSync3(task.sessionFile)) {
     const fallback = task.error ?? task.output ?? "Child session is not available yet.";
     return fallback.split(`
 `);
@@ -1764,7 +1751,7 @@ function canonicalPermissionPath(path, seen = new Set) {
       const parent = dirname3(existing);
       if (parent === existing)
         return path;
-      missing.unshift(basename2(existing));
+      missing.unshift(basename(existing));
       existing = parent;
     }
   }
@@ -2014,26 +2001,31 @@ ${this.primaryAgent.prompt}` };
       return;
     }
     const catalog = this.getAgentCatalog(ctx);
-    for (const warning of catalog.warnings)
-      ctx.ui.notify(warning, "warning");
     for (const diagnostic of catalog.diagnostics)
       ctx.ui.notify(diagnostic, "warning");
-    const agents = availableAgents(catalog);
+    const visibleAgents = availableAgents(catalog);
+    const primaryAgents = visibleAgents.filter((agent) => agentSupportsMode(agent, "primary"));
+    const subagents = visibleAgents.filter((agent) => agentSupportsMode(agent, "subagent"));
     const tasks = [...this.tasks.values()];
     const requested = args.trim();
     const projectTrusted = isProjectTrusted(ctx);
-    let tab = requested ? "sessions" : "agents";
-    let selectedAgent = Math.max(0, agents.findIndex((agent) => agent.name === this.primaryAgent?.name));
+    let tab = requested ? "tasks" : "primary";
+    let selectedPrimaryAgent = Math.max(0, primaryAgents.findIndex((agent) => agent.name === this.primaryAgent?.name));
+    let selectedSubagent = 0;
     let selectedTask = requested ? tasks.findIndex((task) => task.id === requested || task.id.startsWith(requested)) : 0;
     if (selectedTask < 0) {
       ctx.ui.notify(`Unknown task session: ${requested}`, "error");
       return;
     }
     let selectedSetting = 0;
-    let values = [
-      loadLandstripConfig(ctx.cwd, false).maxSubagents,
-      loadLandstripConfig(ctx.cwd, projectTrusted).maxSubagents
-    ];
+    let maxSubagentsSettings = loadMaxSubagentsSettings(ctx.cwd, projectTrusted);
+    const selectedMaxSubagents = () => selectedSetting === 0 ? maxSubagentsSettings.global : maxSubagentsSettings.project ?? maxSubagentsSettings.global;
+    const updateSelectedMaxSubagents = (value) => {
+      maxSubagentsSettings = selectedSetting === 0 ? { ...maxSubagentsSettings, global: value } : { ...maxSubagentsSettings, project: value };
+      dirtySettings.add(selectedSetting);
+    };
+    const dirtySettings = new Set;
+    let saving = false;
     let editing = false;
     let detail = requested.length > 0;
     let scroll = 0;
@@ -2046,8 +2038,10 @@ ${this.primaryAgent.prompt}` };
           boxBottom(theme, width)
         ];
         const tabLabel = (label, active) => active ? theme.fg("accent", theme.bold(`[${label}]`)) : theme.fg("muted", label);
-        const tabs = `${tabLabel("Agents", tab === "agents")}  ${tabLabel(`Sessions ${tasks.length}`, tab === "sessions")}  ${tabLabel("Settings", tab === "settings")}`;
-        if (tab === "agents") {
+        const tabs = `${tabLabel("Primary", tab === "primary")}  ${tabLabel("Subagent", tab === "subagent")}  ${tabLabel("Tasks", tab === "tasks")}  ${tabLabel("Settings", tab === "settings")}`;
+        if (tab === "primary" || tab === "subagent") {
+          const agents = tab === "primary" ? primaryAgents : subagents;
+          const selectedAgent = tab === "primary" ? selectedPrimaryAgent : selectedSubagent;
           const start = Math.max(0, Math.min(selectedAgent - 3, agents.length - 7));
           const shown2 = agents.slice(start, start + 7);
           const lines2 = [tabs, ""];
@@ -2055,13 +2049,14 @@ ${this.primaryAgent.prompt}` };
             const index = start + offset;
             const selected = index === selectedAgent;
             const cursor = selected ? theme.fg("accent", "›") : " ";
-            const active = agent2.name === this.primaryAgent?.name ? theme.fg("success", "●") : theme.fg("dim", "○");
+            const active = tab === "primary" && agent2.name === this.primaryAgent?.name ? theme.fg("success", "●") : theme.fg("dim", "○");
             const name = colorizeAgentText(agent2.color, `@${agent2.name}`, (color, text) => theme.fg(color, text));
             const metadata = theme.fg("dim", `${agent2.mode} · ${agent2.source} · ${agent2.model ?? "current model"}`);
             lines2.push(`${cursor} ${active} ${name} ${metadata}`);
           }
-          if (agents.length === 0)
-            lines2.push(theme.fg("muted", "  No agents configured."));
+          if (agents.length === 0) {
+            lines2.push(theme.fg("muted", `  No ${tab} agents configured.`));
+          }
           const agent = agents[selectedAgent];
           if (agent) {
             lines2.push("", theme.fg("text", agent.description ?? "No description"));
@@ -2094,28 +2089,38 @@ ${this.primaryAgent.prompt}` };
               lines2.push(`  ${theme.fg("error", diagnostic)}`);
             }
           }
-          for (const warning of catalog.warnings.slice(0, 2)) {
-            lines2.push(theme.fg("warning", warning));
-          }
-          const canActivate = agent !== undefined && agentSupportsMode(agent, "primary");
-          lines2.push("", theme.fg("dim", `↑↓ select${canActivate ? "  enter activate" : ""}  tab/→ sessions  esc close`));
+          const canActivate = tab === "primary" && agent !== undefined;
+          lines2.push("", theme.fg("dim", `↑↓ select${canActivate ? "  enter activate" : ""}  tab/→ next  esc close`));
           return box(lines2);
         }
         if (tab === "settings") {
-          const scopes = ["Global", "Project"];
+          const rows = [
+            {
+              label: "Maximum subagents (global)",
+              value: maxSubagentsSettings.global,
+              unavailable: false,
+              inherited: false
+            },
+            {
+              label: "Maximum subagents (local)",
+              value: maxSubagentsSettings.project ?? maxSubagentsSettings.global,
+              unavailable: !projectTrusted,
+              inherited: maxSubagentsSettings.project === undefined
+            }
+          ];
           const lines2 = [tabs, ""];
-          for (const [index, scope] of scopes.entries()) {
+          for (const [index, row] of rows.entries()) {
             const selected = index === selectedSetting;
-            const unavailable = scope === "Project" && !projectTrusted;
             const cursor = selected ? theme.fg("accent", "›") : " ";
-            const value = selected ? theme.fg("accent", `[ ${values[index]} ]`) : theme.fg("text", `[ ${values[index]} ]`);
-            const label = unavailable ? theme.fg("muted", `${scope} (project not trusted)`) : theme.fg("text", scope);
+            const text = row.inherited ? `[ inherited: ${row.value} ]` : `[ ${row.value} ]`;
+            const value = selected ? theme.fg("accent", text) : theme.fg(row.unavailable ? "muted" : "text", text);
+            const label = row.unavailable ? theme.fg("muted", `${row.label} (project not trusted)`) : theme.fg("text", row.label);
             lines2.push(`${cursor} ${value} ${label}`);
           }
-          if (values[selectedSetting] === 0) {
-            lines2.push(`    ${theme.fg("dim", "Task delegation is disabled for this scope")}`);
+          if (selectedMaxSubagents() === 0) {
+            lines2.push(`    ${theme.fg("dim", "Subagents disabled")}`);
           }
-          lines2.push("", theme.fg("dim", "↑↓ scope  0-9/+/- change  enter save  tab agents  esc close"));
+          lines2.push("", theme.fg("dim", saving ? "Saving…" : "↑↓ setting  0-9/+/- change  i use global  enter save  tab primary  esc close"));
           return box(lines2);
         }
         if (!detail) {
@@ -2170,26 +2175,36 @@ ${this.primaryAgent.prompt}` };
       },
       handleInput: (data) => {
         if (matchesKey(data, "tab")) {
-          const tabs = ["agents", "sessions", "settings"];
-          tab = tabs[(tabs.indexOf(tab) + 1) % tabs.length] ?? "agents";
+          const tabs = ["primary", "subagent", "tasks", "settings"];
+          tab = tabs[(tabs.indexOf(tab) + 1) % tabs.length] ?? "primary";
           detail = false;
           editing = false;
           scroll = 0;
           tui.requestRender();
           return;
         }
-        if (tab === "agents") {
+        if (tab === "primary" || tab === "subagent") {
+          const agents = tab === "primary" ? primaryAgents : subagents;
+          const selectedAgent = tab === "primary" ? selectedPrimaryAgent : selectedSubagent;
+          const setSelectedAgent = (index) => {
+            if (tab === "primary")
+              selectedPrimaryAgent = index;
+            else
+              selectedSubagent = index;
+          };
           if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c"))
             done();
           else if (matchesKey(data, "up"))
-            selectedAgent = Math.max(0, selectedAgent - 1);
+            setSelectedAgent(Math.max(0, selectedAgent - 1));
           else if (matchesKey(data, "down") && agents.length > 0) {
-            selectedAgent = Math.min(agents.length - 1, selectedAgent + 1);
+            setSelectedAgent(Math.min(agents.length - 1, selectedAgent + 1));
+          } else if (matchesKey(data, "left") && tab === "subagent") {
+            tab = "primary";
           } else if (matchesKey(data, "right")) {
-            tab = "sessions";
-          } else if (matchesKey(data, "return")) {
+            tab = tab === "primary" ? "subagent" : "tasks";
+          } else if (matchesKey(data, "return") && tab === "primary") {
             const agent = agents[selectedAgent];
-            if (!agent || !agentSupportsMode(agent, "primary"))
+            if (!agent)
               return;
             this.selectPrimaryAgent(agent.name, ctx).then(() => tui.requestRender()).catch((error) => ctx.ui.notify(`Could not select primary agent: ${formatError(error)}`, "error"));
           } else
@@ -2198,6 +2213,8 @@ ${this.primaryAgent.prompt}` };
           return;
         }
         if (tab === "settings") {
+          if (saving)
+            return;
           if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
             done();
             return;
@@ -2209,29 +2226,46 @@ ${this.primaryAgent.prompt}` };
             selectedSetting = Math.min(1, selectedSetting + 1);
             editing = false;
           } else if (/^[0-9]$/.test(data)) {
-            const value = Number(editing ? `${values[selectedSetting]}${data}` : data);
+            const value = Number(editing ? `${selectedMaxSubagents()}${data}` : data);
             if (value <= MAX_SUBAGENTS) {
-              values[selectedSetting] = value;
+              updateSelectedMaxSubagents(value);
               editing = true;
             }
           } else if (data === "+" || data === "-") {
-            values[selectedSetting] = Math.min(MAX_SUBAGENTS, Math.max(0, values[selectedSetting] + (data === "+" ? 1 : -1)));
+            updateSelectedMaxSubagents(Math.min(MAX_SUBAGENTS, Math.max(0, selectedMaxSubagents() + (data === "+" ? 1 : -1))));
+            editing = false;
+          } else if (data === "i" && selectedSetting === 1) {
+            maxSubagentsSettings = { ...maxSubagentsSettings, project: undefined };
+            dirtySettings.add(selectedSetting);
             editing = false;
           } else if (matchesKey(data, "return")) {
-            const scope = selectedSetting === 0 ? "global" : "project";
+            const setting = selectedSetting;
+            const scope = setting === 0 ? "global" : "project";
             if (scope === "project" && !projectTrusted) {
-              ctx.ui.notify("Project settings require a trusted project", "warning");
+              ctx.ui.notify("Local settings require a trusted project", "warning");
               return;
             }
-            const maxSubagents = values[selectedSetting];
-            setMaxSubagentsConfigForScope(ctx.cwd, maxSubagents, scope).then(() => {
-              const effective = loadLandstripConfig(ctx.cwd, projectTrusted).maxSubagents;
-              this.setMaxSubagents(effective);
-              values = [loadLandstripConfig(ctx.cwd, false).maxSubagents, effective];
+            if (!dirtySettings.has(setting))
+              return;
+            const pendingSettings = maxSubagentsSettings;
+            const inherited = scope === "project" && pendingSettings.project === undefined;
+            const maxSubagents = selectedMaxSubagents();
+            saving = true;
+            const save = inherited ? clearMaxSubagentsConfigForScope(ctx.cwd, scope) : setMaxSubagentsConfigForScope(ctx.cwd, maxSubagents, scope);
+            save.then(() => {
+              dirtySettings.delete(setting);
+              const loaded = loadMaxSubagentsSettings(ctx.cwd, projectTrusted);
+              this.setMaxSubagents(loaded.project ?? loaded.global);
+              maxSubagentsSettings = {
+                global: dirtySettings.has(0) ? pendingSettings.global : loaded.global,
+                project: dirtySettings.has(1) ? pendingSettings.project : loaded.project
+              };
               editing = false;
-              ctx.ui.notify(`Maximum concurrent tasks set to ${maxSubagents} in ${scope} config`, "info");
+              ctx.ui.notify(inherited ? "Maximum subagents (local) now uses the global value" : `Maximum subagents (${scope === "project" ? "local" : "global"}) set to ${maxSubagents}`, "info");
+            }).catch((error) => ctx.ui.notify(`Could not save setting: ${formatError(error)}`, "error")).finally(() => {
+              saving = false;
               tui.requestRender();
-            }).catch((error) => ctx.ui.notify(`Could not update config: ${formatError(error)}`, "error"));
+            });
             return;
           } else
             return;
@@ -2242,7 +2276,7 @@ ${this.primaryAgent.prompt}` };
           if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c"))
             done();
           else if (matchesKey(data, "left"))
-            tab = "agents";
+            tab = "subagent";
           else if (matchesKey(data, "right"))
             tab = "settings";
           else if (matchesKey(data, "up"))
@@ -2293,8 +2327,6 @@ ${this.primaryAgent.prompt}` };
   }
   async selectPrimaryAgent(name, ctx) {
     const catalog = this.getAgentCatalog(ctx);
-    for (const warning of catalog.warnings)
-      ctx.ui.notify(warning, "warning");
     for (const diagnostic of catalog.diagnostics)
       ctx.ui.notify(diagnostic, "warning");
     if (catalog.diagnostics.length > 0)
@@ -2316,8 +2348,6 @@ ${this.primaryAgent.prompt}` };
       return;
     }
     const catalog = this.getAgentCatalog(ctx);
-    for (const warning of catalog.warnings)
-      ctx.ui.notify(warning, "warning");
     for (const diagnostic of catalog.diagnostics)
       ctx.ui.notify(diagnostic, "warning");
     if (catalog.diagnostics.length > 0)
@@ -2428,8 +2458,6 @@ ${theme.fg("dim", `↳ /agents ${details.taskId.slice(0, 8)} to inspect`)}`;
     if (!input.prompt.trim())
       throw new Error("Task prompt cannot be empty");
     const catalog = this.loadCatalog(ctx.cwd, getAgentDir3(), isProjectTrusted(ctx));
-    for (const warning of catalog.warnings)
-      ctx.ui.notify(warning, "warning");
     for (const diagnostic of catalog.diagnostics)
       ctx.ui.notify(diagnostic, "warning");
     if (catalog.diagnostics.length > 0) {
@@ -2467,7 +2495,7 @@ ${catalog.diagnostics.join(`
       if (task.agent !== agent.name) {
         throw new Error(`Task ${task.id} belongs to agent ${task.agent}, not ${agent.name}`);
       }
-      if (!this.running.has(task.id) && (!task.sessionDir || !existsSync4(task.sessionDir)) && (!task.sessionFile || !existsSync4(task.sessionFile))) {
+      if (!this.running.has(task.id) && (!task.sessionDir || !existsSync3(task.sessionDir)) && (!task.sessionFile || !existsSync3(task.sessionFile))) {
         throw new Error(`Task ${task.id} session is unavailable`);
       }
     } else {
@@ -3128,8 +3156,6 @@ ${renderTaskResult(task.id, failed ? "error" : "completed", value)}`;
     this.primaryRules = undefined;
     this.primaryConfigurationError = false;
     const catalog = this.loadCatalog(ctx.cwd, getAgentDir3(), isProjectTrusted(ctx));
-    for (const warning of catalog.warnings)
-      ctx.ui.notify(warning, "warning");
     this.maxSubagents = catalog.maxSubagents;
     this.semaphore = new Semaphore(Math.max(1, this.maxSubagents));
     if (catalog.diagnostics.length > 0) {
@@ -3327,21 +3353,21 @@ var NETWORK_PERMISSION_OPTIONS = [
 function loadSandboxConfig(cwd, includeProject) {
   const projectConfigPath = join6(cwd, ".pi", "sandbox.json");
   const globalConfigPath = join6(getAgentDir4(), "sandbox.json");
-  if (!existsSync5(globalConfigPath)) {
+  if (!existsSync4(globalConfigPath)) {
     const templatePath = join6(packageDir2, "sandbox.json");
     mkdirSync3(dirname4(globalConfigPath), { recursive: true });
-    writeFileSync3(globalConfigPath, readFileSync6(templatePath, "utf-8"), "utf-8");
+    writeFileSync3(globalConfigPath, readFileSync5(templatePath, "utf-8"), "utf-8");
   }
-  let globalConfig = JSON.parse(readFileSync6(join6(packageDir2, "sandbox.json"), "utf-8"));
+  let globalConfig = JSON.parse(readFileSync5(join6(packageDir2, "sandbox.json"), "utf-8"));
   try {
-    const override = JSON.parse(readFileSync6(globalConfigPath, "utf-8"));
+    const override = JSON.parse(readFileSync5(globalConfigPath, "utf-8"));
     globalConfig = deepMerge(globalConfig, override);
   } catch (error) {
     console.error(`Warning: Could not parse ${globalConfigPath}: ${error}`);
   }
-  if (includeProject && existsSync5(projectConfigPath)) {
+  if (includeProject && existsSync4(projectConfigPath)) {
     try {
-      const projectConfig = JSON.parse(readFileSync6(projectConfigPath, "utf-8"));
+      const projectConfig = JSON.parse(readFileSync5(projectConfigPath, "utf-8"));
       return deepMerge(globalConfig, projectConfig);
     } catch (error) {
       console.error(`Warning: Could not parse ${projectConfigPath}: ${error}`);
@@ -3421,10 +3447,10 @@ function getConfigPaths(cwd) {
   return getPiConfigPaths(cwd, "sandbox.json");
 }
 function readOrEmptyConfig(configPath) {
-  if (!existsSync5(configPath))
+  if (!existsSync4(configPath))
     return {};
   try {
-    return JSON.parse(readFileSync6(configPath, "utf-8"));
+    return JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -3436,7 +3462,7 @@ function writeConfigFile(configPath, config) {
 }
 function getSandboxConfigWriteTarget(cwd, includeProject = true) {
   const { globalPath, projectPath } = getConfigPaths(cwd);
-  if (includeProject && existsSync5(projectPath)) {
+  if (includeProject && existsSync4(projectPath)) {
     return { scope: "project", path: projectPath };
   }
   return { scope: "global", path: globalPath };
@@ -3512,11 +3538,11 @@ function canonicalizePath(filePath, cwd) {
   } catch {
     const tail = [];
     let probe = abs;
-    while (!existsSync5(probe)) {
+    while (!existsSync4(probe)) {
       const parent = dirname4(probe);
       if (parent === probe)
         return abs;
-      tail.unshift(basename3(probe));
+      tail.unshift(basename2(probe));
       probe = parent;
     }
     try {
@@ -3987,7 +4013,7 @@ function createLandstripIntegration(options = {}) {
     if (!isAbsolute3(requestedEntry)) {
       throw new Error("Worker extension entry must be an absolute path or file URL");
     }
-    if (!existsSync5(requestedEntry)) {
+    if (!existsSync4(requestedEntry)) {
       throw new Error(`Worker extension entry does not exist: ${requestedEntry}`);
     }
     const entry = realpathSync2(requestedEntry);
@@ -4029,7 +4055,7 @@ function createLandstripIntegration(options = {}) {
     const paths = mergeAllowances(config.filesystem.allowRead, sessionAllowedReadPaths, allowances?.readPaths);
     if (process.platform !== "win32")
       return paths;
-    return paths.filter((path) => !path.startsWith("/") && (path.includes("*") || existsSync5(expandPath(path, cwd))));
+    return paths.filter((path) => !path.startsWith("/") && (path.includes("*") || existsSync4(expandPath(path, cwd))));
   }
   function getEffectiveAllowWrite(config, allowances) {
     const paths = mergeAllowances(config.filesystem.allowWrite, sessionAllowedWritePaths, allowances?.writePaths);
@@ -4564,7 +4590,7 @@ function createLandstripIntegration(options = {}) {
   function createLandstripBashOps(ctx, callbacks = {}, allowances = { domains: [], readPaths: [], writePaths: [], targets: [] }) {
     return {
       async exec(command, cwd, { onData, signal, timeout, env }) {
-        if (!existsSync5(cwd))
+        if (!existsSync4(cwd))
           throw new Error(`Working directory does not exist: ${cwd}`);
         const { shell, args } = getShellConfig(SettingsManager.create(cwd).getShellPath());
         const config = loadConfig(cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Sandbox-aware Pi subagents and interactive command permissions",
   "keywords": [
     "landstrip",
@@ -39,7 +39,7 @@
     "ci:test": "npm run test"
   },
   "dependencies": {
-    "@landstrip/landstrip": "^0.18.0",
+    "@landstrip/landstrip": "^0.18.2",
     "jsonc-parser": "^3.3.1",
     "minimatch": "^10.2.5",
     "yaml": "^2.9.0"