pi-landstrip 0.19.18 → 0.19.20

package/README.md

@@ -32,9 +32,11 @@ and platform limits, including Windows read grants and hard-denial restrictions.
 
 Worker boundaries:
 
-- Bootstrap grants override bundled `denyRead`, never global/trusted-project
-  denies. Denied startup resources prevent launch. Legacy `/home` or `/Users`
-  denies are explicit overrides; remove them only if unintended.
+- Workers can read their startup files despite the bundled `denyRead` defaults.
+  If your own sandbox settings block a needed path with `denyRead`, Pi asks for
+  approval before starting the worker. Declining prevents startup. Existing
+  `allowRead` grants and session approvals are reused. `denyReadAlways` blocks
+  startup without asking.
 - Hard read denials also apply to shell host reads. Private workers protect
   parent auth-file/lock roots with `denyReadAlways` and `denyWrite`;
   private worker authentication is unsupported on Windows.

package/dist/index.ts

@@ -17,6 +17,7 @@ import { StringDecoder as StringDecoder3 } from "node:string_decoder";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import {
   createBashToolDefinition,
+  createLocalBashOperations,
   getAgentDir as getAgentDir5,
   getShellConfig,
   SettingsManager as SettingsManager2,
@@ -228,16 +229,19 @@ function serveWorkerAuth(pipe, resolve) {
 // subagents.ts
 import { randomUUID } from "node:crypto";
 import {
+  closeSync,
   existsSync as existsSync5,
   lstatSync,
   mkdirSync as mkdirSync3,
   mkdtempSync,
+  openSync,
   readFileSync as readFileSync6,
   readdirSync as readdirSync2,
   readlinkSync,
   realpathSync as realpathSync2,
   rmSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync3,
+  writeSync
 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
 import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute3, join as join7, relative as relative3, resolve as resolve3, sep as sep4 } from "node:path";
@@ -1457,12 +1461,15 @@ function parseArgv(args) {
   };
 }
 function taskItems(tasks, prefix) {
-  return tasks.map((task) => ({
-    value: `${prefix}${task.id}`,
-    label: task.id.slice(0, 8),
-    description: `@${task.agent} [${task.state}]`,
-    search: task.id
-  }));
+  return tasks.map((task) => {
+    const label = task.kind === "command" || task.agent === "bash" ? "$ bash" : `@${task.agent}`;
+    return {
+      value: `${prefix}${task.id}`,
+      label: task.id.slice(0, 8),
+      description: `${label} [${task.state}]`,
+      search: task.id
+    };
+  });
 }
 function matchingTasksById(tasks, taskId) {
   const exact = tasks.find((task) => task.id === taskId);
@@ -1580,22 +1587,46 @@ Scope: ${scope} configuration`);
   {
     name: "tasks",
     summary: "Inspect and manage running task sessions",
-    pane: (argv) => argv.words[0] === "kill" || argv.words[0] === "list" ? undefined : "tasks",
+    pane: (argv) => {
+      const first = argv.words[0]?.toLowerCase() ?? "";
+      if (["cancel", "delete", "kill"].includes(first))
+        return;
+      if (first === "inspect" && argv.words[1])
+        return argv.words[1];
+      if (first && first !== "list")
+        return first;
+      return "tasks";
+    },
     complete: (argv, { runtime }) => {
       const tasks = runtime?.getTasks() ?? [];
-      if (argv.words[0]?.toLowerCase() === "kill")
-        return taskItems(tasks, "tasks kill ");
+      const action = argv.words[0]?.toLowerCase();
+      if (action === "cancel" || action === "kill")
+        return taskItems(tasks, `tasks ${action} `);
+      if (action === "delete")
+        return taskItems(tasks, "tasks delete ");
+      if (action === "inspect")
+        return taskItems(tasks, "tasks inspect ");
       return [
-        { value: "tasks list", label: "list", description: "List all task sessions" },
-        { value: "tasks kill", label: "kill", description: "Kill a task session by ID" },
+        { value: "tasks cancel", label: "cancel", description: "Cancel an active task session" },
+        { value: "tasks delete", label: "delete", description: "Delete a task session by ID" },
+        { value: "tasks inspect", label: "inspect", description: "Inspect a task session in TUI" },
         ...taskItems(tasks, "tasks ")
       ];
     },
-    run: (argv, { ctx, runtime }) => {
-      const [action = "", taskId = ""] = argv.words;
-      if (action === "kill") {
+    run: async (argv, { ctx, runtime }) => {
+      const [rawAction = "", rawTaskId = ""] = argv.words;
+      let action = rawAction.toLowerCase();
+      let taskId = rawTaskId;
+      if (!["cancel", "delete", "kill", "inspect", "list"].includes(action) && action) {
+        const matched = matchingTasksById(runtime.getTasks(), action);
+        if (matched.length > 0) {
+          action = "inspect";
+          taskId = matched[0].id;
+        }
+      }
+      if (action === "cancel" || action === "kill") {
         if (!taskId) {
-          ctx.ui.notify("Task ID required to kill a task", "error");
+          ctx.ui.notify("Task ID required to cancel a task", "error");
           return;
         }
         const matched = matchingTasksById(runtime.getTasks(), taskId);
@@ -1607,17 +1638,36 @@ Scope: ${scope} configuration`);
           ctx.ui.notify(`Task ID prefix ${taskId} matches ${matched.length} tasks`, "error");
           return;
         }
-        const deleted = runtime.deleteTasks([matched[0].id], ctx);
-        ctx.ui.notify(`Killed ${deleted} task${deleted === 1 ? "" : "s"}`, "info");
+        const cancelled = await runtime.cancelTasks([matched[0].id], ctx);
+        ctx.ui.notify(`Cancelled ${cancelled} task${cancelled === 1 ? "" : "s"}`, "info");
         return;
       }
