pi-async 0.1.0 → 0.2.0

package/src/core/watch.ts

@@ -2,6 +2,35 @@ import type { Condition, WatchSpec } from "./task.ts";
 
 const compiledRegexes = new WeakMap<Condition, RegExp>();
 
+/** Captured streams for watch evaluation: stdout/stderr are distinct; output is merged. */
+export interface WatchOutput {
+  output: string;
+  stdout: string;
+  stderr: string;
+}
+
+/** Cap regex subject size so catastrophic patterns cannot grow without bound (#24). */
+export const MAX_OUTPUT_MATCH_BYTES = 64 * 1024;
+
+/**
+ * Classic exponential-backtracking shape: a group that itself ends with a
+ * quantifier, then another quantifier — e.g. (a+)+ / (a*)* / (a|b+)+.
+ * Conservative; does not catch every polynomial case.
+ */
+const NESTED_QUANTIFIER = /\((?:[^()\\]|\\.)*[+*]\)\s*[+*]/;
+
+function rejectDangerousRegex(regex: string): string | undefined {
+  if (NESTED_QUANTIFIER.test(regex)) {
+    return "regex has nested quantifiers (ReDoS risk); simplify or use stdout_contains";
+  }
+  return undefined;
+}
+
+function matchSubject(output: string): string {
+  if (output.length <= MAX_OUTPUT_MATCH_BYTES) return output;
+  return output.slice(-MAX_OUTPUT_MATCH_BYTES);
+}
+
 export function validateWatchSpec(spec: WatchSpec): { ok: true } | { ok: false; error: string } {
   const invalid = (error: string) => ({ ok: false as const, error });
   if (!spec || typeof spec !== "object") return invalid("watch must be an object");
@@ -38,13 +67,18 @@ export function validateWatchSpec(spec: WatchSpec): { ok: true } | { ok: false;
           break;
         case "json_path_exists":
           if (typeof condition.path !== "string" || parseJsonPath(condition.path) === undefined) {
-            return invalid(`${location}: invalid JSON path`);
+            const shown = typeof condition.path === "string" ? JSON.stringify(condition.path) : String(condition.path);
+            return invalid(`${location}: invalid JSON path ${shown}: paths must start with "$" (e.g. $.ready or $.items[0].state)`);
           }
           break;
         case "output_matches":
           if (typeof condition.regex !== "string") return invalid(`${location}: regex must be a string`);
+          {
+            const danger = rejectDangerousRegex(condition.regex);
+            if (danger) return invalid(`${location}: ${danger}`);
+          }
           try {
-            compiledRegexes.set(condition, new RegExp(condition.regex));
+            compiledRegexes.set(condition, new RegExp(condition.regex, "m"));
           } catch {
             return invalid(`${location}: invalid regex`);
           }
@@ -57,7 +91,9 @@ export function validateWatchSpec(spec: WatchSpec): { ok: true } | { ok: false;
   return { ok: true };
 }
 
-export function evalConditions(conds: Condition[], ctx: { output: string; exitCode?: number }): boolean {
+export type WatchEvalContext = WatchOutput & { exitCode?: number };
+
+export function evalConditions(conds: Condition[], ctx: WatchEvalContext): boolean {
   const result = evaluateConditionsDetailed(conds, ctx);
   return result.status === "matched" && result.matched;
 }
@@ -65,7 +101,7 @@ export function evalConditions(conds: Condition[], ctx: { output: string; exitCo
 export interface WatchLoopDeps {
   taskId: string;
   spec: WatchSpec;
-  readOutput: () => string;
+  readOutput: () => WatchOutput;
   getExitCode: () => number | undefined;
   onSuccess: (detail: string) => void;
   onFailure: () => void;
@@ -111,17 +147,17 @@ export class WatchLoop {
     const conditions = [...this.deps.spec.failure_when, ...this.deps.spec.success_when];
     const needsOutput = conditions.some((condition) => condition.type !== "exit_code");
     const needsExitCode = conditions.some((condition) => condition.type === "exit_code");
-    let output = "";
+    let streams: WatchOutput = { output: "", stdout: "", stderr: "" };
     let exitCode: number | undefined;
     try {
-      if (needsOutput) output = this.deps.readOutput();
+      if (needsOutput) streams = this.deps.readOutput();
       if (needsExitCode) exitCode = this.deps.getExitCode();
     } catch {
       this.countBlindCheck();
       return;
     }
 
-    const ctx = { output, exitCode };
+    const ctx: WatchEvalContext = { ...streams, exitCode };
     const failure = evaluateConditionsDetailed(this.deps.spec.failure_when, ctx);
     if (failure.status === "matched" && failure.matched) {
       this.finish(this.deps.onFailure);
@@ -178,7 +214,7 @@ type ConditionEvaluation =
   | { status: "pending" }
   | { status: "error" };
 
-function evaluateConditionsDetailed(conditions: Condition[], ctx: { output: string; exitCode?: number }): ConditionEvaluation {
+function evaluateConditionsDetailed(conditions: Condition[], ctx: WatchEvalContext): ConditionEvaluation {
   let pending = false;
   let error = false;
   for (const condition of conditions) {
@@ -192,21 +228,21 @@ function evaluateConditionsDetailed(conditions: Condition[], ctx: { output: stri
   return { status: "matched", matched: false };
 }
 
-function evaluateCondition(condition: Condition, ctx: { output: string; exitCode?: number }): ConditionEvaluation {
+function evaluateCondition(condition: Condition, ctx: WatchEvalContext): ConditionEvaluation {
   switch (condition.type) {
     case "exit_code":
       return ctx.exitCode === undefined
         ? { status: "pending" }
         : { status: "matched", matched: ctx.exitCode === condition.equals };
     case "stdout_contains":
+      return { status: "matched", matched: ctx.stdout.includes(condition.value) };
     case "stderr_contains":
-      // The frozen WatchLoop context exposes the captured merged output stream.
-      return { status: "matched", matched: ctx.output.includes(condition.value) };
+      return { status: "matched", matched: ctx.stderr.includes(condition.value) };
     case "output_matches": {
       let regex = compiledRegexes.get(condition);
       if (!regex) {
         try {
-          regex = new RegExp(condition.regex);
+          regex = new RegExp(condition.regex, "m");
           compiledRegexes.set(condition, regex);
         } catch {
           return { status: "error" };
@@ -214,7 +250,7 @@ function evaluateCondition(condition: Condition, ctx: { output: string; exitCode
       }
       // Global/sticky expressions otherwise retain lastIndex between watch polls.
       regex.lastIndex = 0;
-      return { status: "matched", matched: regex.test(ctx.output) };
+      return { status: "matched", matched: regex.test(matchSubject(ctx.output)) };
     }
     case "json_path_exists": {
       let root: unknown;

package/src/guard/settle-guard.ts

@@ -1,5 +1,6 @@
 import type { PiCtx } from "../core/notify.ts";
 import type { TaskRegistry } from "../core/registry.ts";
+import { envNumber } from "../core/env.ts";
 
 export class SettleGuard {
   private readonly maxReminders: number;
@@ -14,7 +15,7 @@ export class SettleGuard {
     this.pi = pi;
     this.registry = registry;
     this.maxReminders = opts?.maxReminders ?? 3;
-    this.heartbeatMs = opts?.heartbeatMs ?? finiteEnvNumber("PI_ASYNC_HEARTBEAT_MS", 60_000);
+    this.heartbeatMs = opts?.heartbeatMs ?? envNumber("PI_ASYNC_HEARTBEAT_MS", 60_000, { integer: true, min: 0 });
   }
 
   register(): void {
@@ -59,7 +60,7 @@ export class SettleGuard {
     if (typeof ui?.setActivity !== "function") return;
     const count = this.registry.activeCount();
     const total = count.running + count.pending;
-    ui.setActivity("pi-async", total ? { message: `${total} async tasks` } : undefined);
+    ui.setActivity("pi-async", total ? { message: `${total} async task${total === 1 ? "" : "s"}` } : undefined);
   }
 
   private startHeartbeat(hooks: { appendEntry?: (customType: string, data: unknown) => void }): void {
@@ -72,7 +73,3 @@ export class SettleGuard {
   }
 }
 
-function finiteEnvNumber(name: string, fallback: number): number {
-  const parsed = Number(process.env[name] ?? fallback);
-  return Number.isFinite(parsed) ? parsed : fallback;
-}

package/src/tools/index.ts

@@ -1,6 +1,6 @@
 import type { PiCtx } from "../core/notify.ts";
 import type { TaskRegistry } from "../core/registry.ts";
-import type { WatchSpec } from "../core/task.ts";
+import { isTerminal, type WatchSpec } from "../core/task.ts";
 
 /**
  * Wrap an extension-tool return value into pi's ToolResultMessage shape.
@@ -21,7 +21,7 @@ function toolResult(payload: unknown, isError = false): { content: Array<{ type:
   return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }], details: { payload }, isError };
 }
 
-const promptGuidelines = "Check commands must not swallow errors with || true; map unknown states to failure; prefer structured output and jq -e; anchor output_matches regexes to avoid premature matches.";
+const promptGuidelines = "Check commands must not swallow errors with || true; map unknown states to failure; prefer structured output and jq -e; anchor output_matches regexes (compiled with multiline `m`: ^/$ are line boundaries) to avoid premature matches; prefer stdout_contains for simple cases and avoid nested quantifiers.";
 const MAX_LOG_BYTES = 50 * 1024;
 const schema = (properties: Record<string, unknown>, required: string[] = [], allOf: unknown[] = []) => ({ type: "object", properties, required, additionalProperties: false, ...(allOf.length ? { allOf } : {}) });
 const stringField = { type: "string" };
@@ -30,7 +30,10 @@ const conditionSchema = {
   oneOf: [
     { type: "object", properties: { type: { const: "exit_code" }, equals: { type: "number" } }, required: ["type", "equals"], additionalProperties: false },
     ...["stdout_contains", "stderr_contains"].map((type) => ({ type: "object", properties: { type: { const: type }, value: stringField }, required: ["type", "value"], additionalProperties: false })),
-    { type: "object", properties: { type: { const: "json_path_exists" }, path: stringField }, required: ["type", "path"], additionalProperties: false },
+    { type: "object", properties: {
+      type: { const: "json_path_exists" },
+      path: { type: "string", pattern: "^\\$", description: "JSONPath rooted at $; e.g. $.ready or $.items[0].state (bare names like \"ready\" are rejected)" },
+    }, required: ["type", "path"], additionalProperties: false },
     { type: "object", properties: { type: { const: "output_matches" }, regex: stringField }, required: ["type", "regex"], additionalProperties: false },
   ],
 };
@@ -49,12 +52,11 @@ export function registerTools(pi: PiCtx, registry: TaskRegistry): void {
   const api = pi as unknown as { registerTool?: (tool: ToolDef) => void };
   if (!api.registerTool) throw new Error("Pi host does not expose registerTool");
   api.registerTool({
-    name: "async_run", label: "Run async command", description: `Run a background, delayed, or synchronous shell command. ${promptGuidelines}`,
-    parameters: schema({ command: stringField, name: stringField, mode: { type: "string", enum: ["background", "sync", "delayed"], default: "background" }, timeoutMs: timeoutField, delayMs: timeoutField, taskTimeoutMs: timeoutField, onTimeout: { type: "string", enum: ["promote", "abort"], default: "promote" }, notifyOnCompletion: { type: "boolean" }, triggerOnCompletion: { type: "boolean" }, env: { type: "object", additionalProperties: { type: "string" } }, watch: watchSchema }, ["command"], [
-      { if: { properties: { mode: { const: "sync" } }, required: ["mode"] }, then: { required: ["timeoutMs"] } },
-      { if: { properties: { mode: { const: "delayed" } }, required: ["mode"] }, then: { required: ["delayMs"] } },
-      { if: { properties: { mode: { const: "sync" } }, required: ["mode"] }, then: { not: { required: ["watch"] } } },
-    ]),
+    name: "async_run", label: "Run async command",
+    description: `Run a background, delayed, or synchronous shell command. mode=sync requires timeoutMs; mode=delayed requires delayMs. onTimeout (sync only): "promote" (default) hands the still-running task to background and returns; "abort" stops WAITING only — the command keeps running in the background and will still notify on completion (Esc semantics; does not kill). ${promptGuidelines}`,
+    // Mode-conditional required fields + mode-scoped rejects enforced in execute (#45/#42),
+    // not allOf/then (host validator emits opaque "must match then schema").
+    parameters: schema({ command: stringField, name: stringField, mode: { type: "string", enum: ["background", "sync", "delayed"], default: "background" }, timeoutMs: timeoutField, delayMs: timeoutField, taskTimeoutMs: timeoutField, onTimeout: { type: "string", enum: ["promote", "abort"], default: "promote" }, notifyOnCompletion: { type: "boolean" }, triggerOnCompletion: { type: "boolean" }, env: { type: "object", additionalProperties: { type: "string" } }, watch: watchSchema }, ["command"]),
     execute: async (_id, params, signal) => {
       const mode = String(params.mode ?? "background");
       if (mode !== "background" && mode !== "sync" && mode !== "delayed") throw new Error(`Unsupported async_run mode: ${mode}`);
@@ -62,6 +64,8 @@ export function registerTools(pi: PiCtx, registry: TaskRegistry): void {
       if (mode === "sync" && params.timeoutMs === undefined) throw new Error("timeoutMs is required for sync mode");
       if (mode === "delayed" && params.delayMs === undefined) throw new Error("delayMs is required for delayed mode");
       if (params.watch !== undefined && mode === "sync") throw new Error("watch is only supported for background and delayed modes");
+      if (mode !== "sync" && params.timeoutMs !== undefined) throw new Error("timeoutMs is only valid for sync mode (use taskTimeoutMs to bound background/delayed tasks)");
+      if (mode !== "delayed" && params.delayMs !== undefined) throw new Error("delayMs is only valid for delayed mode");
       const options = {
         command,
         ...(typeof params.name === "string" ? { name: params.name } : {}),
@@ -87,6 +91,41 @@ export function registerTools(pi: PiCtx, registry: TaskRegistry): void {
     if (maxBytes > MAX_LOG_BYTES) throw new Error("maxBytes must be at most 50 KiB");
     return toolResult(registry.logs(String(params.taskId), { maxBytes, tail: params.tail !== false }));
   } });
-  api.registerTool({ name: "async_status", label: "Async task status", description: "List async tasks and current status.", parameters: schema({ includeHistory: { type: "boolean" } }), execute: async (_id, params) => toolResult(registry.list({ includeHistory: params.includeHistory !== false })) });
-  api.registerTool({ name: "async_kill", label: "Kill async task", description: "Terminate an async task and its process group.", parameters: schema({ taskId: stringField }, ["taskId"]), execute: async (_id, params) => { await registry.kill(String(params.taskId), "user"); return toolResult({ taskId: params.taskId, status: registry.get(String(params.taskId))?.status }); } });
+  api.registerTool({
+    name: "async_status", label: "Async task status",
+    description: "List async tasks and current status. Defaults to active (running/pending) only; pass includeHistory:true for up to 50 recent tasks.",
+    parameters: schema({ includeHistory: { type: "boolean" } }),
+    execute: async (_id, params) => {
+      const MAX_HISTORY = 50;
+      if (params.includeHistory === true) {
+        const all = registry.list({ includeHistory: true });
+        return toolResult(all.slice(-MAX_HISTORY));
+      }
+      return toolResult(registry.list({ includeHistory: false }));
+    },
+  });
+  api.registerTool({
+    name: "async_kill", label: "Kill async task", description: "Terminate an async task and its process group.",
+    parameters: schema({ taskId: stringField }, ["taskId"]),
+    execute: async (_id, params) => {
+      const taskId = String(params.taskId);
+      const before = registry.get(taskId);
+      const alreadyTerminal = before !== undefined && isTerminal(before.status);
+      let warning: string | undefined;
+      try {
+        await registry.kill(taskId, "user");
+      } catch (error) {
+        // Kill may still have finalized the task; surface confirmation failures as warning (#6).
+        warning = error instanceof Error ? error.message : String(error);
+      }
+      const after = registry.get(taskId);
+      return toolResult({
+        taskId,
+        status: after?.status,
+        ...(after?.killKind ? { killKind: after.killKind } : {}),
+        alreadyTerminal,
+        ...(warning ? { warning } : {}),
+      }, Boolean(warning && after?.status !== "killed"));
+    },
+  });
 }

package/src/tui/panel.ts

@@ -2,8 +2,10 @@ import { openSync, closeSync, fstatSync, readSync } from "node:fs";
 import type { PiCtx } from "../core/notify.ts";
 import type { TaskRegistry } from "../core/registry.ts";
 import type { TaskSnapshot } from "../core/task.ts";
-import { stripAnsi } from "../core/output.ts";
-import { clearDoneStatus } from "./status.ts";
+import { stripAnsi, visibleText } from "../core/output.ts";
+import { formatDuration } from "../core/duration.ts";
+import { fitWidth } from "./width.ts";
+import { clearDoneStatus, survivesClearCutoff } from "./status.ts";
 import { tuiHost } from "./host.ts";
 
 const isTui = (pi: unknown): boolean => {
@@ -14,8 +16,9 @@ const isTui = (pi: unknown): boolean => {
 
 const UI_TAIL_BYTES = 128 * 1024;
 const PANEL_ROWS = 12;
-let historyClearedAt = 0;
-const visible = (value: unknown): string => stripAnsi(String(value ?? "")).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").replace(/[\r\n\t]+/g, " ");
+const visible = visibleText;
+/** Per-line sanitizer for multiline command display — keeps LF, strips controls/tabs. */
+const visibleLine = (value: unknown): string => stripAnsi(String(value ?? "")).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").replace(/[\t]+/g, " ");
 function readUiOutput(task: TaskSnapshot, registry: TaskRegistry): { text: string; truncated: boolean } {
   const outputPath = task.metadata.outputFile;
   if (typeof outputPath !== "string") return { text: registry.logs(task.taskId, { maxBytes: UI_TAIL_BYTES, tail: true }).text, truncated: false };
@@ -33,21 +36,26 @@ function readUiOutput(task: TaskSnapshot, registry: TaskRegistry): { text: strin
   }
 }
 
-const duration = (task: TaskSnapshot, now: number): string => {
-  const end = task.finishedAt ?? now;
-  const seconds = Math.floor(Math.max(0, end - (task.startedAt ?? task.createdAt)) / 1000);
-  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-};
 const frame = (title: string, body: string[], width: number, height: number): string[] => {
   const w = Math.max(8, Math.floor(width));
   const h = Math.max(4, Math.floor(height));
-  const fit = (text: string): string => Array.from(text).slice(0, w - 4).join("").padEnd(w - 4);
-  const content = [`╭─ ${fit(title)}─╮`, ...body.slice(0, h - 2).map((line) => `│ ${fit(line)} │`), `╰${"─".repeat(w - 2)}╯`];
+  // Title prefix is "╭─ " (3) + "─╮" (2) => budget w-5; body "│ "/" │" (2+2) => w-4.
+  // #55 keeps fitTitle(w-5); #7/#62 routes both through fitWidth (cell-aware).
+  const fitTitle = (text: string): string => fitWidth(text, w - 5);
+  const fit = (text: string): string => fitWidth(text, w - 4);
+  const content = [`╭─ ${fitTitle(title)}─╮`, ...body.slice(0, h - 2).map((line) => `│ ${fit(line)} │`), `╰${"─".repeat(w - 2)}╯`];
   while (content.length < height) content.splice(content.length - 1, 0, `│${" ".repeat(w - 2)}│`);
   // The solid background masks chat rows beneath the overlay, as in legion-viz's live overlay.
   return content;
 };
 
+/** Bare Esc, Kitty CSI-u Escape (key 27), and a lone CSI introducer. */
+export function isEscapeKey(data: string): boolean {
+  if (data === "\u001b") return true;
+  if (data === "\u001b[") return true;
+  return /^\u001b\[27(?:;\d+)*u$/.test(data);
+}
+
 export function registerPanelCommands(pi: PiCtx, registry: TaskRegistry): void {
   // Commands/shortcuts are factory-time APIs (they exist on the factory pi); TUI
   // gating comes from the bound event context. Handlers receive a rich ctx with ui.
@@ -62,14 +70,23 @@ export function registerPanelCommands(pi: PiCtx, registry: TaskRegistry): void {
     description: "Clear async task history",
     handler: (_args, ctx) => {
       if (!isTui(ctx)) return;
-      historyClearedAt = Date.now();
-      clearDoneStatus();
+      clearDoneStatus(); // shared watermark in status.ts (#31)
     },
   });
-  try {
-    host.registerShortcut?.(process.env.PI_ASYNC_DOCK_SHORTCUT ?? "ctrl+alt+a", { description: "Open async task panel", handler: (ctx) => openPanel(ctx, registry) });
-  } catch {
-    // The /async command remains the fallback when Pi reserves this shortcut.
+  // CONTRACT: PI_ASYNC_DOCK_SHORTCUT is disableable ("可 off"). Treat
+  // off/none/false/empty (case-insensitive, trimmed) as skip registration —
+  // otherwise "off" would be registered as a literal key name (#30).
+  // Unset stays the default; only an explicitly set disable value skips.
+  const rawShortcut = process.env.PI_ASYNC_DOCK_SHORTCUT;
+  const normalized = rawShortcut === undefined ? undefined : rawShortcut.trim().toLowerCase();
+  const disabled = normalized !== undefined && ["off", "none", "false", ""].includes(normalized);
+  if (!disabled) {
+    const key = rawShortcut && rawShortcut.trim() ? rawShortcut.trim() : "ctrl+alt+a";
+    try {
+      host.registerShortcut?.(key, { description: "Open async task panel", handler: (ctx) => openPanel(ctx, registry) });
+    } catch {
+      // The /async command remains the fallback when Pi reserves this shortcut.
+    }
   }
 }
 
@@ -86,7 +103,7 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
     } | undefined,
   };
   if (!isTui(pi) || typeof host.ui?.custom !== "function") return;
-  const snapshots = (): TaskSnapshot[] => registry.list({ includeHistory: true }).filter((task) => task.createdAt >= historyClearedAt || task.status === "running" || task.status === "pending");
+  const snapshots = (): TaskSnapshot[] => registry.list({ includeHistory: true }).filter((task) => survivesClearCutoff(task));
   const custom = host.ui.custom;
   const factory = (tui: unknown, _theme: unknown, _keybindings: unknown, done: (value?: unknown) => void) => {
     let selected = initialTaskId ?? snapshots()[0]?.taskId;
@@ -94,21 +111,37 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
     let history = true;
     let confirmKill = false;
     let scroll = 0;
+    let listScroll = 0;
     let follow = true;
     let width = 100;
     let height = process.stdout.rows ?? 24;
     let lastLines: string[] = [];
+    let actionError: string | undefined;
     const requestRender = (): void => {
       (tui as { requestRender?: () => void } | undefined)?.requestRender?.();
     };
+    const filtered = (): TaskSnapshot[] => snapshots().filter((task) => history || task.status === "running" || task.status === "pending");
     const choose = (): TaskSnapshot | undefined => snapshots().find((task) => task.taskId === selected);
+    const listBudget = (): number => Math.max(1, height - 3); // frame borders + hint row
+    const ensureListWindow = (tasks: TaskSnapshot[]): number => {
+      const budget = listBudget();
+      const selIndex = tasks.findIndex((task) => task.taskId === selected);
+      const index = selIndex < 0 ? 0 : selIndex;
+      if (index < listScroll) listScroll = index;
+      if (index >= listScroll + budget) listScroll = index - budget + 1;
+      listScroll = Math.max(0, Math.min(listScroll, Math.max(0, tasks.length - budget)));
+      return listScroll;
+    };
     const renderBody = (): string[] => {
-      const tasks = snapshots().filter((task) => history || task.status === "running" || task.status === "pending");
+      const tasks = filtered();
       if (!detail) {
-        return ["↑/↓ select · Enter details · h history · q close", ...tasks.map((task) => {
+        const start = ensureListWindow(tasks);
+        const budget = listBudget();
+        const rows = tasks.slice(start, start + budget).map((task) => {
           const output = task.status === "running" ? registry.logs(task.taskId, { maxBytes: UI_TAIL_BYTES, tail: true }).text.split(/\r?\n/).filter(Boolean).at(-1) : undefined;
-          return `${task.taskId === selected ? "▶" : " "} ${visible(task.name)} · ${task.status} · ${duration(task, Date.now())}${output ? ` · ${visible(output)}` : ""}`;
-        })];
+          return `${task.taskId === selected ? "▶" : " "} ${visible(task.name)} · ${task.status} · ${formatDuration(task, Date.now())}${output ? ` · ${visible(output)}` : ""}`;
+        });
+        return ["↑/↓ select · Enter details · h history · q close", ...rows];
       }
       const task = choose();
       if (!task) return ["Task not found", "Esc return · q close"];
@@ -117,12 +150,20 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
       scroll = Math.min(scroll, Math.max(0, outputLines.length - PANEL_ROWS));
       const tail = outputLines.slice(Math.max(0, outputLines.length - PANEL_ROWS - scroll), outputLines.length - scroll);
       const meta = JSON.stringify(task.metadata);
+      const commandLines = String(task.command ?? "").split(/\r?\n/);
+      const killHint = task.status === "pending"
+        ? "Cancel this pending task? press k again to confirm; any other key cancels"
+        : "Kill this task? press k again to confirm; any other key cancels";
       return [
-        `${visible(task.name)} [${task.taskId}]`, `status: ${task.status} · elapsed: ${duration(task, Date.now())}`,
-        `command: ${visible(task.command)}`, `metadata: ${meta}`, `output${output.truncated ? " (tail truncated)" : ""}:`,
+        `${visible(task.name)} [${task.taskId}]`, `status: ${task.status} · elapsed: ${formatDuration(task, Date.now())}`,
+        "command:",
+        ...commandLines.map((line) => `  ${visibleLine(line)}`),
+        `metadata: ${meta}`, `output${output.truncated ? " (tail truncated)" : ""}:`,
         // registry.logs caps its own data at 50 KiB; the TUI intentionally reads a larger 128 KiB tail directly from the output file.
-        ...tail.map(visible), ...(confirmKill ? ["Kill this task? press k again to confirm; any other key cancels"] : []),
-        "Esc return · k kill · R rerun · c copy output path · ↑/↓ scroll",
+        ...tail.map(visible),
+        ...(actionError ? [`error: ${visible(actionError)}`] : []),
+        ...(confirmKill ? [killHint] : []),
+        "Esc return · k kill/cancel · R rerun · c copy output path · ↑/↓ scroll",
       ];
     };
     const render = (nextWidth?: number): string[] => {
@@ -135,9 +176,11 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
       return frame(detail ? "Async task detail" : "Async tasks", lastLines, width, height);
     };
     const move = (delta: number): void => {
-      const tasks = snapshots().filter((task) => history || task.status === "running" || task.status === "pending");
+      const tasks = filtered();
       const index = tasks.findIndex((task) => task.taskId === selected);
-      const next = tasks[Math.max(0, Math.min(tasks.length - 1, index + delta))];
+      // Harden dangling selection (filtered away): start from edge rather than relying on -1+delta===0 alone.
+      const base = index < 0 ? (delta > 0 ? -1 : 0) : index;
+      const next = tasks[Math.max(0, Math.min(tasks.length - 1, base + delta))];
       if (next) selected = next.taskId;
       if (detail && delta < 0) { scroll += -delta; follow = false; }
       else if (detail && delta > 0) { scroll = Math.max(0, scroll - delta); follow = scroll === 0; }
@@ -150,22 +193,37 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
         const key = data.toLowerCase();
         if (confirmKill && key !== "k") { confirmKill = false; requestRender(); return; }
         if (key === "q") { done(undefined); return; }
-        if (data === "\u001b") { if (detail) { detail = false; confirmKill = false; requestRender(); } else done(undefined); return; }
-        if (key === "h" && !detail) { history = !history; requestRender(); return; }
-        if (data === "\r" || data === "\n") { detail = true; scroll = 0; follow = true; requestRender(); return; }
+        if (isEscapeKey(data)) { if (detail) { detail = false; confirmKill = false; actionError = undefined; requestRender(); } else done(undefined); return; }
+        if (key === "h" && !detail) {
+          history = !history;
+          const tasks = filtered();
+          if (!tasks.some((task) => task.taskId === selected)) selected = tasks[0]?.taskId;
+          listScroll = 0;
+          requestRender();
+          return;
+        }
+        if (data === "\r" || data === "\n") { detail = true; scroll = 0; follow = true; actionError = undefined; requestRender(); return; }
         if (data === "\u001b[A" || data === "k") { if (detail && key === "k") {
           if (!confirmKill) { confirmKill = true; requestRender(); return; }
           confirmKill = false;
           const task = choose();
-          if (task?.status === "running") void registry.kill(task.taskId, "user");
+          if (task?.status === "running" || task?.status === "pending") void registry.kill(task.taskId, "user");
           requestRender(); return;
         } move(-1); return; }
         if (data === "\u001b[B" || key === "j") { move(1); return; }
         if (data === "R" && detail) {
           const task = choose();
           if (task) {
-            try { registry.submit({ command: task.command, name: task.name, mode: "background" }); }
-            catch (error) { host.ui?.notify?.(String(error), "error"); }
+            try {
+              const created = registry.submit({ command: task.command, name: task.name, mode: "background" });
+              selected = created.taskId;
+              scroll = 0;
+              follow = true;
+              actionError = undefined;
+            } catch (error) {
+              actionError = String(error);
+              host.ui?.notify?.(actionError, "error");
+            }
           }
           requestRender(); return;
         }
@@ -189,22 +247,25 @@ export function openPanel(pi: PiCtx, registry: TaskRegistry, initialTaskId?: str
           latchedId = undefined;
           if (detail) return undefined;
           if (event.button !== "left") return undefined;
-          const index = (event.y ?? -1) - 2;
-          const tasks = snapshots().filter((task) => history || task.status === "running" || task.status === "pending");
+          const tasks = filtered();
+          const start = ensureListWindow(tasks);
+          const index = (event.y ?? -1) - 2 + start;
           const task = tasks[index];
           if (!task) return undefined;
           latchedId = task.taskId;
           return { handled: true };
         }
         if (event.type !== "click" || event.button !== "left" || detail) return undefined;
-        const index = (event.y ?? -1) - 2;
-        const tasks = snapshots().filter((task) => history || task.status === "running" || task.status === "pending");
+        const tasks = filtered();
+        const start = ensureListWindow(tasks);
+        const index = (event.y ?? -1) - 2 + start;
         const task = tasks[index];
         if (!latchedId || !task || task.taskId !== latchedId) { latchedId = undefined; return undefined; }
         selected = latchedId;
         detail = true;
         scroll = 0;
         follow = true;
+        actionError = undefined;
         latchedId = undefined;
         requestRender();
         return { handled: true };