pi-landstrip 0.17.35 → 0.17.37

package/README.md

@@ -16,7 +16,7 @@ The extension includes a shared [sandbox policy](./sandbox.json) and separate
 [agent configuration](./subagents.json). Global and trusted-project files can
 override both.
 
-Process-backed subagents require Pi >= 0.80.6, and Node.js >= 22.19.0.
+Process-backed subagents require Pi >= 0.82.0, and Node.js >= 22.19.0.
 
 ## Installation
 
@@ -208,11 +208,44 @@ merged over the packaged [defaults](./subagents.json). The packaged subagent typ
 are `explore`, `general`, and the OpenCode-compatible `scout` reconnaissance agent.
 
 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.
+`settings.json` only needs the normal package entry for the extension:
 
-`subagents.json` accepts only top-level `maxSubagents` and `subagents`; sandbox
-fields belong in `sandbox.json`.
+```json
+{
+  "packages": ["npm:pi-landstrip"]
+}
+```
+
+Optional OpenCode import flags live in `subagents.json` as top-level `opencode`:
+
+```json
+{
+  "maxSubagents": 0,
+  "opencode": {
+    "showGlobalAgents": false,
+    "showLocalAgents": false
+  },
+  "subagents": {
+    "agent": {}
+  }
+}
+```
+
+Both flags default to `false`. When enabled:
+
+- `showGlobalAgents` imports Markdown agents from the OpenCode global config
+  directory (`$OPENCODE_CONFIG_DIR`, or `$XDG_CONFIG_HOME/opencode`, or
+  `~/.config/opencode`) under `agent/` and `agents/`.
+- `showLocalAgents` imports Markdown agents from the trusted project's
+  `.opencode/agent/` and `.opencode/agents/` directories.
+
+OpenCode local agents override OpenCode global agents. Pi agent definitions
+from `subagents.json` (built-in, global, and local) take precedence over OpenCode
+imports with the same name; conflicts are silent. Local OpenCode agents are
+skipped when the project is untrusted, regardless of the flag.
+
+`subagents.json` accepts top-level `maxSubagents`, `opencode`, and `subagents`;
+sandbox fields belong in `sandbox.json`.
 
 The Windows sandbox fields are:
 
@@ -306,6 +339,8 @@ follows, then remove the old fields:
 - Convert legacy `tools` booleans to explicit `permission` rules.
 - Move Markdown agent prompts into each `subagents.agent.<name>.prompt` string.
 - Put the worker limit in top-level `maxSubagents`; zero disables delegation.
+- Move `landstrip.opencode` flags from Pi `settings.json` to top-level
+  `opencode` in `subagents.json`.
 - Use `~/.pi/agent/subagents.json` for global configuration and
   `.pi/subagents.json` for trusted project configuration.
 - Leave sandbox policy in `~/.pi/agent/sandbox.json` and `.pi/sandbox.json`;

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 existsSync4,
+  existsSync as existsSync5,
   mkdirSync as mkdirSync3,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync as realpathSync2,
   rmSync as rmSync2,
   writeFileSync as writeFileSync3
@@ -18,8 +18,8 @@ import {
   isIP,
   Socket as NetSocket
 } from "node:net";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, parse, resolve as resolve2 } from "node:path";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "node:os";