-      const tasks = runtime.getTasks();
-      if (tasks.length === 0) {
-        ctx.ui.notify("No task sessions", "info");
+      if (action === "delete") {
+        if (!taskId) {
+          ctx.ui.notify("Task ID required to delete a task", "error");
+          return;
+        }
+        const matched = matchingTasksById(runtime.getTasks(), taskId);
+        if (matched.length === 0) {
+          ctx.ui.notify(`No task found matching ${taskId}`, "error");
+          return;
+        }
+        if (matched.length > 1) {
+          ctx.ui.notify(`Task ID prefix ${taskId} matches ${matched.length} tasks`, "error");
+          return;
+        }
+        const deleted = runtime.deleteTasks([matched[0].id], ctx);
+        ctx.ui.notify(`Deleted ${deleted} task${deleted === 1 ? "" : "s"}`, "info");
         return;
       }
-      ctx.ui.notify(tasks.map((task) => `${task.id.slice(0, 8)}: @${task.agent} [${task.state}]`).join(`
-`), "info");
+      if (action === "inspect" && taskId) {
+        const matched = matchingTasksById(runtime.getTasks(), taskId);
+        if (matched.length === 1) {
+          await runtime.openLandstrip(matched[0].id, ctx);
+          return;
+        }
+      }
+      await runtime.openLandstrip("tasks", ctx);
     }
   },
   {
@@ -2485,6 +2535,7 @@ var AGENTS_HELP_ROWS = [
   ["Esc", "Back one level, or close from a top-level tab"],
   ["Ctrl+C", "Close"],
   ["Space", "Toggle agent enabled or select task"],
+  ["C", "Cancel running task or execution"],
   ["X", "Delete selected agent or task sessions"],
   ["E", "Edit project agent"],
   ["I", "Inherit global agent state"],
@@ -2596,6 +2647,14 @@ var taskParameters = Type.Object({
   command: Type.Optional(Type.String({ description: "Originating command, if any" })),
   background: Type.Optional(Type.Boolean({ description: "Return immediately and run in background" }))
 });
+var TasksToolSchema = Type.Object({
+  action: Type.Union([Type.Literal("list"), Type.Literal("inspect"), Type.Literal("cancel")], {
+    description: 'Task management action: "list" to view task sessions, "inspect" for status/output, or "cancel" to stop an active task'
+  }),
+  task_id: Type.Optional(Type.String({
+    description: 'Task ID or unique prefix (required for "inspect" and "cancel")'
+  }))
+});
 var TASK_STATES = new Set([
   "queued",
   "running",
@@ -2609,6 +2668,8 @@ function taskDetails(task, state = task.state) {
     taskId: task.id,
     state,
     agent: task.agent,
+    kind: task.kind ?? "subagent",
+    command: task.command,
     description: task.description,
     background: task.background,
     currentTool: task.currentTool,
@@ -2618,7 +2679,12 @@ function taskDetails(task, state = task.state) {
     startedAt: task.startedAt,
     finishedAt: task.finishedAt,
     output: task.output,
-    error: task.error
+    error: task.error,
+    outputFile: task.outputFile,
+    errorFile: task.errorFile,
+    exitCode: task.exitCode,
+    parentTaskId: task.parentTaskId,
+    depth: task.depth
   };
 }
 function taskDuration(details) {
@@ -2808,6 +2874,12 @@ function taskProgress(task) {
   if (task.state !== "running")
     return [];
   const progress = [];
+  if (task.kind === "command") {
+    const duration = taskDuration(taskDetails(task));
+    if (duration)
+      progress.push(duration);
+    return progress;
+  }
   if (task.currentTool)
     progress.push(`→ ${task.currentTool}`);
   if (task.toolCalls !== undefined) {
@@ -2848,6 +2920,19 @@ function messageContentText(message) {
 `);
 }
 function taskTranscript(task) {
+  if (task.kind === "command") {
+    if (task.outputFile) {
+      try {
+        const content = readFileSync6(task.outputFile, "utf8");
+        const lines = content.split(`
+`);
+        return lines.length > 0 && lines[0] !== "" ? lines : ["Command running... (no output yet)"];
+      } catch {}
+    }
+    const fallback = task.error ?? task.output ?? "Command output is not available yet.";
+    return fallback.split(`
+`);
+  }
   if (!task.sessionFile || !existsSync5(task.sessionFile)) {
     const fallback = task.error ?? task.output ?? "Child session is not available yet.";
     return fallback.split(`
@@ -3105,7 +3190,7 @@ ${requested.map(({ permission, resource }) => `${permission}: ${resource}`).join
   }
 }
 function renderTaskResult(id, state, value) {
-  const tag = state === "error" ? "task_error" : "task_result";
+  const tag = state === "error" || state === "cancelled" || state === "interrupted" ? "task_error" : "task_result";
   return `<task id="${id}" state="${state}">
 <${tag}>
 ${value}
@@ -3401,6 +3486,8 @@ class SubagentRuntime {
   primaryAgentSwitching = false;
   shuttingDown = false;
   activeSessionId;
+  taskUpdateListeners = new Set;
+  recentCompletions = new Map;
   constructor(pi, integration, createWorker = (...args) => this.defaultWorker(...args), loadCatalog = loadAgentCatalog, permissionPrompts = new PermissionPromptCoordinator) {
     this.pi = pi;
     this.integration = integration;
@@ -3417,14 +3504,31 @@ class SubagentRuntime {
   primaryAgentName() {
     return this.primaryAgent?.name;
   }
+  onTaskUpdate(listener) {
+    this.taskUpdateListeners.add(listener);
+    return () => this.taskUpdateListeners.delete(listener);
+  }
+  notifyTaskUpdate() {
+    for (const listener of this.taskUpdateListeners) {
+      try {
+        listener();
+      } catch {}
+    }
+  }
   register() {
     this.pi.registerTool(this.createTaskTool());
+    this.pi.registerTool(this.createTasksTool());
     registerLandstripCommands(this.pi, this, this.integration);
     this.pi.registerShortcut("ctrl+shift+a", {
       description: "Cycle to the next primary agent",
       handler: async (ctx) => this.cyclePrimaryAgent(ctx)
     });
+    this.pi.registerShortcut("ctrl+shift+t", {
+      description: "Open Landstrip task sessions dashboard",
+      handler: async (ctx) => this.openLandstrip("tasks", ctx)
+    });
     this.pi.on("session_start", async (_event, ctx) => {
+      this.recentCompletions.clear();
       this.activeSessionId = undefined;
       await this.dispose();
       this.shuttingDown = false;
@@ -3439,6 +3543,10 @@ class SubagentRuntime {
       if (nextTools.join("\x00") !== activeTools.join("\x00"))
         this.pi.setActiveTools(nextTools);
     });
+    this.pi.on("turn_start", async (_event, ctx) => {
+      this.recentCompletions.clear();
+      this.updateTaskWidget(ctx);
+    });
     this.pi.on("session_before_switch", async (_event, ctx) => {
       this.activeSessionId = undefined;
       if (ctx.hasUI)
@@ -3784,6 +3892,14 @@ ${this.primaryAgent.prompt}` };
       return settingsList;
     };
     return ctx.ui.custom((tui, theme, _keybindings, done) => {
+      const unsubscribe = this.onTaskUpdate(() => {
+        refreshTasks();
+        tui.requestRender();
+      });
+      const finish = () => {
+        unsubscribe();
+        done(undefined);
+      };
       const renderAgentsTab = (frame) => {
         const { tabs, pane, contentWidth, pad } = frame;
         const listedAgents = agentsForTab();
@@ -4008,7 +4124,7 @@ ${this.primaryAgent.prompt}` };
           const shellReadMode = overview.windowsMode !== undefined ? "Policy (required)" : overview.shellReadMode === "host" ? "Host-aligned" : "Policy";
           const changePath = overview.changeScope === "project" ? overview.paths.project : overview.paths.global;
           const item = (label, value) => `  ${theme.fg("dim", label.padEnd(16))} ${value}`;
-          lines.push(`${theme.fg(status.color, "●")} ${theme.fg("text", status.label)}`, item("Configured", overview.enabled ? theme.fg("text", "Enabled") : theme.fg("warning", "Disabled")), item("Runtime", overview.running ? theme.fg("success", "Running") : theme.fg("dim", "Not running")), "", theme.fg("accent", "Protection"), item("Network", networkMode), item("Shell reads", shellReadMode), item("Read rules", `${overview.config.filesystem.denyRead.length + overview.config.filesystem.allowRead.length} · ${overview.readRuleScope}`), item("Write rules", String(overview.config.filesystem.allowWrite.length + overview.config.filesystem.denyWrite.length)), item("Session grants", String(overview.sessionDomains.length + overview.sessionReadPaths.length + overview.sessionWritePaths.length)), "", theme.fg("accent", "Configuration"), item("Change scope", overview.changeScope === "project" ? "Project" : "Global"), item("Change file", truncateToWidth(changePath, Math.max(10, contentWidth - 20))), item("Project file", truncateToWidth(overview.paths.project, Math.max(10, contentWidth - 20))), item("Global file", truncateToWidth(overview.paths.global, Math.max(10, contentWidth - 20))), item("Landstrip binary", truncateToWidth(overview.paths.binary, Math.max(10, contentWidth - 20))));
+          lines.push(`${theme.fg(status.color, "●")} ${theme.fg("text", status.label)}`, item("Configured", overview.enabled ? theme.fg("text", "Enabled") : theme.fg("warning", "Disabled")), item("Runtime", overview.running ? theme.fg("success", "Running") : theme.fg("dim", "Not running")), item("Tasks", `${tasks.filter((t) => t.state === "running").length} running · ${tasks.length} total`), "", theme.fg("accent", "Protection"), item("Network", networkMode), item("Shell reads", shellReadMode), item("Read rules", `${overview.config.filesystem.denyRead.length + overview.config.filesystem.allowRead.length} · ${overview.readRuleScope}`), item("Write rules", String(overview.config.filesystem.allowWrite.length + overview.config.filesystem.denyWrite.length)), item("Session grants", String(overview.sessionDomains.length + overview.sessionReadPaths.length + overview.sessionWritePaths.length)), "", theme.fg("accent", "Configuration"), item("Change scope", overview.changeScope === "project" ? "Project" : "Global"), item("Change file", truncateToWidth(changePath, Math.max(10, contentWidth - 20))), item("Project file", truncateToWidth(overview.paths.project, Math.max(10, contentWidth - 20))), item("Global file", truncateToWidth(overview.paths.global, Math.max(10, contentWidth - 20))), item("Landstrip binary", truncateToWidth(overview.paths.binary, Math.max(10, contentWidth - 20))));
           if (overview.windowsMode !== undefined)
             lines.push(item("Windows mode", overview.windowsMode));
           lines.push("", theme.fg("accent", "Network"), item("Allowed domains", listValue(overview.config.network.allowedDomains)), item("Denied domains", listValue(overview.config.network.deniedDomains)), item("Unix sockets", overview.config.network.allowAllUnixSockets ? "all" : listValue(overview.config.network.allowUnixSockets)), "", theme.fg("accent", "Filesystem"), item("Shell reads", shellReadMode), item("Read rules for", overview.readRuleScope), item("Denied reads", listValue(overview.config.filesystem.denyRead)), item("Allowed reads", listValue(overview.config.filesystem.allowRead)), item("Allowed writes", listValue(overview.config.filesystem.allowWrite)), item("Denied writes", listValue(overview.config.filesystem.denyWrite)), "", theme.fg("accent", "Session grants"), item("Domains", listValue(overview.sessionDomains)), item("Read paths", listValue(overview.sessionReadPaths)), item("Write paths", listValue(overview.sessionWritePaths)));
@@ -4054,7 +4170,8 @@ ${this.primaryAgent.prompt}` };
               const cursor = index === selectedTask ? theme.fg("accent", "›") : " ";
               const selected = selectedTaskIds.has(task.id) ? theme.fg("accent", "✓") : " ";
               const indent = "  ".repeat(Math.max(0, task.depth - 1));
-              listLines.push(`${cursor} ${selected} ${indent}${taskState(theme, task)} ${theme.fg("accent", `@${task.agent}`)} ${theme.fg("text", task.description)} ${theme.fg("dim", task.id.slice(0, 8))}`);
+              const tag = task.kind === "command" ? "$ bash" : `@${task.agent}`;
+              listLines.push(`${cursor} ${selected} ${indent}${taskState(theme, task)} ${theme.fg("accent", tag)} ${theme.fg("text", task.description)} ${theme.fg("dim", task.id.slice(0, 8))}`);
             }
             if (status)
               listLines.push(theme.fg("dim", `  ${status}`));
@@ -4066,7 +4183,8 @@ ${this.primaryAgent.prompt}` };
           listLines.push("");
           if (pendingTaskAction) {
             const count = pendingTaskAction.taskIds.length;
-            const label = count === 1 ? `Delete ${pendingTaskAction.taskIds[0]?.slice(0, 8) ?? "task"}?` : `Delete ${count} selected task sessions?`;
+            const actionLabel = pendingTaskAction.type === "cancel" ? "Cancel" : "Delete";
+            const label = count === 1 ? `${actionLabel} ${pendingTaskAction.taskIds[0]?.slice(0, 8) ?? "task"}?` : `${actionLabel} ${count} selected tasks?`;
             listLines.push(`${theme.fg("warning", label)} ${dialogKeys(theme, [
               ["Enter", "confirm"],
               ["Esc", "cancel"]
@@ -4076,6 +4194,7 @@ ${this.primaryAgent.prompt}` };
               ["↑ / ↓", "move"],
               ["Space", "select"],
               ["Enter", "inspect"],
+              ["C", "cancel"],
               ["X", "delete"],
               ["Esc", "close"]
             ]));
@@ -4098,10 +4217,11 @@ ${this.primaryAgent.prompt}` };
             duration
           ].filter(Boolean);
           const usage = formatTaskUsage(task.usage);
+          const tag = task.kind === "command" ? "$ bash" : `@${task.agent}`;
           const lines = [
             tabs,
             "",
-            `${theme.fg("accent", theme.bold(`@${task.agent}`))} ${theme.fg("text", task.description)}`,
+            `${theme.fg("accent", theme.bold(tag))} ${theme.fg("text", task.description)}`,
             `${taskState(theme, task)} ${theme.fg("dim", metrics.join(" · "))} ${theme.fg("dim", "·")} ${theme.fg(follow ? "accent" : "muted", `Follow: ${follow ? "on" : "off"}`)}`,
             ...usage ? [theme.fg("dim", usage)] : [],
             "",
@@ -4116,11 +4236,11 @@ ${this.primaryAgent.prompt}` };
             const input = steering.render(Math.max(2, contentWidth - visibleWidth("Steer ")))[0] ?? "";
             lines.push(`${theme.fg("accent", "Steer")} ${input.replace(/^>/, "›")}`);
           } else if (task.state === "queued" || task.state === "running") {
-            lines.push(dialogKeys(theme, [
-              ["Enter", "steer"],
-              ["F", "follow"],
-              ["Esc", "tasks"]
-            ]));
+            const keys = [];
+            if (task.kind !== "command")
+              keys.push(["Enter", "steer"]);
+            keys.push(["C", "cancel"], ["F", "follow"], ["Esc", "tasks"]);
+            lines.push(dialogKeys(theme, keys));
           }
           return pane(lines.map((line) => truncateToWidth(line, contentWidth)));
         },
@@ -4149,7 +4269,7 @@ ${this.primaryAgent.prompt}` };
               return;
           }
           if (matchesKey(data, "escape")) {
-            done(undefined);
+            finish();
             return;
           }
           if (!matchesKey(data, "return"))
@@ -4196,10 +4316,20 @@ ${this.primaryAgent.prompt}` };
         tasks: (data) => {
           if (pendingTaskAction) {
             if (matchesKey(data, "return")) {
-              const taskIds = pendingTaskAction.taskIds;
+              const action = pendingTaskAction;
               pendingTaskAction = undefined;
-              const deleted = this.deleteTasks(taskIds, ctx);
-              for (const taskId of taskIds)
+              if (action.type === "cancel") {
+                this.cancelTasks(action.taskIds, ctx).then((cancelled) => {
+                  if (cancelled > 0) {
+                    ctx.ui.notify(`Cancelled ${cancelled} task${cancelled === 1 ? "" : "s"}`, "info");
+                  }
+                  refreshTasks();
+                  tui.requestRender();
+                });
+                return;
+              }
+              const deleted = this.deleteTasks(action.taskIds, ctx);
+              for (const taskId of action.taskIds)
                 selectedTaskIds.delete(taskId);
               refreshTasks();
               if (deleted > 0) {
@@ -4215,7 +4345,7 @@ ${this.primaryAgent.prompt}` };
             return;
           }
           if (matchesKey(data, "escape"))
-            done(undefined);
+            finish();
           else if (matchesKey(data, "up"))
             selectedTask = Math.max(0, selectedTask - 1);
           else if (matchesKey(data, "down") && tasks.length > 0) {
@@ -4226,6 +4356,17 @@ ${this.primaryAgent.prompt}` };
               return;
             if (!selectedTaskIds.delete(task.id))
               selectedTaskIds.add(task.id);
+          } else if (data.toLowerCase() === "c") {
+            const targets = taskTargets();
+            const cancellable = targets.filter((t) => t.state === "running" || t.state === "queued");
+            if (cancellable.length === 0) {
+              ctx.ui.notify("No running or queued tasks selected to cancel", "warning");
+              return;
+            }
+            pendingTaskAction = {
+              type: "cancel",
+              taskIds: cancellable.map((task) => task.id)
+            };
           } else if (data.toLowerCase() === "x") {
             const targets = taskTargets();
             if (targets.length === 0)
@@ -4247,13 +4388,22 @@ ${this.primaryAgent.prompt}` };
           const task = tasks[selectedTask];
           if (!task) {
             if (matchesKey(data, "escape"))
-              done(undefined);
+              finish();
             return;
           }
           if (matchesKey(data, "escape")) {
             tab = "tasks";
             follow = false;
             scroll = 0;
+          } else if (data.toLowerCase() === "c" && (task.state === "running" || task.state === "queued")) {
+            this.cancelTasks([task.id], ctx).then((count) => {
+              if (count > 0) {
+                ctx.ui.notify(`Cancelled task ${task.id.slice(0, 8)}`, "info");
+              }
+              refreshTasks();
+              tui.requestRender();
+            });
+            return;
           } else if (matchesKey(data, "return") && (task.state === "queued" || task.state === "running")) {
             const input = new Input;
             input.focused = true;
@@ -4314,7 +4464,7 @@ ${this.primaryAgent.prompt}` };
         },
         help: (data) => {
           if (matchesKey(data, "escape"))
-            done(undefined);
+            finish();
           return;
         }
       };
@@ -4408,7 +4558,9 @@ ${this.primaryAgent.prompt}` };
           }
           handleTabInput[tab](data);
         },
-        invalidate() {}
+        invalidate() {
+          unsubscribe();
+        }
       };
     }, {
       overlay: true,
@@ -4460,6 +4612,199 @@ ${this.primaryAgent.prompt}` };
       this.primaryAgentSwitching = false;
     }
   }
+  createTasksTool(boundCtx) {
+    return {
+      name: "tasks",
+      label: "Tasks",
+      description: "Inspect, list, and cancel background tasks and subagents managed by Landstrip.",
+      parameters: TasksToolSchema,
+      executionMode: "parallel",
+      renderCall: (input, theme) => {
+        const action = input.action ?? "list";
+        const target = input.task_id ? ` ${input.task_id.slice(0, 8)}` : "";
+        return new Text(`${theme.fg("toolTitle", theme.bold("Tasks"))} ${theme.fg("accent", action)}${theme.fg("dim", target)}`, 0, 0);
+      },
+      execute: async (_toolCallId, input, _signal, _onUpdate, callCtx) => {
+        const ctx = boundCtx ?? callCtx;
+        if (!ctx)
+          throw new Error("Task context is unavailable");
+        const action = input.action;
+        if (action === "list") {
+          const list = [...this.tasks.values()].map((task) => {
+            const details = taskDetails(task);
+            return {
+              id: details.taskId,
+              kind: details.kind,
+              agent: details.agent,
+              state: details.state,
+              command: details.command,
+              description: details.description,
+              duration: taskDuration(details),
+              exitCode: details.exitCode
+            };
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(list, null, 2) }],
+            details: { count: list.length }
+          };
+        }
+        if (action === "inspect") {
+          if (!input.task_id)
+            throw new Error("task_id is required for inspect action");
+          const matched = matchingTasksById([...this.tasks.values()], input.task_id);
+          if (matched.length === 0)
+            throw new Error(`No task found matching prefix "${input.task_id}"`);
+          if (matched.length > 1)
+            throw new Error(`Task ID prefix "${input.task_id}" matches ${matched.length} tasks`);
+          const task = matched[0];
+          const details = taskDetails(task);
+          const transcript = taskTranscript(task);
+          const tail = transcript.slice(-100).join(`
+`);
+          const header = task.kind === "command" ? `$ bash ${task.command ?? task.description}
+CWD: ${task.cwd}
+State: ${details.state}
+Duration: ${taskDuration(details) ?? "unknown"}
+Exit code: ${details.exitCode ?? "none"}` : `@${task.agent}: ${task.description}
+State: ${details.state}
+Duration: ${taskDuration(details) ?? "unknown"}
+Tool calls: ${task.toolCalls ?? 0}`;
+          return {
+            content: [{ type: "text", text: `${header}
+
+Recent Output:
+${tail}` }],
+            details
+          };
+        }
+        if (action === "cancel") {
+          if (!input.task_id)
+            throw new Error("task_id is required for cancel action");
+          const matched = matchingTasksById([...this.tasks.values()], input.task_id);
+          if (matched.length === 0)
+            throw new Error(`No task found matching prefix "${input.task_id}"`);
+          if (matched.length > 1)
+            throw new Error(`Task ID prefix "${input.task_id}" matches ${matched.length} tasks`);
+          const count = await this.cancelTasks([matched[0].id], ctx);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Cancelled task ${matched[0].id.slice(0, 8)} (${count} task cancelled)`
+              }
+            ],
+            details: { taskId: matched[0].id, cancelled: count > 0 }
+          };
+        }
+        throw new Error(`Unknown action: ${action}`);
+      }
+    };
+  }
+  async runBackgroundShellTask(params, ctx) {
+    const taskId = randomUUID();
+    const sessionId = this.activeSessionId ?? ctx.sessionManager.getSessionId();
+    const sessionDir = join7(getAgentDir4(), "sessions", "pi-landstrip", sessionId, taskId);
+    mkdirSync3(sessionDir, { recursive: true });
+    const outputFile = join7(sessionDir, "output.txt");
+    const outputFd = openSync(outputFile, "w");
+    const label = params.name?.trim() || truncateToWidth(params.command.trim(), 60);
+    const task = {
+      version: 1,
+      id: taskId,
+      kind: "command",
+      agent: "bash",
+      command: params.command,
+      description: label,
+      cwd: ctx.cwd,
+      parentSessionId: sessionId,
+      parentSessionFile: ctx.sessionManager.getSessionFile(),
+      depth: 1,
+      state: "running",
+      startedAt: Date.now(),
+      sessionDir,
+      outputFile,
+      background: true
+    };
+    this.tasks.set(taskId, task);
+    this.persist(task);
+    this.notifyTaskUpdate();
+    this.updateTaskWidget(ctx);
+    const controller = new AbortController;
+    this.controllers.set(taskId, controller);
+    (async () => {
+      try {
+        const result = await this.integration.runSandboxedCommand(params.command, ctx.cwd, {
+          timeout: params.timeout,
+          signal: controller.signal,
+          promptOnBlock: false,
+          onData: (chunk) => {
+            try {
+              writeSync(outputFd, chunk);
+            } catch {}
+            this.notifyTaskUpdate();
+          }
+        }, ctx);
+        task.exitCode = result.exitCode;
+        if (task.state !== "cancelled") {
+          task.state = result.exitCode === 0 ? "completed" : "error";
+          if (result.exitCode !== 0) {
+            task.error = `Process exited with code ${result.exitCode}`;
+          }
+        }
+      } catch (err) {
+        if (task.state !== "cancelled") {
+          task.state = "error";
+          task.error = formatError(err);
+        }
+      } finally {
+        try {
+          closeSync(outputFd);
+        } catch {}
+        task.finishedAt = Date.now();
+        this.controllers.delete(taskId);
+        this.persist(task);
+        const durationSec = taskDuration(taskDetails(task)) ?? "";
+        const exitMsg = task.exitCode !== undefined && task.exitCode !== null ? task.exitCode === 0 ? "completed" : `failed (exit ${task.exitCode})` : task.state === "cancelled" ? "cancelled" : "error";
+        this.recentCompletions.set(taskId, {
+          label: task.description,
+          status: task.state === "completed" ? "completed" : task.state === "cancelled" ? "cancelled" : "error",
+          text: `$ bash ${task.description} ${exitMsg} (${durationSec})`,
+          finishedAt: Date.now()
+        });
+        const commandOutput = task.outputFile && existsSync5(task.outputFile) ? readFileSync6(task.outputFile, "utf8").trim() : task.output ?? "";
+        const deliveryText = `Background command ${task.state === "completed" ? "completed" : "failed"}: ${task.description}
+
+${renderTaskResult(task.id, task.state, commandOutput || (task.error ?? ""))}`;
+        const delivered = await this.deliverBackground(task, deliveryText);
+        if (delivered) {
+          task.delivered = true;
+          this.persist(task);
+        }
+        if (task.state === "error") {
+          ctx.ui.notify(`Background command failed: ${task.description}`, "error");
+        }
+        this.notifyTaskUpdate();
+        this.updateTaskWidget(ctx);
+      }
+    })();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Command launched in background.
+Task ID: ${taskId}
+Output file: ${outputFile}
+Use /landstrip tasks to view live progress or cancel.`
+        }
+      ],
+      details: {
+        taskId,
+        state: "running",
+        description: label,
+        outputFile
+      }
+    };
+  }
   createTaskTool(parentTask, callerRules, boundCtx) {
     const cwd = boundCtx?.cwd ?? process.cwd();
     const catalog = this.loadCatalog(cwd, getAgentDir4(), boundCtx ? isProjectTrusted(boundCtx) : false);
@@ -5198,6 +5543,13 @@ ${catalog.diagnostics.join(`
       const output = await run;
       if (this.shuttingDown || task.delivered || this.foregroundClaims.has(task.id))
         return;
+      const durationSec = taskDuration(taskDetails(task)) ?? "";
+      this.recentCompletions.set(task.id, {
+        label: task.description,
+        status: "completed",
+        text: `@${task.agent}: ${task.description} completed (${durationSec})`,
+        finishedAt: Date.now()
+      });
       const delivered = await this.deliverBackground(task, `Background task completed: ${task.description}
 
 ${renderTaskResult(task.id, "completed", output)}`);
@@ -5205,10 +5557,18 @@ ${renderTaskResult(task.id, "completed", output)}`);
         return;
       task.delivered = true;
       this.persist(task);
+      this.notifyTaskUpdate();
     } catch (error) {
       if (this.shuttingDown || task.delivered || this.foregroundClaims.has(task.id))
         return;
       const message = formatError(error);
+      const durationSec = taskDuration(taskDetails(task)) ?? "";
+      this.recentCompletions.set(task.id, {
+        label: task.description,
+        status: task.state === "cancelled" ? "cancelled" : "error",
+        text: `@${task.agent}: ${task.description} failed (${durationSec})`,
+        finishedAt: Date.now()
+      });
       const delivered = await this.deliverBackground(task, `Background task failed: ${task.description}
 
 ${renderTaskResult(task.id, "error", message)}`);
@@ -5217,6 +5577,7 @@ ${renderTaskResult(task.id, "error", message)}`);
       ctx.ui.notify(`Background task failed: ${task.description}`, "error");
       task.delivered = true;
       this.persist(task);
