pi-landstrip 0.19.1 → 0.19.3

package/dist/index.ts

@@ -352,16 +352,16 @@ class AsyncQueue {
     const generation = this.generation;
     let release;
     const previous = this.tail;
-    this.tail = new Promise((resolve2) => {
-      release = resolve2;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
     });
     const finish = () => {
       release?.();
     };
     let wakeReset;
-    const resetSignal = new Promise((resolve2) => {
-      wakeReset = resolve2;
-      this.resetWaiters.push(resolve2);
+    const resetSignal = new Promise((resolve) => {
+      wakeReset = resolve;
+      this.resetWaiters.push(resolve);
     });
     const dropResetWaiter = () => {
       if (!wakeReset)
@@ -1396,15 +1396,15 @@ async function deleteProjectAgent(cwd, agent, agentDir = getAgentDir3()) {
 function prepareProjectAgentEditor(cwd, agent, agentDir = getAgentDir3()) {
   const origin = agent.origin;
   if (origin?.path && origin.kind === "pi-markdown") {
-    const target2 = projectMarkdownPath(cwd, agentDir, agent);
+    const target = projectMarkdownPath(cwd, agentDir, agent);
     return {
       title: `Edit @${agent.name}`,
       content: readFileSync4(origin.path, "utf8"),
       async save(content) {
         validateAgentRaw(agent.name, parseMarkdownAgentRaw(content));
-        await withFileMutationQueue2(target2, async () => {
-          mkdirSync2(dirname2(target2), { recursive: true });
-          writeFileSync2(target2, ensureFinalNewline2(content), { mode: 384 });
+        await withFileMutationQueue2(target, async () => {
+          mkdirSync2(dirname2(target), { recursive: true });
+          writeFileSync2(target, ensureFinalNewline2(content), { mode: 384 });
         });
       }
     };
@@ -1629,10 +1629,10 @@ function getLandstripArgumentCompletions(argumentPrefix, runtime, contextProvide
   const deps = { runtime, ctx: contextProvider?.() };
   if (argv.words.length === 0 && !argv.trailing) {
     const roots = [
-      ...SUBCOMMANDS.map((command2) => ({
-        value: command2.name,
-        label: command2.name,
-        description: command2.summary
+      ...SUBCOMMANDS.map((command) => ({
+        value: command.name,
+        label: command.name,
+        description: command.summary
       })),
       ...taskItems(runtime?.getTasks() ?? [], "")
     ];
@@ -1685,7 +1685,7 @@ function defaultSpawn(command, args, options) {
   return spawn(command, [...args], options);
 }
 function delay(milliseconds) {
-  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 class RpcProcess {
@@ -1742,7 +1742,7 @@ class RpcProcess {
     });
     child.stdin.on("error", (error) => this.handleChildError(child, error, "RPC stdin error"));
     child.on("error", (error) => this.handleChildError(child, error, "RPC process error"));
-    this.exitPromise = new Promise((resolve2) => {
+    this.exitPromise = new Promise((resolve) => {
       child.once("exit", (code, signal) => {
         this.disposeAuthPipe?.();
         this.disposeAuthPipe = undefined;
@@ -1750,13 +1750,13 @@ class RpcProcess {
           this.child = null;
           this.failAll(new Error(this.exitMessage(code, signal)));
         }
-        resolve2();
+        resolve();
       });
     });
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve, reject) => {
       const onSpawn = () => {
         cleanup();
-        resolve2();
+        resolve();
       };
       const onError = (error) => {
         cleanup();
@@ -1815,12 +1815,12 @@ class RpcProcess {
     if (this.fatalError)
       throw this.fatalError;
     const id = `rpc-${++this.nextRequestId}`;
-    const response = await new Promise((resolve2, reject) => {
+    const response = await new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(this.withStderr(`Timed out waiting for ${type} response`));
       }, this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
-      this.pending.set(id, { command: type, resolve: resolve2, reject, timer });
+      this.pending.set(id, { command: type, resolve, reject, timer });
       this.write({ ...fields, id, type }, (error) => {
         if (!error)
           return;
@@ -2036,12 +2036,12 @@ class RpcProcess {
   }
   waitForAgentSettled() {
     let waiter;
-    const promise = new Promise((resolve2, reject) => {
+    const promise = new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.settledWaiters.delete(waiter);
         reject(this.withStderr("Timed out waiting for agent_settled"));
       }, this.options.settleTimeoutMs ?? DEFAULT_SETTLE_TIMEOUT_MS);
-      waiter = { resolve: resolve2, reject, timer };
+      waiter = { resolve, reject, timer };
       this.settledWaiters.add(waiter);
     });
     return {
@@ -2060,13 +2060,13 @@ class RpcProcess {
     }
     this.settledWaiters.clear();
   }
-  write(record2, callback) {
+  write(record, callback) {
     const child = this.child;
     if (!child || child.stdin.destroyed) {
       callback(this.notRunningError());
       return;
     }
-    child.stdin.write(`${JSON.stringify(record2)}
+    child.stdin.write(`${JSON.stringify(record)}
 `, callback);
   }
   handleChildError(child, error, prefix) {
@@ -2196,18 +2196,18 @@ async function resolveWorkerAuth(registry, provider, signal, model) {
     timer = setTimeout(() => reject(new Error("Subagent provider authentication lookup timed out after 30 seconds")), 30000);
   });
   try {
-    const resolve2 = async () => {
+    const resolve = async () => {
       try {
         const providerAuth = await registry.getProviderAuth(provider);
         if (signal.aborted || !providerAuth)
           return;
         if (model && typeof registry.getApiKeyAndHeaders === "function") {
-          const result2 = await registry.getApiKeyAndHeaders(model);
-          if (!result2.ok)
+          const result = await registry.getApiKeyAndHeaders(model);
+          if (!result.ok)
             throw new Error;
           return {
-            auth: { apiKey: result2.apiKey, headers: result2.headers, baseUrl: result2.baseUrl },
-            env: result2.env
+            auth: { apiKey: result.apiKey, headers: result.headers, baseUrl: result.baseUrl },
+            env: result.env
           };
         }
         return { auth: providerAuth.auth, env: providerAuth.env };
@@ -2215,7 +2215,7 @@ async function resolveWorkerAuth(registry, provider, signal, model) {
         throw new Error("Could not resolve subagent provider authentication");
       }
     };
-    const result = await Promise.race([resolve2(), interrupted]);
+    const result = await Promise.race([resolve(), interrupted]);
     if (signal.aborted)
       throw new Error("Task cancelled");
     try {
@@ -2807,7 +2807,8 @@ function taskProgress(task) {
   return progress;
 }
 function workerDialogTitle(task, title) {
-  return `@${task.agent} · ${task.description} · ${task.id.slice(0, 8)}
+  const label = `@${task.agent} · ${task.description} · ${task.id.slice(0, 8)}`;
+  return title === undefined ? label : `${label}
 ${title}`;
 }
 function messageContentText(message) {
@@ -2873,14 +2874,14 @@ var OAUTH_REFRESH_HOSTS = {
 };
 function modelEndpoint(ctx, selectedModel) {
   const models = ctx.modelRegistry?.getAll() ?? [];
-  const qualified = models.find((model2) => `${model2.provider}/${model2.id}` === selectedModel);
-  const byId = models.filter((model2) => model2.id === selectedModel);
+  const qualified = models.find((model) => `${model.provider}/${model.id}` === selectedModel);
+  const byId = models.filter((model) => model.id === selectedModel);
   const registered = qualified ?? (byId.length === 1 ? byId[0] : undefined);
   const activeName = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined;
   const active = selectedModel === activeName || byId.length === 0 && selectedModel === ctx.model?.id ? ctx.model : undefined;
   const model = registered ?? active;
   if (!model)
-    return { model: selectedModel, domains: [] };
+    return { error: byId.length > 1 ? "Ambiguous model" : "Model not found" };
   const domains = [];
   const endpoint = {
     provider: model.provider,
@@ -2897,20 +2898,21 @@ function modelEndpoint(ctx, selectedModel) {
     domains.push(refreshHost);
   return endpoint;
 }
-async function workerEndpoint(ctx, selectedModel, signal) {
+async function workerEndpoint(ctx, selectedModel, agentName, signal) {
   if (signal.aborted)
     throw new Error("Task cancelled");
   const endpoint = modelEndpoint(ctx, selectedModel);
+  if ("error" in endpoint) {
+    throw new Error(`${endpoint.error} for subagent ${agentName}: ${selectedModel}`);
+  }
   const { provider, domains, selected } = endpoint;
-  if (provider === undefined)
-    return endpoint;
   const auth = await resolveWorkerAuth(ctx.modelRegistry, provider, signal, selected);
   const host = workerAuthHost(auth?.auth.baseUrl);
   const granted = [...new Set(host ? [...domains, host] : domains)];
   return {
     ...endpoint,
     domains: granted,
-    resolveAuth: auth && selected ? workerAuthResolver(ctx.modelRegistry, selected, granted) : undefined
+    resolveAuth: auth ? workerAuthResolver(ctx.modelRegistry, selected, granted) : undefined
   };
 }
 function agentBootstrapPaths(agentDir, privateAuth) {
@@ -2964,7 +2966,7 @@ class Semaphore {
       this.active += 1;
       return this.releaseOnce();
     }
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve, reject) => {
       const abort = () => {
         const index = this.waiters.indexOf(start);
         if (index >= 0)
@@ -2974,7 +2976,7 @@ class Semaphore {
       const start = () => {
         signal?.removeEventListener("abort", abort);
         this.active += 1;
-        resolve4();
+        resolve();
       };
       this.waiters.push(start);
       signal?.addEventListener("abort", abort, { once: true });
@@ -3638,7 +3640,7 @@ ${this.primaryAgent.prompt}` };
       selectedTask = Math.max(0, Math.min(nextSelected < 0 ? 0 : nextSelected, tasks.length - 1));
     };
     const taskTargets = () => {
-      const selected = tasks.filter((task2) => selectedTaskIds.has(task2.id));
+      const selected = tasks.filter((task) => selectedTaskIds.has(task.id));
       if (selected.length > 0)
         return selected;
       const task = tasks[selectedTask];
@@ -3770,22 +3772,22 @@ ${this.primaryAgent.prompt}` };
         const listedAgents = agentsForTab();
         const agentRows = listRowBudget(tui.terminal?.rows, AGENT_LIST_ROWS, AGENT_TAB_CHROME_ROWS);
         const { shown, start, status } = listWindow(listedAgents, selectedAgent, agentRows);
-        const nameWidth = Math.min(20, Math.max(5, ...listedAgents.map((agent2) => visibleWidth(`@${agent2.name}`))));
+        const nameWidth = Math.min(20, Math.max(5, ...listedAgents.map((agent) => visibleWidth(`@${agent.name}`))));
         const modelWidth = Math.max(10, Math.min(24, Math.floor((contentWidth - 2) / 3)));
         const enabledWidth = 13;
         const runtimeWidth = Math.max(12, contentWidth - 2 - nameWidth - 1 - modelWidth - 1 - enabledWidth - 1);
-        const runtimeFor = (agent2) => {
+        const runtimeFor = (agent) => {
           const parts = [];
-          if (agent2.name === this.primaryAgent?.name)
+          if (agent.name === this.primaryAgent?.name)
             parts.push("★ primary");
-          const byState = (state) => [...this.tasks.values()].filter((task) => task.agent === agent2.name && task.state === state).length;
+          const byState = (state) => [...this.tasks.values()].filter((task) => task.agent === agent.name && task.state === state).length;
           const running = byState("running");
           const queued = byState("queued");
           if (running > 0)
             parts.push(`${running} running`);
           if (queued > 0)
             parts.push(`${queued} queued`);
-          const rules = [...catalog.permissions, ...agent2.permissions].length;
+          const rules = [...catalog.permissions, ...agent.permissions].length;
           parts.push(rules > 0 ? `${rules} rules` : "ask by default");
           return parts.length > 0 ? parts.join(" · ") : "—";
         };
@@ -3794,20 +3796,20 @@ ${this.primaryAgent.prompt}` };
           lines.push(`${theme.fg("accent", "Filter")} ${agentFilter}${filteringAgents ? theme.fg("accent", "█") : ""}`);
         }
         lines.push(theme.fg("dim", `  ${pad("Agent", nameWidth)} ${pad("Model", modelWidth)} ${pad("Enabled", enabledWidth)} ${pad("Runtime", runtimeWidth)}`));
-        for (const [offset, agent2] of shown.entries()) {
+        for (const [offset, agent] of shown.entries()) {
           const index = start + offset;
           const selected = index === selectedAgent;
           const cursor = selected ? theme.fg("accent", "›") : " ";
-          const disabled = agent2.disabled;
-          const deleting = confirmingDeleteAgent === agent2.name;
-          const inherited = !disabledOverrides.project.has(agent2.name);
+          const disabled = agent.disabled;
+          const deleting = confirmingDeleteAgent === agent.name;
+          const inherited = !disabledOverrides.project.has(agent.name);
           const enabled = inherited ? `inherited ${disabled ? "off" : "on"}` : disabled ? "disabled" : "enabled";
           const color = deleting ? "error" : disabled ? "muted" : "text";
-          const plainName = pad(`@${agent2.name}`, nameWidth);
-          const name = deleting ? theme.fg("error", plainName) : disabled ? theme.fg("muted", plainName) : colorizeAgentText(agent2.color, plainName, (agentColor, text) => theme.fg(agentColor, text));
-          const runtime = runtimeFor(agent2);
-          const line = `${cursor} ${name} ${theme.fg(color, pad(agent2.model ?? "current model", modelWidth))} ${theme.fg(deleting ? "error" : disabled ? "warning" : color, pad(enabled, enabledWidth))} ${theme.fg(disabled ? "muted" : "dim", pad(runtime, runtimeWidth))}`;
-          lines.push(agent2.name === this.primaryAgent?.name ? theme.bold(line) : line);
+          const plainName = pad(`@${agent.name}`, nameWidth);
+          const name = deleting ? theme.fg("error", plainName) : disabled ? theme.fg("muted", plainName) : colorizeAgentText(agent.color, plainName, (agentColor, text) => theme.fg(agentColor, text));
+          const runtime = runtimeFor(agent);
+          const line = `${cursor} ${name} ${theme.fg(color, pad(agent.model ?? "current model", modelWidth))} ${theme.fg(deleting ? "error" : disabled ? "warning" : color, pad(enabled, enabledWidth))} ${theme.fg(disabled ? "muted" : "dim", pad(runtime, runtimeWidth))}`;
+          lines.push(agent.name === this.primaryAgent?.name ? theme.bold(line) : line);
         }
         if (listedAgents.length === 0) {
           lines.push(theme.fg("muted", agentFilter ? `  No ${tab} agents match ${agentFilter}` : `  No ${tab} agents configured.`));
@@ -4584,22 +4586,22 @@ ${catalog.diagnostics.join(`
     if (input.task_id)
       task.delivered = false;
     if (existingRun) {
-      const controller2 = this.controllers.get(task.id);
+      const controller = this.controllers.get(task.id);
       let rejectCancelled;
       const cancelled = new Promise((_resolve, reject) => {
         rejectCancelled = reject;
       });
-      const abort2 = () => {
-        controller2?.abort();
+      const abort = () => {
+        controller?.abort();
         rejectCancelled?.(new Error("Task cancelled"));
       };
       const waitFor = (promise) => signal && !input.background ? Promise.race([promise, cancelled]) : promise;
       if (!input.background && signal?.aborted) {
-        controller2?.abort();
+        controller?.abort();
         throw new Error("Task cancelled");
       }
       if (!input.background)
-        signal?.addEventListener("abort", abort2, { once: true });
+        signal?.addEventListener("abort", abort, { once: true });
       try {
         const running = this.running.get(task.id);
         if (running) {
@@ -4629,7 +4631,7 @@ ${catalog.diagnostics.join(`
           this.releaseForeground(task.id);
         }
       } finally {
-        signal?.removeEventListener("abort", abort2);
+        signal?.removeEventListener("abort", abort);
       }
     }
     task.state = "queued";
@@ -4880,7 +4882,7 @@ ${catalog.diagnostics.join(`
     const model = agent.model ?? (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
     if (!model)
       throw new Error(`No model available for subagent ${agent.name}`);
-    const endpoint = await workerEndpoint(ctx, model, signal);
+    const endpoint = await workerEndpoint(ctx, model, agent.name, signal);
     if (signal.aborted)
       throw new Error("Task cancelled");
     const thinking = agent.variant && PI_THINKING_LEVELS.has(agent.variant) ? agent.variant : this.pi.getThinkingLevel();
@@ -4905,7 +4907,8 @@ ${catalog.diagnostics.join(`
       join7(packageDir, "index.ts"),
       ...workerExtensions.flatMap((extension) => ["--extension", extension.entry]),
       ...task.sessionFile ? ["--session", task.sessionFile] : task.sessionDir ? ["--session-dir", task.sessionDir] : [],
-      ...endpoint.provider === undefined ? [] : ["--provider", endpoint.provider],
+      "--provider",
+      endpoint.provider,
       "--model",
       endpoint.model,
       "--thinking",
@@ -4934,6 +4937,7 @@ ${catalog.diagnostics.join(`
       const modelsStorePath = join7(agentDir, "models-store.json");
       const cliEntry = invocation.args[0] ?? invocation.command;
       launch = await this.integration.prepareRpcWorker({
+        permissionPromptLabel: workerDialogTitle(task),
         command: invocation.command,
         args,
         cwd: ctx.cwd,
@@ -5148,7 +5152,7 @@ ${catalog.diagnostics.join(`
   }
   async forwardWorkerUi(ctx, task, request, signal) {
     if (request.method === "select" && typeof request.title === "string" && Array.isArray(request.options)) {
-      const options = request.options.filter((value2) => typeof value2 === "string");
+      const options = request.options.filter((value) => typeof value === "string");
       const value = await ctx.ui.select(workerDialogTitle(task, request.title), options, {
         signal
       });
@@ -5257,10 +5261,10 @@ ${renderTaskResult(task.id, "error", message)}`);
         const tree = taskTreeLines(visible, (task) => {
           const state = taskState(theme, task);
           const agent = theme.fg("accent", `@${task.agent}`);
-          const record2 = byId.get(task.id);
-          const progress = taskProgress(record2);
+          const record = byId.get(task.id);
+          const progress = taskProgress(record);
           const suffix = progress.length > 0 ? theme.fg("dim", `  ·  ${progress.join(" · ")}`) : "";
-          const indentWidth = 3 + Math.max(0, record2.depth) * 3;
+          const indentWidth = 3 + Math.max(0, record.depth) * 3;
           const descriptionWidth = Math.max(1, width - indentWidth - visibleWidth(`${state}  ${agent}  ${suffix}`));
           const description = theme.fg("text", truncateToWidth(task.description, descriptionWidth));
           return `${state}  ${agent}  ${description}${suffix}`;
@@ -5415,8 +5419,8 @@ ${renderTaskResult(task.id, failed ? "error" : "completed", value)}`;
     }
     if (agent.model) {
       const models = ctx.modelRegistry.getAll();
-      const qualified = models.filter((model2) => `${model2.provider}/${model2.id}` === agent.model);
-      const matches = qualified.length > 0 ? qualified : models.filter((model2) => model2.id === agent.model);
+      const qualified = models.filter((model) => `${model.provider}/${model.id}` === agent.model);
+      const matches = qualified.length > 0 ? qualified : models.filter((model) => model.id === agent.model);
       if (matches.length === 0) {
         ctx.ui.notify(`Model not found for primary agent ${agent.name}: ${agent.model}`, "error");
         return false;
@@ -5815,8 +5819,8 @@ function matchesPattern(filePath, patterns, cwd, explicitDenyGlobRoots) {
       }
       return roots.some((target) => abs === target || abs.startsWith(target.endsWith("/") ? target : `${target}/`));
     }
-    const sep5 = absPattern.endsWith("/") ? "" : "/";
-    return abs === absPattern || abs.startsWith(absPattern + sep5);
+    const sep = absPattern.endsWith("/") ? "" : "/";
+    return abs === absPattern || abs.startsWith(absPattern + sep);
   });
 }
 function normalizeBlockedPath(path, cwd) {
@@ -5867,9 +5871,32 @@ function extractNativeDeniedPath(output, cwd) {
     return normalizePathMatch(match[1], cwd);
   return null;
 }
+function extractDeniedPathMention(output, cwd, denied) {
+  const start = /(?<=^|['"`\s=:(])(?=\/|[a-zA-Z]:[\\/])/g;
+  for (const line of output.split(/\r?\n/)) {
+    for (const match of line.matchAll(start)) {
+      const raw = line.slice(match.index);
+      const quoted = raw.match(/^([^'"`]+)['"`]/);
+      const words = (quoted ? quoted[1] : raw).replace(/[.,:;)\]]+$/, "").split(" ");
+      for (let count = words.length;count > 0; count -= 1) {
+        const candidate = words.slice(0, count).join(" ");
+        if (!existsSync6(candidate))
+          continue;
+        const path = normalizeBlockedPath(candidate, cwd);
+        if (denied(path))
+          return path;
+        break;
+      }
+    }
+  }
+  return null;
+}
 function extractRetryableNativeReadDeniedPath(output, cwd, allowRead, denyRead) {
+  const denied = (path) => !readAllowed(path, allowRead, denyRead, cwd);
   const path = extractNativeDeniedPath(output, cwd);
-  return path && !readAllowed(path, allowRead, denyRead, cwd) ? path : null;
+  if (path)
+    return denied(path) ? path : null;
+  return extractDeniedPathMention(output, cwd, denied);
 }
 function extractNativeWriteDeniedPath(output, cwd) {
   const denial = String.raw`(?:Access is denied\.?|Operation not permitted|Permission denied)`;
@@ -5935,23 +5962,24 @@ async function stopPreparedChild(child) {
   child.kill("SIGKILL");
   if (child.exitCode !== null || child.signalCode !== null)
     return;
-  await new Promise((resolve5) => {
+  await new Promise((resolve) => {
     let settleTimer;
     const done = () => {
       if (settleTimer)
         clearTimeout(settleTimer);
       child.removeListener("exit", done);
-      resolve5();
+      resolve();
     };
     child.once("exit", done);
     settleTimer = setTimeout(done, 1000);
   });
 }
-async function showPermissionPrompt(ctx, title, options, signal) {
+async function showPermissionPrompt(ctx, title, options, signal, label) {
   if (!ctx.hasUI)
     return "abort";
-  const labels = options.map((option2) => option2.hint ? `${option2.label} — ${option2.hint}` : option2.label);
-  const selected = await ctx.ui.select(title, labels, { signal });
+  const labels = options.map((option) => option.hint ? `${option.label} — ${option.hint}` : option.label);
+  const selected = await ctx.ui.select(label ? `${label}
+${title}` : title, labels, { signal });
   if (signal?.aborted)
     return "abort";
   const index = selected === undefined ? -1 : labels.indexOf(selected);
@@ -5959,7 +5987,8 @@ async function showPermissionPrompt(ctx, title, options, signal) {
   if (!option)
     return "abort";
   if (option.confirm) {
-    const confirmed = await ctx.ui.confirm("Save this permission?", `${title}
+    const confirmed = await ctx.ui.confirm(label ? `${label}
+Save this permission?` : "Save this permission?", `${title}
 
 ${option.hint ?? "This changes persisted sandbox policy."}`, { signal });
     if (!confirmed || signal?.aborted)
@@ -5967,9 +5996,9 @@ ${option.hint ?? "This changes persisted sandbox policy."}`, { signal });
   }
   return option.action;
 }
-function promptReadBlock(ctx, filePath, reason, signal) {
+function promptReadBlock(ctx, filePath, reason, signal, label) {
   const title = reason ? `Read blocked: "${filePath}" is in denyRead (${reason})` : `Read blocked: "${filePath}" is not in allowRead`;
-  return showPermissionPrompt(ctx, title, PERMISSION_OPTIONS, signal);
+  return showPermissionPrompt(ctx, title, PERMISSION_OPTIONS, signal, label);
 }
 function writeEnvFile(env, proxyPort, proxyToken) {
   const lines = [];
@@ -6285,7 +6314,7 @@ function createLandstripIntegrationWithPrompts(options, permissionPrompts) {
       target.push(scope);
     noteScope(ctx, "Write", choice, filePath, scope);
   }
-  async function authorizeFilesystemToolAccess(ctx, accesses, options2 = {}) {
+  async function authorizeFilesystemToolAccess(ctx, accesses, options = {}) {
     const normalized = [
       ...new Map(accesses.map((access) => {
         const path = normalizeBlockedPath(access.path, ctx.cwd);
@@ -6317,9 +6346,9 @@ function createLandstripIntegrationWithPrompts(options, permissionPrompts) {
       const blocked = normalized.filter((access) => access.operation === "read" ? !readAllowed(access.path, getEffectiveAllowRead(config, ctx.cwd), getEffectiveDenyRead(config, ctx.cwd), ctx.cwd) : shouldPromptForWrite(access.path, getEffectiveAllowWrite(config), ctx.cwd));
       const paths = blocked.map(({ operation, path }) => `${operation}: ${path}`).join(`
 `);
-      const note = options2.authorizationNote ? `
+      const note = options.authorizationNote ? `
 
-${options2.authorizationNote}` : "";
+${options.authorizationNote}` : "";
       const choice = await showPermissionPrompt(ctx, `Filesystem policy blocked this tool call:
 ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       if (choice === "abort" || promptSignal.aborted) {
@@ -6333,7 +6362,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         }
       }
       return { allowed: true, prompted: true };
-    }, options2.signal);
+    }, options.signal);
   }
   async function ensureDomainAllowed(ctx, domain, cwd, allowances, signal) {
     const current = () => {
@@ -6348,7 +6377,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
     if (!ctx.hasUI)
       return current() ?? false;
     return permissionPrompts.resolve(current, async (promptSignal) => {
-      const choice = await showPermissionPrompt(ctx, `Network blocked: "${domain}" is not in the allowed domains list`, PERMISSION_OPTIONS, promptSignal);
+      const choice = await showPermissionPrompt(ctx, `Network blocked: "${domain}" is not in the allowed domains list`, PERMISSION_OPTIONS, promptSignal, allowances?.permissionPromptLabel);
       if (choice === "abort" || promptSignal.aborted)
         return false;
       await applyDomainChoice(choice, domain, cwd, allowances);
@@ -6398,7 +6427,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
     });
   }
   function createSocketPair() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve, reject) => {
       const server = createServer();
       server.on("error", reject);
       let client = null;
@@ -6407,7 +6436,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         server.close();
         if (client) {
           client.removeListener("error", reject);
-          resolve5([client, serverEnd]);
+          resolve([client, serverEnd]);
         }
       });
       server.listen(0, "127.0.0.1", () => {
@@ -6421,14 +6450,14 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
   async function resolveTrapQuery(trap, ctx, cwd, allowances, promptOnBlock, signal) {
     if (!isFilesystemTrap(trap)) {
       const key = `${trap.operation}\x00${trap.target}`;
-      const current2 = () => sessionAllowedTargets.includes(key) || allowances.targets.includes(key) ? { action: "allow" } : undefined;
-      const existing2 = current2();
-      if (existing2)
-        return existing2;
+      const current = () => sessionAllowedTargets.includes(key) || allowances.targets.includes(key) ? { action: "allow" } : undefined;
+      const existing = current();
+      if (existing)
+        return existing;
       if (!ctx.hasUI || !promptOnBlock)
         return { action: "deny", reason: "unprompted" };
-      return permissionPrompts.resolve(current2, async (promptSignal) => {
-        const choice = await showPermissionPrompt(ctx, `Network blocked: ${trap.operation} "${trap.target}"`, NETWORK_PERMISSION_OPTIONS, promptSignal);
+      return permissionPrompts.resolve(current, async (promptSignal) => {
+        const choice = await showPermissionPrompt(ctx, `Network blocked: ${trap.operation} "${trap.target}"`, NETWORK_PERMISSION_OPTIONS, promptSignal, allowances.permissionPromptLabel);
         if (choice === "abort" || promptSignal.aborted)
           return { action: "deny", reason: "rejected" };
         const targets = choice === "once" ? allowances.targets : sessionAllowedTargets;
@@ -6462,7 +6491,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       return { action: "deny", reason: "unprompted" };
     return permissionPrompts.resolve(current, async (promptSignal) => {
       const config = loadConfig(cwd);
-      const choice = trap.operation === "read" ? await promptReadBlock(ctx, path, matchesPattern(path, config.filesystem.denyRead, cwd) ? "granting allowRead will override it" : undefined, promptSignal) : await showPermissionPrompt(ctx, `Write blocked: "${path}" is not in allowWrite`, PERMISSION_OPTIONS, promptSignal);
+      const choice = trap.operation === "read" ? await promptReadBlock(ctx, path, matchesPattern(path, config.filesystem.denyRead, cwd) ? "granting allowRead will override it" : undefined, promptSignal, allowances.permissionPromptLabel) : await showPermissionPrompt(ctx, `Write blocked: "${path}" is not in allowWrite`, PERMISSION_OPTIONS, promptSignal, allowances.permissionPromptLabel);
       if (choice === "abort" || promptSignal.aborted)
         return { action: "deny", reason: "rejected" };
       if (trap.operation === "read") {
@@ -6519,7 +6548,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       }
     });
   }
-  function prepareUnsandboxedRpcWorker(options2) {
+  function prepareUnsandboxedRpcWorker(options) {
     let spawned = false;
     let disposed = false;
     let disposePromise;
@@ -6532,8 +6561,8 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       spawned = true;
       const child = spawn2(command, [...args], {
         ...spawnOptions,
-        cwd: options2.cwd,
-        env: options2.env,
+        cwd: options.cwd,
+        env: options.env,
         detached: true
       });
       patchProcessGroupKill(child);
@@ -6541,10 +6570,10 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       return child;
     };
     return {
-      command: options2.command,
-      args: options2.args,
-      cwd: options2.cwd,
-      env: options2.env,
+      command: options.command,
+      args: options.args,
+      cwd: options.cwd,
+      env: options.env,
       spawn: spawnWorker,
       dispose() {
         disposePromise ??= (async () => {
@@ -6555,65 +6584,66 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       }
     };
   }
-  async function prepareRpcWorker(options2) {
-    if (options2.signal?.aborted)
+  async function prepareRpcWorker(options) {
+    if (options.signal?.aborted)
       throw new Error("Task cancelled");
-    if (!ensureSandboxState(options2.ctx)) {
+    if (!ensureSandboxState(options.ctx)) {
       if (sandboxState === "unavailable") {
         throw new Error("Sandbox is unavailable; refusing subagent process");
       }
       if (!unsandboxedWorkerWarningShown) {
-        warnUnsandboxed(options2.ctx, "Subagent processes are running without Landstrip sandboxing", "warning");
+        warnUnsandboxed(options.ctx, "Subagent processes are running without Landstrip sandboxing", "warning");
         unsandboxedWorkerWarningShown = true;
       }
-      return prepareUnsandboxedRpcWorker(options2);
+      return prepareUnsandboxedRpcWorker(options);
     }
     const allowances = {
-      domains: [...options2.domains ?? []],
-      readPaths: [...options2.readPaths],
-      writePaths: [...options2.writePaths],
+      permissionPromptLabel: options.permissionPromptLabel,
+      domains: [...options.domains ?? []],
+      readPaths: [...options.readPaths],
+      writePaths: [...options.writePaths],
       targets: [],
       protectedPaths: [
-        ...new Set((options2.protectedPaths ?? []).flatMap((path) => {
+        ...new Set((options.protectedPaths ?? []).flatMap((path) => {
           if (/[*?[\]]/.test(path)) {
             throw new Error(`Worker protected path "${path}" must be a concrete path, not a glob`);
           }
-          return [expandPath(path, options2.cwd), canonicalizePath2(path, options2.cwd)];
+          return [expandPath(path, options.cwd), canonicalizePath2(path, options.cwd)];
         }))
       ]
     };
-    const processAllowances = withWindowsProcessReadAccess(allowances, options2.command, options2.cwd);
-    const config = loadConfig(options2.cwd);
+    const processAllowances = withWindowsProcessReadAccess(allowances, options.command, options.cwd);
+    const config = loadConfig(options.cwd);
     const explicitDenyGlobRoots = new Map;
     processAllowances.explicitDenyRead = {
       patterns: config.explicitDenyRead,
       globRoots: explicitDenyGlobRoots
     };
-    for (const path of [options2.cwd, options2.command, ...processAllowances.readPaths]) {
+    for (const path of [options.cwd, options.command, ...processAllowances.readPaths]) {
       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], options2.cwd, explicitDenyGlobRoots));
+      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`);
       }
     }
     const proxyToken = randomBytes(32).toString("base64url");
     const proxyAuthorization = `Basic ${Buffer.from(`landstrip:${proxyToken}`).toString("base64")}`;
-    const proxy = shouldStartProxy(config) ? await startProxy(options2.ctx, options2.cwd, processAllowances, options2.signal, proxyAuthorization, restrictedUserProxyPortRange()) : null;
+    const proxy = shouldStartProxy(config) ? await startProxy(options.ctx, options.cwd, processAllowances, options.signal, proxyAuthorization, restrictedUserProxyPortRange()) : null;
     let policy;
     let trapSocket;
     let childEnd;
     let disposed = false;
     try {
-      if (options2.signal?.aborted)
+      if (options.signal?.aborted)
         throw new Error("Task cancelled");
-      policy = writePolicyFile(options2.cwd, proxy?.port ?? null, "worker", processAllowances);
+      policy = writePolicyFile(options.cwd, proxy?.port ?? null, "worker", processAllowances);
       if (process.platform !== "win32") {
         [trapSocket, childEnd] = await createSocketPair();
-        if (options2.signal?.aborted)
+        if (options.signal?.aborted)
           throw new Error("Task cancelled");
-        attachWorkerTrap(trapSocket, options2.ctx, options2.cwd, processAllowances, options2.signal);
+        attachWorkerTrap(trapSocket, options.ctx, options.cwd, processAllowances, options.signal);
       }
     } catch (error) {
       trapSocket?.destroy();
@@ -6626,7 +6656,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
     const workerPolicy = policy;
     const workerTrapSocket = trapSocket;
     const workerChildEnd = childEnd;
-    const workerEnv = { ...options2.env };
+    const workerEnv = { ...options.env };
     if (proxy) {
       const url = `http://landstrip:${proxyToken}@127.0.0.1:${proxy.port}`;
       for (const name of PROXY_ENVIRONMENT_VARIABLES) {
@@ -6649,8 +6679,8 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         "-p",
         workerPolicy.path,
         "--",
-        options2.command,
-        ...options2.args
+        options.command,
+        ...options.args
       ];
       const authPipe = Array.isArray(spawnOptions.stdio) && spawnOptions.stdio[WORKER_AUTH_FD] === "pipe";
       if (authPipe && process.platform === "win32") {
@@ -6667,7 +6697,7 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         landstripArgs.splice(1, 0, "--trap", "3");
       const child = spawn2(binaryPath(), landstripArgs, {
         ...spawnOptions,
-        cwd: options2.cwd,
+        cwd: options.cwd,
         env: workerEnv,
         detached: true,
         stdio
@@ -6678,9 +6708,9 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       return child;
     };
     return {
-      command: options2.command,
-      args: options2.args,
-      cwd: options2.cwd,
+      command: options.command,
+      args: options.args,
+      cwd: options.cwd,
       env: workerEnv,
       spawn: spawnWorker,
       dispose() {
@@ -6696,15 +6726,15 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       }
     };
   }
-  async function prepareProcess(options2) {
-    if (process.platform === "win32" && (getNoSandboxFlag() || !loadConfig(options2.cwd).enabled)) {
+  async function prepareProcess(options) {
+    if (process.platform === "win32" && (getNoSandboxFlag() || !loadConfig(options.cwd).enabled)) {
       throw new Error("Generic process preparation requires sandboxing on Windows");
     }
     return prepareRpcWorker({
-      ...options2,
-      env: options2.env ?? process.env,
-      readPaths: options2.readPaths ?? [],
-      writePaths: options2.writePaths ?? []
+      ...options,
+      env: options.env ?? process.env,
+      readPaths: options.readPaths ?? [],
+      writePaths: options.writePaths ?? []
     });
   }
   function createProviderBashOps() {
@@ -7096,16 +7126,16 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         return null;
       const { globalPath, projectPath } = getPiConfigPaths(ctx.cwd, "sandbox.json");
       const current = () => {
-        const config2 = loadConfig(ctx.cwd);
-        if (matchesPattern(blockedPath, operation === "read" ? config2.filesystem.denyReadAlways : config2.filesystem.denyWrite, ctx.cwd)) {
+        const config = loadConfig(ctx.cwd);
+        if (matchesPattern(blockedPath, operation === "read" ? config.filesystem.denyReadAlways : config.filesystem.denyWrite, ctx.cwd)) {
           return false;
         }
-        const needsPrompt = operation === "read" ? !readAllowed(blockedPath, getEffectiveAllowRead(config2, ctx.cwd, allowances), getEffectiveDenyRead(config2, ctx.cwd), ctx.cwd) : shouldPromptForWrite(blockedPath, getEffectiveAllowWrite(config2, allowances), ctx.cwd);
+        const needsPrompt = operation === "read" ? !readAllowed(blockedPath, getEffectiveAllowRead(config, ctx.cwd, allowances), getEffectiveDenyRead(config, ctx.cwd), ctx.cwd) : shouldPromptForWrite(blockedPath, getEffectiveAllowWrite(config, allowances), ctx.cwd);
         return needsPrompt ? undefined : true;
       };
       const access = await permissionPrompts.resolve(current, async (promptSignal) => {
-        const config2 = loadConfig(ctx.cwd);
-        const choice = operation === "read" ? await promptReadBlock(ctx, blockedPath, matchesPattern(blockedPath, config2.filesystem.denyRead, ctx.cwd) ? "granting allowRead will override it" : undefined, promptSignal) : await showPermissionPrompt(ctx, `Write blocked: "${blockedPath}" is not in allowWrite`, PERMISSION_OPTIONS, promptSignal);
+        const config = loadConfig(ctx.cwd);
+        const choice = operation === "read" ? await promptReadBlock(ctx, blockedPath, matchesPattern(blockedPath, config.filesystem.denyRead, ctx.cwd) ? "granting allowRead will override it" : undefined, promptSignal) : await showPermissionPrompt(ctx, `Write blocked: "${blockedPath}" is not in allowWrite`, PERMISSION_OPTIONS, promptSignal);
         if (choice === "abort" || promptSignal.aborted)
           return false;
         if (operation === "read") {
@@ -7116,8 +7146,8 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
         return true;
       }, signal);
       if (!access) {
-        const config2 = loadConfig(ctx.cwd);
-        if (operation === "write" && matchesPattern(blockedPath, config2.filesystem.denyWrite, ctx.cwd)) {
+        const config = loadConfig(ctx.cwd);
+        if (operation === "write" && matchesPattern(blockedPath, config.filesystem.denyWrite, ctx.cwd)) {
           notify(ctx, `"${blockedPath}" is blocked by denyWrite. Check:
   ${projectPath}
   ${globalPath}`, "warning");
@@ -7153,21 +7183,21 @@ ${paths}${note}`, PERMISSION_OPTIONS, promptSignal);
       const errorText = formatError(error);
       const fallbackOutput = `${stderrOutput}
 ${errorText}`;
-      const blockedWritePath2 = extractTrapBlockedPath(landstripErrorOutput, ctx.cwd, "write") ?? extractNativeWriteDeniedPath(fallbackOutput, ctx.cwd);
-      if (blockedWritePath2) {
-        const retryResult2 = await retryWithAccess("write", blockedWritePath2);
-        if (retryResult2)
-          return retryResult2;
+      const blockedWritePath = extractTrapBlockedPath(landstripErrorOutput, ctx.cwd, "write") ?? extractNativeWriteDeniedPath(fallbackOutput, ctx.cwd);
+      if (blockedWritePath) {
+        const retryResult = await retryWithAccess("write", blockedWritePath);
+        if (retryResult)
+          return retryResult;
       }
-      const blockedReadPath2 = blockedReadPathForRetry(fallbackOutput);
-      if (blockedReadPath2) {
-        const retryResult2 = await retryWithAccess("read", blockedReadPath2);
-        if (retryResult2)
-          return retryResult2;
+      const blockedReadPath = blockedReadPathForRetry(fallbackOutput);
+      if (blockedReadPath) {
+        const retryResult = await retryWithAccess("read", blockedReadPath);
+        if (retryResult)
+          return retryResult;
       }
-      const landstripErrors2 = parseLandstripTraps(landstripErrorOutput);
-      if (landstripErrors2.length > 0) {
-        throw new Error(formatLandstripTraps(landstripErrors2));
+      const landstripErrors = parseLandstripTraps(landstripErrorOutput);
+      if (landstripErrors.length > 0) {
+        throw new Error(formatLandstripTraps(landstripErrors));
       }
       throw error;
     }
@@ -7180,9 +7210,9 @@ ${message}
     }
     const blockedWritePath = extractTrapBlockedPath(landstripErrorOutput, ctx.cwd, "write") ?? extractNativeWriteDeniedPath(stderrOutput, ctx.cwd);
     if (blockedWritePath) {
-      const retryResult2 = await retryWithAccess("write", blockedWritePath);
-      if (retryResult2)
-        return retryResult2;
+      const retryResult = await retryWithAccess("write", blockedWritePath);
+      if (retryResult)
+        return retryResult;
     }
     const blockedReadPath = blockedReadPathForRetry(stderrOutput);
     if (!blockedReadPath)
@@ -7240,7 +7270,7 @@ ${message}
       networkLabel = `${config.network.allowedDomains.length} domains`;
       networkColor = "accent";
     }
-    const sep5 = theme.fg("dim", "·");
+    const sep = 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];
@@ -7249,7 +7279,7 @@ ${message}
       const implementationLabel = windowsImplementation === "restrictedUser" ? "restricted user" : `${config.windows.appContainerMode} AppContainer`;
       fields.splice(1, 0, theme.fg(standard ? "warning" : "accent", implementationLabel));
     }
-    setTuiStatus(ctx, "sandbox", fields.join(`  ${sep5}  `));
+    setTuiStatus(ctx, "sandbox", fields.join(`  ${sep}  `));
   }
   const headlessWarnings = new Set;
   function warnUnsandboxed(ctx, message, level) {

package/dist/worker-auth-entry.js

@@ -228,17 +228,17 @@ async function main() {
     const agentDir = getAgentDir();
     const sessionManager = args.session ? SessionManager.open(args.session, args.sessionDir) : args.noSession ? SessionManager.inMemory(cwd) : SessionManager.create(cwd, args.sessionDir);
     const absolutePaths = (paths) => paths?.map((path) => resolve(cwd, path));
-    const runtime = await createAgentSessionRuntime(async ({ cwd: cwd2, sessionManager: sessionManager2, sessionStartEvent }) => {
+    const runtime = await createAgentSessionRuntime(async ({ cwd, sessionManager, sessionStartEvent }) => {
       const catalog = await ModelRuntime.create({
         credentials: new InMemoryCredentialStore,
         allowModelNetwork: false,
         refreshOnCreate: false
       });
       const services = await createAgentSessionServices({
-        cwd: cwd2,
+        cwd,
         agentDir,
         modelRuntime: catalog,
-        settingsManager: SettingsManager.create(cwd2, agentDir, {
+        settingsManager: SettingsManager.create(cwd, agentDir, {
           projectTrusted: args.projectTrustOverride === true
         }),
         extensionFlagValues: args.unknownFlags,
@@ -274,7 +274,7 @@ async function main() {
       return {
         ...await createAgentSessionFromServices({
           services,
-          sessionManager: sessionManager2,
+          sessionManager,
           sessionStartEvent,
           model: initial.model,
           thinkingLevel: args.thinking,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-landstrip",
-  "version": "0.19.1",
+  "version": "0.19.3",
   "description": "Sandboxed Bash and process-backed agents for Pi",
   "keywords": [
     "landstrip",
@@ -39,22 +39,22 @@
     "ci:test": "npm run test"
   },
   "dependencies": {
-    "@landstrip/landstrip-api": "^0.19.1",
+    "@landstrip/landstrip-api": "^0.19.3",
     "jsonc-parser": "^3.3.1",
     "minimatch": "^10.2.5",
     "undici": "^8.9.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.84.1",
+    "@earendil-works/pi-ai": "^0.85.1",
     "@earendil-works/pi-coding-agent": "^0.85.1",
     "@earendil-works/pi-tui": "^0.85.1",
     "@types/node": "^26.4.1",
-    "oxfmt": "^0.64.0",
+    "oxfmt": "^0.67.0",
     "oxlint": "^1.68.0",
     "typebox": "^1.3.6",
     "typescript": "^5.0.0",
-    "vitest": "^4.1.9"
+    "vitest": "^5.0.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.82.0",