+import { basename as basename3, dirname as dirname3, isAbsolute as isAbsolute2, join as join6, parse, resolve as resolve2 } from "node:path";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 import { fileURLToPath as fileURLToPath3, URL } from "node:url";
 import {
@@ -70,18 +70,18 @@ function encodeLandstripContext(context) {
 // subagents.ts
 import { randomUUID } from "node:crypto";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   lstatSync,
   mkdirSync as mkdirSync2,
   mkdtempSync,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   readlinkSync,
   realpathSync,
   rmSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { homedir as homedir2, tmpdir } from "node:os";
-import { basename, dirname as dirname2, isAbsolute, join as join4, relative, resolve, sep } from "node:path";
+import { homedir as homedir3, tmpdir } from "node:os";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join5, relative as relative2, resolve, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   getAgentDir as getAgentDir3,
@@ -92,8 +92,8 @@ import { matchesKey, Text, truncateToWidth as truncateToWidth2 } from "@earendil
 import { Type } from "typebox";
 
 // agents.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
 import { minimatch } from "minimatch";
 import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
 
@@ -160,6 +160,38 @@ class AsyncQueue {
 // config.ts
 var MAX_SUBAGENTS = 16;
 var packageDir = dirname(fileURLToPath(import.meta.url));
+var DEFAULT_OPENCODE = {
+  showGlobalAgents: false,
+  showLocalAgents: false
+};
+var OPENCODE_KEYS = new Set(["showGlobalAgents", "showLocalAgents"]);
+function readBooleanField(section, key, path) {
+  if (!(key in section))
+    return;
+  const value = section[key];
+  if (typeof value === "boolean")
+    return value;
+  throw new Error(`${path}.${key} must be a boolean`);
+}
+function normalizeOpenCode(value, path) {
+  if (value === undefined)
+    return {};
+  if (!isRecord2(value))
+    throw new Error(`${path} must be a JSON object`);
+  for (const key of Object.keys(value)) {
+    if (!OPENCODE_KEYS.has(key)) {
+      throw new Error(`${path}: unknown field ${key}`);
+    }
+  }
+  const result = {};
+  const showGlobalAgents = readBooleanField(value, "showGlobalAgents", path);
+  if (showGlobalAgents !== undefined)
+    result.showGlobalAgents = showGlobalAgents;
+  const showLocalAgents = readBooleanField(value, "showLocalAgents", path);
+  if (showLocalAgents !== undefined)
+    result.showLocalAgents = showLocalAgents;
+  return result;
+}
 function readConfig(path) {
   if (!existsSync(path))
     return {};
@@ -173,11 +205,27 @@ function readConfig(path) {
   if (!isRecord2(value))
     throw new Error(`${path} must contain a JSON object`);
   for (const key of Object.keys(value)) {
-    if (key !== "maxSubagents" && key !== "subagents") {
+    if (key !== "maxSubagents" && key !== "subagents" && key !== "opencode") {
       throw new Error(`${path}: unknown top-level field ${key}`);
     }
   }
-  return value;
+  const config = {};
+  if ("maxSubagents" in value) {
+    if (typeof value.maxSubagents !== "number") {
+      throw new Error(`${path}: maxSubagents must be a number`);
+    }
+    config.maxSubagents = value.maxSubagents;
+  }
+  if ("subagents" in value) {
+    if (!isRecord2(value.subagents)) {
+      throw new Error(`${path}: subagents must be an object`);
+    }
+    config.subagents = value.subagents;
+  }
+  if ("opencode" in value) {
+    config.opencode = normalizeOpenCode(value.opencode, `${path}: opencode`);
+  }
+  return config;
 }
 function mergeValue(base, override) {
   if (override === undefined)
@@ -239,7 +287,182 @@ function loadLandstripConfig(cwd, includeProject = true, agentDir = getAgentDir(
   }
   if (!isRecord2(config.subagents))
     throw new Error("subagents must be an object");
-  return { ...config, agentSources };
+  const opencode = {
+    ...DEFAULT_OPENCODE,
+    ...config.opencode
+  };
+  return { ...config, opencode, agentSources };
+}
+
+// opencode-agents.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, extname, join as join3, relative, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+var AGENT_DIR_PREFIXES = ["agent/", "agents/"];
+function openCodeGlobalConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR)
+    return process.env.OPENCODE_CONFIG_DIR;
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return join3(xdg && xdg.length > 0 ? xdg : join3(homedir2(), ".config"), "opencode");
+}
+function listMarkdownFiles(root) {
+  if (!existsSync2(root))
+    return [];
+  const results = [];
+  const visit = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const path = join3(dir, entry);
+      let stats;
+      try {
+        stats = statSync(path);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory())
+        visit(path);
+      else if (stats.isFile() && extname(entry).toLowerCase() === ".md")
+        results.push(path);
+    }
+  };
+  visit(root);
+  return results;
+}
+function agentNameFromPath(dir, filePath) {
+  const relativePath = relative(dir, filePath).split(sep).join("/");
+  for (const prefix of AGENT_DIR_PREFIXES) {
+    if (relativePath.startsWith(prefix)) {
+      const candidate = relativePath.slice(prefix.length);
+      const extension2 = extname(candidate);
+      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;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/);
+  if (!match)
+    return { data: {}, body: content };
+  const parsed = parseYaml(match[1] ?? "");
+  if (parsed === null || parsed === undefined)
+    return { data: {}, body: match[2] ?? "" };
+  if (!isRecord2(parsed))
+    throw new Error("frontmatter must be a YAML mapping");
+  return { data: { ...parsed }, body: match[2] ?? "" };
+}
+function convertToolsToPermission(tools) {
+  if (!isRecord2(tools))
+    throw new Error("tools must be a map of booleans");
+  const permission = {};
+  for (const [tool, enabled] of Object.entries(tools)) {
+    if (typeof enabled !== "boolean") {
+      throw new Error(`tools.${tool} must be a boolean`);
+    }
+    const action = enabled ? "allow" : "deny";
+    if (tool === "write" || tool === "edit" || tool === "patch") {
+      permission.edit = action;
+      continue;
+    }
+    permission[tool] = action;
+  }
+  return permission;
+}
+function normalizeOpenCodeAgentRaw(data, prompt) {
+  const known = new Set([
+    "name",
+    "model",
+    "variant",
+    "prompt",
+    "description",
+    "temperature",
+    "top_p",
+    "mode",
+    "hidden",
+    "color",
+    "steps",
+    "maxSteps",
+    "options",
+    "permission",
+    "disable",
+    "tools"
+  ]);
+  const options = isRecord2(data.options) ? { ...data.options } : {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!known.has(key))
+      options[key] = value;
+  }
+  let permission = {};
+  if (data.tools !== undefined) {
+    permission = convertToolsToPermission(data.tools);
+  }
+  if (data.permission !== undefined) {
+    if (!isRecord2(data.permission))
+      throw new Error("permission must be an object");
+    permission = { ...permission, ...data.permission };
+  }
+  const steps = data.steps ?? data.maxSteps;
+  const raw = {
+    description: data.description,
+    prompt,
+    mode: data.mode,
+    model: data.model,
+    variant: data.variant,
+    hidden: data.hidden,
+    disable: data.disable,
+    color: data.color,
+    temperature: data.temperature,
+    top_p: data.top_p
+  };
+  if (steps !== undefined)
+    raw.steps = steps;
+  if (Object.keys(permission).length > 0)
+    raw.permission = permission;
+  if (Object.keys(options).length > 0)
+    raw.options = options;
+  for (const key of Object.keys(raw)) {
+    if (raw[key] === undefined)
+      delete raw[key];
+  }
+  return raw;
+}
+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 = readFileSync2(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 loadOpenCodeAgents(options) {
+  const agents = new Map;
+  const diagnostics = [];
+  if (options.includeGlobal) {
+    loadAgentsFromDir(options.globalConfigDir ?? openCodeGlobalConfigDir(), "global", agents, diagnostics);
+  }
+  if (options.includeProject) {
+    loadAgentsFromDir(join3(options.cwd, ".opencode"), "local", agents, diagnostics);
+  }
+  return { agents, diagnostics };
 }
 
 // agents.ts
@@ -290,14 +513,14 @@ function normalizePermissions(value) {
   return Object.entries(value).flatMap(([permission, rules]) => permissionEntries(permission, rules));
 }
 function legacyConfigWarnings(piAgentDir) {
-  const path = join3(piAgentDir, "settings.json");
-  if (!existsSync2(path))
+  const path = join4(piAgentDir, "settings.json");
+  if (!existsSync3(path))
     return [];
   try {
-    const value = JSON.parse(readFileSync2(path, "utf8"));
+    const value = JSON.parse(readFileSync3(path, "utf8"));
     if (!isRecord2(value))
       return [];
-    const fields = ["agent", "permission", "subagents", "maxSubagents"].filter((field) => value[field] !== undefined);
+    const fields = ["agent", "permission", "subagents", "maxSubagents", "landstrip"].filter((field) => value[field] !== undefined);
     if (fields.length === 0)
       return [];
     return [
@@ -360,21 +583,40 @@ function normalizeAgent(name, raw, source) {
 function loadAgentCatalog(cwd, piAgentDir = getAgentDir2(), includeProject = true) {
   const warnings = [
     ...legacyConfigWarnings(piAgentDir),
-    ...includeProject ? legacyConfigWarnings(join3(cwd, ".pi")) : []
+    ...includeProject ? legacyConfigWarnings(join4(cwd, ".pi")) : []
   ];
   const diagnostics = [];
   let maxSubagents = 0;
   let subagents = {};
   let agentSources = new Map;
+  let showGlobalAgents = false;
+  let showLocalAgents = false;
   try {
     const config = loadLandstripConfig(cwd, includeProject, piAgentDir);
     maxSubagents = config.maxSubagents;
     subagents = config.subagents;
     agentSources = new Map(config.agentSources);
+    showGlobalAgents = config.opencode.showGlobalAgents;
+    showLocalAgents = config.opencode.showLocalAgents;
   } catch (error) {
     diagnostics.push(formatError(error));
   }
+  const openCode = loadOpenCodeAgents({
+    cwd,
+    includeGlobal: showGlobalAgents,
+    includeProject: showLocalAgents && includeProject
+  });
+  diagnostics.push(...openCode.diagnostics);
   const normalized = new Map;
+  for (const imported of openCode.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)}`);
+    }
+  }
   if (subagents.agent !== undefined && !isRecord2(subagents.agent)) {
     diagnostics.push("subagents.agent must be an object");
   } else if (isRecord2(subagents.agent)) {
@@ -388,6 +630,8 @@ function loadAgentCatalog(cwd, piAgentDir = getAgentDir2(), includeProject = tru
         const agent = normalizeAgent(name, value, agentSources.get(name) ?? "built-in");
         if (agent)
           normalized.set(name, agent);
+        else
+          normalized.delete(name);
       } catch (error) {
         diagnostics.push(formatError(error));
       }
@@ -878,14 +1122,22 @@ var MAX_DEPTH = 3;
 var packageDir2 = dirname2(fileURLToPath2(import.meta.url));
 var MAX_TASK_OUTPUT_BYTES = 64 * 1024;
 var INSPECTOR_BODY_LINES = 16;
-var SUPPORTED_PI_MAJOR = 0;
-var MIN_SUPPORTED_PI_MINOR = 80;
-var MIN_SUPPORTED_PI_PATCH = 6;
+var MIN_SUPPORTED_PI_VERSION = [0, 82, 0];
 var cachedPiPackage;
 var piPackageResolved = false;
 function isSupportedPiVersion(version) {
-  const [major, minor = -1, patch = -1] = version;
-  return version.length === 3 && Number.isInteger(major) && Number.isInteger(minor) && Number.isInteger(patch) && major === SUPPORTED_PI_MAJOR && (minor > MIN_SUPPORTED_PI_MINOR || minor === MIN_SUPPORTED_PI_MINOR && patch >= MIN_SUPPORTED_PI_PATCH);
+  if (version.length !== 3 || !version.every((part) => Number.isInteger(part) && part >= 0)) {
+    return false;
+  }
+  for (let i = 0;i < 3; i++) {
+    const part = version[i];
+    const min = MIN_SUPPORTED_PI_VERSION[i];
+    if (part > min)
+      return true;
+    if (part < min)
+      return false;
+  }
+  return true;
 }
 function resolvePiPackage() {
   if (piPackageResolved)
@@ -895,8 +1147,8 @@ function resolvePiPackage() {
     const entry = fileURLToPath2(import.meta.resolve("@earendil-works/pi-coding-agent"));
     let dir2 = dirname2(entry);
     for (;; ) {
-      const pkgPath = join4(dir2, "package.json");
-      if (existsSync3(pkgPath)) {
+      const pkgPath = join5(dir2, "package.json");
+      if (existsSync4(pkgPath)) {
         const pkg = readPiPackage(pkgPath);
         if (pkg)
           return pkg;
@@ -909,8 +1161,8 @@ function resolvePiPackage() {
   } catch {}
   let dir = packageDir2;
   for (;; ) {
-    const pkgPath = join4(dir, "node_modules", "@earendil-works", "pi-coding-agent", "package.json");
-    if (existsSync3(pkgPath)) {
+    const pkgPath = join5(dir, "node_modules", "@earendil-works", "pi-coding-agent", "package.json");
+    if (existsSync4(pkgPath)) {
       const pkg = readPiPackage(pkgPath);
       if (pkg)
         return pkg;
@@ -923,7 +1175,7 @@ function resolvePiPackage() {
 }
 function readPiPackage(pkgPath) {
   try {
-    const value = JSON.parse(readFileSync3(pkgPath, "utf8"));
+    const value = JSON.parse(readFileSync4(pkgPath, "utf8"));
     if (!isRecord2(value) || value.name !== "@earendil-works/pi-coding-agent" || typeof value.version !== "string") {
       return;
     }
@@ -933,8 +1185,8 @@ function readPiPackage(pkgPath) {
     const binFile = typeof value.bin === "string" ? value.bin : isRecord2(value.bin) && typeof value.bin.pi === "string" ? value.bin.pi : undefined;
     if (!binFile)
       return;
-    const cliEntry = join4(dirname2(pkgPath), binFile);
-    if (!existsSync3(cliEntry))
+    const cliEntry = join5(dirname2(pkgPath), binFile);
+    if (!existsSync4(cliEntry))
       return;
     cachedPiPackage = { cliEntry, version: parts.slice(0, 3) };
     return cachedPiPackage;
@@ -1008,7 +1260,7 @@ function messageContentText(message) {
 `);
 }
 function taskTranscript(task) {
-  if (!task.sessionFile || !existsSync3(task.sessionFile)) {
+  if (!task.sessionFile || !existsSync4(task.sessionFile)) {
     const fallback = task.error ?? task.output ?? "Child session is not available yet.";
     return fallback.split(`
 `);
@@ -1038,7 +1290,7 @@ function isProjectTrusted(ctx) {
   return trustContext.isProjectTrusted?.() ?? false;
 }
 function dependencyRoot(path) {
-  const marker = `${sep}node_modules${sep}`;
+  const marker = `${sep2}node_modules${sep2}`;
   const index = path.lastIndexOf(marker);
   return index < 0 ? undefined : path.slice(0, index + marker.length - 1);
 }
@@ -1059,7 +1311,7 @@ function agentBootstrapPaths(agentDir) {
     "bin",
     "npm",
     "git"
-  ].map((path) => join4(agentDir, path));
+  ].map((path) => join5(agentDir, path));
 }
 
 class Semaphore {
@@ -1253,7 +1505,7 @@ function canonicalPermissionPath(path, seen = new Set) {
       const parent = dirname2(existing);
       if (parent === existing)
         return path;
-      missing.unshift(basename(existing));
+      missing.unshift(basename2(existing));
       existing = parent;
     }
   }
@@ -1275,11 +1527,11 @@ function permissionResource(tool, input, cwd) {
     return "*";
   const projectRoot = canonicalPermissionPath(resolve(cwd));
   const absolutePath = canonicalPermissionPath(resolve(cwd, input.path));
-  const projectPath = relative(projectRoot, absolutePath);
-  if (projectPath && !isAbsolute(projectPath) && !projectPath.startsWith(`..${sep}`) && projectPath !== "..") {
-    return projectPath.split(sep).join("/");
+  const projectPath = relative2(projectRoot, absolutePath);
+  if (projectPath && !isAbsolute(projectPath) && !projectPath.startsWith(`..${sep2}`) && projectPath !== "..") {
+    return projectPath.split(sep2).join("/");
   }
-  return absolutePath.split(sep).join("/");
+  return absolutePath.split(sep2).join("/");
 }
 function permissionResources(tool, input, cwd) {
   if (tool !== "apply_patch" || typeof input.patchText !== "string") {
@@ -1811,7 +2063,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 || !existsSync3(task.sessionDir)) && (!task.sessionFile || !existsSync3(task.sessionFile))) {
+      if (!this.running.has(task.id) && (!task.sessionDir || !existsSync4(task.sessionDir)) && (!task.sessionFile || !existsSync4(task.sessionFile))) {
         throw new Error(`Task ${task.id} session is unavailable`);
       }
     } else {
@@ -1921,7 +2173,7 @@ ${catalog.diagnostics.join(`
   createRecord(input, ctx, parentTask, agent, depth) {
     const parentSession = parentTask?.sessionFile ?? ctx.sessionManager.getSessionFile();
     const id = randomUUID();
-    const sessionDir = join4(getAgentDir3(), "sessions", "pi-landstrip", ctx.sessionManager.getSessionId(), id);
+    const sessionDir = join5(getAgentDir3(), "sessions", "pi-landstrip", ctx.sessionManager.getSessionId(), id);
     mkdirSync2(sessionDir, { recursive: true });
     const task = {
       version: 1,
@@ -2111,7 +2363,7 @@ ${catalog.diagnostics.join(`
       "--mode",
       "rpc",
       "--extension",
-      join4(packageDir2, "index.ts"),
+      join5(packageDir2, "index.ts"),
       ...workerExtensions.flatMap((extension) => ["--extension", extension.entry]),
       ...task.sessionFile ? ["--session", task.sessionFile] : task.sessionDir ? ["--session-dir", task.sessionDir] : [],
       "--model",
@@ -2126,7 +2378,7 @@ ${catalog.diagnostics.join(`
     ];
     const config = { rules, task, taskEnabled, steps: agent.steps };
     const publicContext = this.taskContext(task, ctx);
-    const temp = mkdtempSync(join4(tmpdir(), `pi-landstrip-task-${task.id}-`));
+    const temp = mkdtempSync(join5(tmpdir(), `pi-landstrip-task-${task.id}-`));
     const agentDir = getAgentDir3();
     let launch;
     let rpc;
@@ -2158,9 +2410,9 @@ ${catalog.diagnostics.join(`
           ...new Set([
             ctx.cwd,
             ...agentBootstrapPaths(agentDir),
-            join4(homedir2(), ".agents", "skills"),
+            join5(homedir3(), ".agents", "skills"),
             packageDir2,
-            join4(packageDir2, "node_modules"),
+            join5(packageDir2, "node_modules"),
             invocation.command,
             cliRoot,
             extensionRoot,
@@ -2258,7 +2510,7 @@ ${catalog.diagnostics.join(`
       throw new Error("Unable to resolve the running Pi package; process-backed subagents are unavailable");
     }
     if (!isSupportedPiVersion(pkg.version)) {
-      throw new Error(`Process-backed subagents require Pi >=0.80.6; found ${pkg.version.join(".")}`);
+      throw new Error(`Process-backed subagents require Pi >=0.82.0; found ${pkg.version.join(".")}`);
     }
   }
   async handleWorkerRequest(task, rules, ctx, request) {
@@ -2382,7 +2634,7 @@ ${renderTaskResult(task.id, "error", message)}`);
     if (!directory)
       throw new Error(`Task ${task.id} has no artifact directory`);
     mkdirSync2(directory, { recursive: true });
-    const artifactPath = join4(directory, `${kind}.txt`);
+    const artifactPath = join5(directory, `${kind}.txt`);
     const bounded = boundTaskOutput(value, artifactPath);
     if (kind === "output")
       task.outputFile = artifactPath;
@@ -2628,23 +2880,23 @@ var NETWORK_PERMISSION_OPTIONS = [
   { label: "Abort (keep blocked)", key: "esc", action: "abort" }
 ];
 function loadSandboxConfig(cwd, includeProject) {
-  const projectConfigPath = join5(cwd, ".pi", "sandbox.json");
-  const globalConfigPath = join5(getAgentDir4(), "sandbox.json");
-  if (!existsSync4(globalConfigPath)) {
-    const templatePath = join5(packageDir3, "sandbox.json");
+  const projectConfigPath = join6(cwd, ".pi", "sandbox.json");
+  const globalConfigPath = join6(getAgentDir4(), "sandbox.json");
+  if (!existsSync5(globalConfigPath)) {
+    const templatePath = join6(packageDir3, "sandbox.json");
     mkdirSync3(dirname3(globalConfigPath), { recursive: true });
-    writeFileSync3(globalConfigPath, readFileSync4(templatePath, "utf-8"), "utf-8");
+    writeFileSync3(globalConfigPath, readFileSync5(templatePath, "utf-8"), "utf-8");
   }
-  let globalConfig = JSON.parse(readFileSync4(join5(packageDir3, "sandbox.json"), "utf-8"));
+  let globalConfig = JSON.parse(readFileSync5(join6(packageDir3, "sandbox.json"), "utf-8"));
   try {
-    const override = JSON.parse(readFileSync4(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 && existsSync4(projectConfigPath)) {
+  if (includeProject && existsSync5(projectConfigPath)) {
     try {
-      const projectConfig = JSON.parse(readFileSync4(projectConfigPath, "utf-8"));
+      const projectConfig = JSON.parse(readFileSync5(projectConfigPath, "utf-8"));
       const merged = deepMerge(globalConfig, projectConfig);
       merged.windows.backend = globalConfig.windows.backend;
       return merged;
@@ -2719,10 +2971,10 @@ function getConfigPaths(cwd) {
   return getPiConfigPaths(cwd, "sandbox.json");
 }
 function readOrEmptyConfig(configPath) {
-  if (!existsSync4(configPath))
+  if (!existsSync5(configPath))
     return {};
   try {
-    return JSON.parse(readFileSync4(configPath, "utf-8"));
+    return JSON.parse(readFileSync5(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -2734,7 +2986,7 @@ function writeConfigFile(configPath, config) {
 }
 function getSandboxConfigWriteTarget(cwd, includeProject = true) {
   const { globalPath, projectPath } = getConfigPaths(cwd);
-  if (includeProject && existsSync4(projectPath)) {
+  if (includeProject && existsSync5(projectPath)) {
     return { scope: "project", path: projectPath };
   }
   return { scope: "global", path: globalPath };
@@ -2810,11 +3062,11 @@ function canonicalizePath(filePath, cwd) {
   } catch {
     const tail = [];
     let probe = abs;
-    while (!existsSync4(probe)) {
+    while (!existsSync5(probe)) {
       const parent = dirname3(probe);
       if (parent === probe)
         return abs;
-      tail.unshift(basename2(probe));
+      tail.unshift(basename3(probe));
       probe = parent;
     }
     try {
@@ -2835,26 +3087,26 @@ function matchesPattern(filePath, patterns, cwd) {
       const escaped = absPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\/|\*\*|\*/g, (token) => token === "**/" ? "(?:.*/)?" : token === "**" ? ".*" : "[^/]*");
       return new RegExp(`^${escaped}$`).test(abs);
     }
-    const sep2 = absPattern.endsWith("/") ? "" : "/";
-    return abs === absPattern || abs.startsWith(absPattern + sep2);
+    const sep3 = absPattern.endsWith("/") ? "" : "/";
+    return abs === absPattern || abs.startsWith(absPattern + sep3);
   });
 }
 function normalizeBlockedPath(path, cwd) {
   const nativePath = process.platform === "win32" && /^\/[a-zA-Z](?:\/|$)/.test(path) ? `${path[1]}:${path.slice(2)}` : path;
-  return canonicalizePath(isAbsolute2(nativePath) ? nativePath : join5(cwd, nativePath), cwd);
+  return canonicalizePath(isAbsolute2(nativePath) ? nativePath : join6(cwd, nativePath), cwd);
 }
 function pathUnderDirectory(filePath, dir) {
   const normalizedFilePath = normalizePathSeparators(filePath);
   const normalizedDir = normalizePathSeparators(dir);
   if (normalizedFilePath === normalizedDir)
     return true;
-  const sep2 = normalizedDir.endsWith("/") ? "" : "/";
-  return normalizedFilePath.startsWith(normalizedDir + sep2);
+  const sep3 = normalizedDir.endsWith("/") ? "" : "/";
+  return normalizedFilePath.startsWith(normalizedDir + sep3);
 }
 function sessionScopeFor(filePath, baseDirectory) {
   const dir = dirname3(filePath);
   const normalizedDir = normalizePathSeparators(dir);
-  const home = homedir3();
+  const home = homedir4();
   const boundaries = new Set;
   if (home)
     boundaries.add(home);
@@ -2870,7 +3122,7 @@ function sessionScopeFor(filePath, baseDirectory) {
       const first = rest.split("/")[0];
       if (!first)
         return filePath;
-      return join5(boundary, first);
+      return join6(boundary, first);
     }
   }
   if (pathUnderDirectory(dir, baseDirectory))
@@ -3143,8 +3395,8 @@ function writeEnvFile(env, proxyPort, proxyToken) {
     lines.push("export NO_PROXY=''");
     lines.push("export no_proxy=''");
   }
-  const dir = mkdtempSync2(join5(tmpdir2(), "pi-landstrip-env-"));
-  const path = join5(dir, "env.sh");
+  const dir = mkdtempSync2(join6(tmpdir2(), "pi-landstrip-env-"));
+  const path = join6(dir, "env.sh");
   writeFileSync3(path, lines.join(`
 `), "utf-8");
   return { dir, path };
@@ -3285,7 +3537,7 @@ function createLandstripIntegration(options = {}) {
     if (!isAbsolute2(requestedEntry)) {
       throw new Error("Worker extension entry must be an absolute path or file URL");
     }
-    if (!existsSync4(requestedEntry)) {
+    if (!existsSync5(requestedEntry)) {
       throw new Error(`Worker extension entry does not exist: ${requestedEntry}`);
     }
     const entry = realpathSync2(requestedEntry);
@@ -3327,7 +3579,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("*") || existsSync4(expandPath(path, cwd))));
+    return paths.filter((path) => !path.startsWith("/") && (path.includes("*") || existsSync5(expandPath(path, cwd))));
   }
   function getEffectiveAllowWrite(config, allowances) {
     const paths = mergeAllowances(config.filesystem.allowWrite, sessionAllowedWritePaths, allowances?.writePaths);
@@ -3433,8 +3685,8 @@ function createLandstripIntegration(options = {}) {
     };
   }
   function writePolicyFile(cwd, proxyPort, allowances) {
-    const dir = mkdtempSync2(join5(tmpdir2(), "pi-landstrip-"));
-    const path = join5(dir, "policy.json");
+    const dir = mkdtempSync2(join6(tmpdir2(), "pi-landstrip-"));
+    const path = join6(dir, "policy.json");
     writeFileSync3(path, JSON.stringify(buildLandstripPolicy(cwd, proxyPort, allowances), null, 2) + `
 `, "utf-8");
     return { dir, path };
@@ -3861,7 +4113,7 @@ function createLandstripIntegration(options = {}) {
   function createLandstripBashOps(ctx, callbacks = {}, allowances = { domains: [], readPaths: [], writePaths: [], targets: [] }) {
     return {
       async exec(command, cwd, { onData, signal, timeout, env }) {
-        if (!existsSync4(cwd))
+        if (!existsSync5(cwd))
           throw new Error(`Working directory does not exist: ${cwd}`);
         const { shell, args } = getShellConfig(SettingsManager.create(cwd).getShellPath());
         const config = loadConfig(cwd);
@@ -4225,7 +4477,7 @@ ${message}
       networkLabel = `${config.network.allowedDomains.length} domains`;
       networkColor = "accent";
     }
-    const sep2 = theme.fg("dim", "·");
+    const sep3 = theme.fg("dim", "·");
     const net = theme.fg(networkColor, networkLabel);
     const write = theme.fg("accent", `${config.filesystem.allowWrite.length} write paths`);
     const fields = [`${dot} ${label}`, net, write];
@@ -4235,7 +4487,7 @@ ${message}
       const label2 = backend === "restrictedUser" ? "restricted user" : `${config.windows.appContainerMode} AppContainer`;
       fields.splice(1, 0, theme.fg(standard ? "warning" : "accent", label2));
     }
-    setTuiStatus(ctx, "sandbox", fields.join(`  ${sep2}  `));
+    setTuiStatus(ctx, "sandbox", fields.join(`  ${sep3}  `));
   }
   const headlessWarnings = new Set;
   function warnUnsandboxed(ctx, message, level) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.17.35",
+  "version": "0.17.37",
   "description": "Sandbox-aware Pi subagents and interactive command permissions",
   "keywords": [
     "landstrip",
@@ -40,14 +40,15 @@
     "ci:test": "npm run test"
   },
   "dependencies": {
-    "@landstrip/landstrip": "^0.17.35",
-    "minimatch": "^10.2.5"
+    "@landstrip/landstrip": "^0.17.37",
+    "minimatch": "^10.2.5",
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.81.1",
+    "@earendil-works/pi-coding-agent": "^0.82.0",
     "@earendil-works/pi-tui": "^0.81.1",
     "@types/node": "^24.0.0",
-    "oxfmt": "^0.59.0",
+    "oxfmt": "^0.60.0",
     "oxlint": "^1.68.0",
     "typebox": "^1.3.6",
     "typescript": "^5.0.0",