+      this.notifyTaskUpdate();
     }
   }
   async deliverBackground(task, content) {
@@ -5262,7 +5623,7 @@ ${renderTaskResult(task.id, "error", message)}`);
       return;
     const tasks = [...this.tasks.values()];
     const active = tasks.filter((task) => task.state === "queued" || task.state === "running");
-    if (active.length === 0) {
+    if (active.length === 0 && this.recentCompletions.size === 0) {
       ctx.ui.setWidget(TASK_WIDGET, undefined);
       return;
     }
@@ -5274,10 +5635,11 @@ ${renderTaskResult(task.id, "error", message)}`);
     const summary = queued > 0 ? `${runningSummary} · ${queued} queued` : runningSummary;
     ctx.ui.setWidget(TASK_WIDGET, (_tui, theme) => ({
       render: (width) => {
-        const header = theme.fg("accent", theme.bold("Subagents")) + theme.fg("dim", `  ${summary}`);
+        const header = theme.fg("accent", theme.bold("Tasks")) + theme.fg("dim", `  ${summary}`);
         const tree = taskTreeLines(visible, (task) => {
           const state = taskState(theme, task);
-          const agent = theme.fg("accent", `@${task.agent}`);
+          const tag = task.kind === "command" ? "$ bash" : `@${task.agent}`;
+          const agent = theme.fg("accent", tag);
           const record = byId.get(task.id);
           const progress = taskProgress(record);
           const suffix = progress.length > 0 ? theme.fg("dim", `  ·  ${progress.join(" · ")}`) : "";
@@ -5290,32 +5652,97 @@ ${renderTaskResult(task.id, "error", message)}`);
         if (tree.length > shown.length) {
           shown.push(theme.fg("dim", `   … ${tree.length - shown.length} more`));
         }
+        if (this.recentCompletions.size > 0 && shown.length < 8) {
+          for (const comp of this.recentCompletions.values()) {
+            if (shown.length >= 8)
+              break;
+            const icon = comp.status === "completed" ? theme.fg("success", "✓") : comp.status === "cancelled" ? theme.fg("muted", "⊘") : theme.fg("error", "✗");
+            shown.push(`  ${icon} ${theme.fg("dim", comp.text)}`);
+          }
+        }
         return [header, ...shown].map((line) => truncateToWidth(line, Math.max(1, width)));
       },
       invalidate() {}
     }));
   }
+  abortTaskProcess(taskId) {
+    const running = this.running.get(taskId);
+    if (running) {
+      try {
+        running.rpc.abort();
+      } catch {}
+    }
+    const controller = this.controllers.get(taskId);
+    if (controller) {
+      controller.abort();
+      this.controllers.delete(taskId);
+    }
+  }
+  async cancelTasks(taskIds, ctx) {
+    let cancelled = 0;
+    const toCancel = new Set;
+    const collectRecursive = (id) => {
+      toCancel.add(id);
+      for (const t of this.tasks.values()) {
+        if (t.parentTaskId === id && !toCancel.has(t.id)) {
+          collectRecursive(t.id);
+        }
+      }
+    };
+    for (const id of taskIds) {
+      const task = this.tasks.get(id);
+      if (task)
+        collectRecursive(task.id);
+    }
+    for (const taskId of toCancel) {
+      const task = this.tasks.get(taskId);
+      if (!task)
+        continue;
+      if (task.state === "completed" || task.state === "error" || task.state === "cancelled") {
+        continue;
+      }
+      task.state = "cancelled";
+      task.finishedAt = Date.now();
+      this.abortTaskProcess(taskId);
+      this.persist(task);
+      cancelled += 1;
+    }
+    if (cancelled > 0) {
+      this.updateTaskWidget(ctx);
+      this.notifyTaskUpdate();
+    }
+    return cancelled;
+  }
   deleteTasks(taskIds, ctx) {
     let deleted = 0;
     for (const taskId of taskIds) {
       const task = this.tasks.get(taskId);
       if (!task)
         continue;
+      if (task.state === "running" || task.state === "queued") {
+        task.state = "cancelled";
+        task.finishedAt = Date.now();
+        this.abortTaskProcess(taskId);
+      }
       task.deleted = true;
       task.delivered = true;
-      this.controllers.get(taskId)?.abort();
       if (task.sessionDir && existsSync5(task.sessionDir)) {
-        rmSync(task.sessionDir, { recursive: true, force: true });
+        try {
+          rmSync(task.sessionDir, { recursive: true, force: true });
+        } catch {}
       }
       this.tasks.delete(taskId);
       this.pendingPrompts.delete(taskId);
       this.pendingSteers.delete(taskId);
       this.foregroundClaims.delete(taskId);
+      this.recentCompletions.delete(taskId);
       this.persist(task);
       deleted += 1;
     }
-    if (deleted > 0)
+    if (deleted > 0) {
       this.updateTaskWidget(ctx);
+      this.notifyTaskUpdate();
+    }
     return deleted;
   }
   async cleanupOrphanSubagentSessions(ctx) {
@@ -5536,6 +5963,18 @@ function registerSubagents(pi, integration, permissionPrompts = new PermissionPr
 }
 
 // index.ts
+import { Type as Type2 } from "typebox";
+import { Text as Text2 } from "@earendil-works/pi-tui";
+var LandstripBashSchema = Type2.Object({
+  command: Type2.String({ description: "Shell command to execute" }),
+  timeout: Type2.Optional(Type2.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+  background: Type2.Optional(Type2.Boolean({
+    description: "Run command asynchronously in the background and return a task ID"
+  })),
+  name: Type2.Optional(Type2.String({
+    description: "Concise label for the background command execution"
+  }))
+});
 function enforcesShellReadPolicy(shellReadAccess, platform = process.platform) {
   return shellReadAccess !== "host" || platform === "win32";
 }
@@ -5583,7 +6022,8 @@ function loadSandboxConfig(cwd, includeProject) {
   const globalConfig = deepMerge(JSON.parse(readFileSync7(join8(packageDir2, "sandbox.json"), "utf-8")), globalOverrides);
   return {
     ...deepMerge(globalConfig, projectOverrides),
-    explicitDenyRead: mergeArray(globalOverrides.filesystem?.denyRead ?? [], projectOverrides.filesystem?.denyRead)
+    explicitDenyRead: mergeArray(globalOverrides.filesystem?.denyRead ?? [], projectOverrides.filesystem?.denyRead),
+    explicitAllowRead: mergeArray(globalOverrides.filesystem?.allowRead ?? [], projectOverrides.filesystem?.allowRead)
   };
 }
 function windowsStatus() {
@@ -5927,7 +6367,8 @@ function pi_landstrip_default(pi) {
   }
   const permissionPrompts = new PermissionPromptCoordinator;
   const integration = createLandstripIntegrationWithPrompts({}, permissionPrompts);
-  registerSubagents(pi, integration, permissionPrompts);
+  const subagentRuntime = registerSubagents(pi, integration, permissionPrompts);
+  integration.setSubagentRuntime?.(subagentRuntime);
   integration.register(pi);
 }
 function createLandstripIntegration(options = {}) {
@@ -5936,6 +6377,7 @@ function createLandstripIntegration(options = {}) {
 function createLandstripIntegrationWithPrompts(options, permissionPrompts) {
   const shouldRegisterBashTool = options.registerBashTool ?? true;
   const localCwd = options.cwd ?? process.cwd();
+  let subagentRuntime = options.subagentRuntime;
   let projectConfigTrusted = false;
   function loadConfig(cwd) {
     return loadSandboxConfig(cwd, projectConfigTrusted);
@@ -6135,9 +6577,13 @@ function createLandstripIntegrationWithPrompts(options, permissionPrompts) {
     if (scope !== filePath)
       notify(ctx, `${verb} allowed (${choice}): ${scope}`, "info");
   }
-  async function applyReadChoice(ctx, choice, filePath, cwd, allowances) {
+  async function applyReadChoice(ctx, choice, filePath, cwd, allowances, scope = sessionScopeFor(filePath, cwd)) {
     const { globalPath, projectPath } = getPiConfigPaths(cwd, "sandbox.json");
-    const scope = sessionScopeFor(filePath, cwd);
+    if (allowances?.explicitDenyRead && !readAllowed(filePath, [scope], mergeArray(loadConfig(cwd).filesystem.denyRead, [
+      ...allowances.explicitDenyRead.patterns,
+      ...[...allowances.explicitDenyRead.globRoots.values()].flat()
+    ]), cwd))
+      scope = filePath;
     const configPath = choice === "project" ? projectPath : choice === "global" ? globalPath : undefined;
     if (configPath) {
       await addConfigValue(configPath, scope, (config) => config.filesystem?.allowRead ?? [], (config, allowRead) => {
@@ -6147,6 +6593,7 @@ function createLandstripIntegrationWithPrompts(options, permissionPrompts) {
     const target = choice === "once" ? allowances?.readPaths : sessionAllowedReadPaths;
     if (target && !target.includes(scope))
       target.push(scope);
+    allowances?.explicitDenyRead?.approvedPaths.push(scope);
     noteScope(ctx, "Read", choice, filePath, scope);
   }
   async function applyWriteChoice(ctx, choice, filePath, cwd, allowances) {
@@ -6291,8 +6738,8 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       });
     });
   }
-  async function resolveTrapQuery(trap, ctx, cwd, allowances, promptOnBlock, signal) {
-    if (!isFilesystemTrap(trap)) {
+  async function resolveTrapQuery(trap, ctx, cwd, allowances, promptOnBlock, signal, readScope) {
+    if (trap.kind !== "filesystem") {
       const key = `${trap.operation}\x00${trap.target}`;
       const current = () => sessionAllowedTargets.includes(key) || allowances.targets.includes(key) ? { action: "allow" } : undefined;
       const existing = current();
@@ -6320,7 +6767,13 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         return { action: "deny", reason: "hard-deny" };
       }
       if (trap.operation === "read" && allowances.explicitDenyRead && matchesPattern(path, mergeArray(allowances.explicitDenyRead.patterns, config.explicitDenyRead), cwd, allowances.explicitDenyRead.globRoots)) {
-        return { action: "deny", reason: "hard-deny" };
+        return isPathReadAllowed(path, mergeArray(config.explicitAllowRead, [
+          ...sessionAllowedReadPaths,
+          ...allowances.explicitDenyRead.approvedPaths
+        ]), mergeArray(config.explicitDenyRead, [
+          ...allowances.explicitDenyRead.patterns,
+          ...[...allowances.explicitDenyRead.globRoots.values()].flat()
+        ]), cwd, { requireAllowMatch: true }) ? { action: "allow" } : undefined;
       }
       if (trap.operation === "write" && (matchesPattern(path, config.filesystem.denyWriteAlways, cwd) || matchesPattern(path, config.filesystem.denyWrite, cwd))) {
         return { action: "deny", reason: "hard-deny" };
@@ -6339,7 +6792,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       if (choice === "abort" || promptSignal.aborted)
         return { action: "deny", reason: "rejected" };
       if (trap.operation === "read") {
-        await applyReadChoice(ctx, choice, path, cwd, allowances);
+        await applyReadChoice(ctx, choice, path, cwd, allowances, readScope);
       } else {
         await applyWriteChoice(ctx, choice, path, cwd, allowances);
       }
@@ -6461,15 +6914,24 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
     const explicitDenyGlobRoots = new Map;
     processAllowances.explicitDenyRead = {
       patterns: config.explicitDenyRead,
-      globRoots: explicitDenyGlobRoots
+      globRoots: explicitDenyGlobRoots,
+      approvedPaths: []
     };
-    for (const path of [options.cwd, options.command, ...processAllowances.readPaths]) {
+    const startupPaths = [
+      ...new Set([options.cwd, options.command, ...processAllowances.readPaths])
+    ];
+    for (const path of startupPaths) {
       if (/[*?[\]]/.test(path)) {
         throw new Error(`Worker startup read path "${path}" must be a concrete path, not a glob`);
       }
-      const deny = config.explicitDenyRead.find((pattern) => matchesPattern(path, [pattern], options.cwd, explicitDenyGlobRoots));
-      if (deny !== undefined) {
-        throw new Error(`Worker startup read path "${path}" conflicts with explicit filesystem.denyRead "${deny}"; change the configured deny or the worker startup paths`);
+      if (matchesPattern(path, mergeArray(config.filesystem.denyReadAlways, processAllowances.protectedPaths), options.cwd)) {
+        throw new Error(`Worker startup read path "${path}" is denied by sandbox policy`);
+      }
+    }
+    for (const path of startupPaths) {
+      const result = await resolveTrapQuery({ kind: "filesystem", operation: "read", path }, options.ctx, options.cwd, processAllowances, true, options.signal, normalizeBlockedPath(path, options.cwd));
+      if (result.action !== "allow") {
+        throw new Error(`Worker startup read access denied: ${path} (${result.reason})`);
       }
     }
     const { token: proxyToken, authorization: proxyAuthorization } = createProxyCredentials();
@@ -6527,14 +6989,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       if (spawned)
         throw new Error("Prepared process can only be spawned once");
       spawned = true;
-      const landstripArgs = [
-        "run",
-        "-p",
-        workerPolicy.path,
-        "--",
-        options.command,
-        ...options.args
-      ];
+      const landstripArgs = ["-p", workerPolicy.path, "--", options.command, ...options.args];
       const authPipe = Array.isArray(spawnOptions.stdio) && spawnOptions.stdio[WORKER_AUTH_FD] === "pipe";
       if (authPipe && process.platform === "win32") {
         throw new Error("Sandboxed worker authentication requires inherited Unix file descriptors");
@@ -6544,10 +6999,10 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         stdio.push(workerChildEnd ?? "ignore");
       if (authPipe) {
         stdio.push("pipe");
-        landstripArgs.splice(1, 0, "--inherit", String(WORKER_AUTH_FD));
+        landstripArgs.unshift("--inherit", String(WORKER_AUTH_FD));
       }
       if (workerChildEnd)
-        landstripArgs.splice(1, 0, "--trap", "3");
+        landstripArgs.unshift("--trap", "3");
       const child = spawn2(binaryPath(), landstripArgs, {
         ...spawnOptions,
         cwd: options.cwd,
@@ -6755,16 +7210,9 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
           };
           processAllowances = withWindowsProcessReadAccess(processAllowances, invocation.executable, cwd);
           policy = writePolicyFile(cwd, proxy?.port ?? null, "shell", processAllowances);
-          landstripArgs = [
-            "run",
-            "-p",
-            policy.path,
-            "--",
-            invocation.executable,
-            ...invocation.args
-          ];
+          landstripArgs = ["-p", policy.path, "--", invocation.executable, ...invocation.args];
           if (process.platform !== "win32")
-            landstripArgs.splice(1, 0, "--trap", "3");
+            landstripArgs.unshift("--trap", "3");
         } catch (error) {
           await teardownResources();
           throw error;
@@ -7194,13 +7642,45 @@ ${message}
     const localBash = createBashToolDefinition(cwd, {
       shellPath: SettingsManager2.create(cwd).getShellPath()
     });
+    const baseRenderCall = localBash.renderCall;
+    const baseRenderResult = localBash.renderResult;
     return {
       ...localBash,
       label: "bash (landstrip)",
       description: "Execute commands with the active Landstrip shell provider.",
-      async execute(id, params, signal, onUpdate, ctx) {
+      parameters: LandstripBashSchema,
+      renderCall(args, theme, context) {
+        const bashArgs = args;
+        if (bashArgs.background) {
+          const nameSuffix = bashArgs.name ? theme.fg("dim", ` (${bashArgs.name})`) : "";
+          return new Text2(theme.fg("accent", "$ " + bashArgs.command) + theme.fg("muted", " [bg]") + nameSuffix, 0, 0);
+        }
+        return baseRenderCall ? baseRenderCall(args, theme, context) : new Text2(args.command, 0, 0);
+      },
+      renderResult(result, options, theme, context) {
+        const details = result.details;
+        if (details?.taskId) {
+          const text = result.content[0]?.type === "text" ? result.content[0].text : "";
+          return new Text2(theme.fg("success", `✓ Task ${details.taskId.slice(0, 8)} started`) + `
+` + theme.fg("dim", text), 0, 0);
+        }
+        return baseRenderResult ? baseRenderResult(result, options, theme, context) : new Text2("", 0, 0);
+      },
+      async execute(id, rawParams, signal, onUpdate, ctx) {
         if (!ctx)
           throw new Error("Sandbox context is unavailable");
+        const params = rawParams;
+        if (params.background) {
+          if (!ensureSandboxState(ctx)) {
+            if (sandboxState === "unavailable") {
+              throw new Error("Sandbox is unavailable; refusing command");
+            }
+          }
+          if (!subagentRuntime) {
+            throw new Error("Background task runtime is unavailable");
+          }
+          return subagentRuntime.runBackgroundShellTask(params, ctx);
+        }
         if (!ensureSandboxState(ctx)) {
           if (sandboxState === "unavailable") {
             throw new Error("Sandbox is unavailable; refusing command");
@@ -7328,11 +7808,24 @@ ${message}
     on,
     register,
     emit: emitEvent,
+    runSandboxedCommand(command, cwd, execOptions, ctx) {
+      const ops = ensureSandboxState(ctx) ? createLandstripBashOps(ctx, { promptOnBlock: execOptions.promptOnBlock ?? false }) : externalShellProvider !== undefined ? createProviderBashOps() : createLocalBashOperations();
+      return ops.exec(command, cwd, {
+        onData: execOptions.onData ?? (() => {}),
+        signal: execOptions.signal,
+        timeout: execOptions.timeout,
+        env: execOptions.env
+      });
+    },
+    setSubagentRuntime(runtime) {
+      subagentRuntime = runtime;
+    },
     sandboxCallbacks
   };
   return integration;
 }
 export {
+  LandstripBashSchema,
   POSIX_SHELL_PROVIDER_ID,
   controlResponseLine,
   createLandstripIntegration,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.19.18",
+  "version": "0.19.20",
   "description": "Sandboxed Bash and process-backed agents for Pi",
   "keywords": [
     "landstrip",
@@ -39,7 +39,7 @@
     "ci:test": "npm run test"
   },
   "dependencies": {
-    "@landstrip/landstrip-api": "^0.19.18",
+    "@landstrip/landstrip-api": "^0.19.20",
     "jsonc-parser": "^3.3.1",
     "minimatch": "^10.2.5",
     "undici": "^8.9.0",