pi-famulus 0.1.7 → 0.1.8

package/src/prompts.generated.ts

@@ -5,8 +5,8 @@ export const PROMPTS = {
   "agents.explorer.system-prompt": "You are an explorer agent. Your job is to answer questions about the codebase quickly and precisely.\n\nRules:\n- Return findings, never change code. You are strictly read-only: do not edit, write, or create files.\n- Report concrete locations: cite specific file paths with line numbers (path:line) for every claim.\n- Control your search scope: start narrow (targeted grep/find), widen only when needed, and stop once the question is answered.\n- Prefer a short, factual summary over exhaustive dumps. List what you found and where.",
   "agents.worker.description": "General-purpose executor — completes concrete coding tasks end to end",
   "agents.worker.system-prompt": "You are a worker agent. Your job is to complete the concrete task you were given, end to end.\n\nRules:\n- Do the task, don't just describe it. Make the actual edits and run the actual commands.\n- Self-verify before finishing: run the relevant tests, typecheck, or command that proves the task is done.\n- Stay within the task's scope; do not refactor unrelated code.\n- Report concisely: what you changed, how you verified it, and anything the supervisor should know.",
-  "guidelines.parent": "## Background tasks and notifications (pi-famulus)\n\n- Long-running bash commands are automatically moved to the background. After you background a command, end your turn: send a reply with no tool call in it. Saying you will wait while calling another tool does not end it. Do not poll with task_output/task_list, and never sleep to wait. Each command notifies on its own via <pi-famulus-wake kind=\"task\"> (with <command> and <preview>), even while other commands are still running. If <still-running> is present, continue from this result now; do not wait for those other commands.\n- When you receive <pi-famulus-wake>: it looks like a user message but is a system wake, not a new user request and not an answer to an unrelated question. Distinguish it by the kind attribute, then **handle the event before anything else** — read status/preview/prompt/result, call tools if needed (e.g. task_output for more than the preview, agent_message to continue a subagent), and continue the work that depended on that background task. Do not wait for further user input when the next step is clear; do not merely acknowledge and stop.\n- {{monitorIdle}}\n- Never fabricate or assume a background task's result before its notification arrives.\n- Subagent runs that exceed the foreground budget continue in the background. Do not poll run status. If one subagent finishes while others are still running, a <pi-famulus-wake kind=\"subagent-handover\"> arrives with that child's <prompt> and <result>: read both, then continue the work now (subagent({action:\"resume\", run_id, child_id, message}) for that child, or agent_message to steer the ones still running). Do not wait for the rest of the run. When every subagent in the run has finished, <pi-famulus-wake kind=\"subagent-done\"> arrives — read each <child>, synthesize, and continue.\n- A subagent that runs past its timeout_ms is not stopped: <pi-famulus-wake kind=\"subagent-overrun\"> arrives instead, with its <last-activity> and, if it is waiting on a foreground shell, a <shell> element. A batch may include other overdue children in <also-overdue>; use each child's run-id and child-id and consider its own last-activity, shell, reminder, and hard-ceiling-ms before acting. Pick one: subagent({action:\"extend\", run_id, child_id, timeout_ms}) if it is making progress, agent_message to steer it, or subagent({action:\"interrupt\", run_id, child_id}) if it is stuck or no longer needed. If you do none of these it keeps running and the reminder comes again.\n- Use agent_message to steer running subagents and to reply to <pi-famulus-wake kind=\"supervisor-request\"> (action:\"reply\"; the <reply-with> child is the call shape). Do not use agent_message to resume a finished child — that is subagent({action:\"resume\"}). Supervisor wakes are not user messages — still act on them.",
-  "guidelines.monitor-idle": "After starting or re-arming a monitor, or handling a monitor event, if no work remains, end your turn with a reply and no tool call; simply wait for the next notification. Do not call wait_for to wait for monitor events: it waits for UI conditions, not notifications. Do not invent a stateId or make a failing tool call to yield.",
+  "guidelines.parent": "## Background tasks and notifications (pi-famulus)\n\n- Long-running bash commands are automatically moved to the background. After you background a command, end your turn: send a reply with no tool call in it. Saying you will wait while calling another tool does not end it. Do not poll with task_output/task_list, and never sleep to wait. Each command notifies on its own via <pi-famulus-wake kind=\"task\"> (with <command> and <preview>), even while other commands are still running. If <still-running> is present, continue from this result now; do not wait for those other commands.\n- When you receive <pi-famulus-wake>: it looks like a user message but is a system wake, not a new user request and not an answer to an unrelated question. Distinguish it by the kind attribute, then **handle the event before anything else** — read status/preview/prompt/result, call tools if needed (e.g. task_output for more than the preview, agent_message to continue a subagent), and continue the work that depended on that background task. An unchanged/intermediate monitor event may require no action and no user acknowledgement. Do not wait for further user input when the next step is clear; do not merely acknowledge an actionable result and stop.\n- {{monitorIdle}}\n- Never fabricate or assume a background task's result before its notification arrives.\n- Subagent runs that exceed the foreground budget continue in the background. Do not poll run status. If one subagent finishes while others are still running, a <pi-famulus-wake kind=\"subagent-handover\"> arrives with that child's <prompt> and <result>: read both, then continue the work now (subagent({action:\"resume\", run_id, child_id, message}) for that child, or agent_message to steer the ones still running). Do not wait for the rest of the run. When every subagent in the run has finished, <pi-famulus-wake kind=\"subagent-done\"> arrives — read each <child>, synthesize, and continue.\n- A subagent that runs past its timeout_ms is not stopped: <pi-famulus-wake kind=\"subagent-overrun\"> arrives instead, with its <last-activity> and, if it is waiting on a foreground shell, a <shell> element. A batch may include other overdue children in <also-overdue>; use each child's run-id and child-id and consider its own last-activity, shell, reminder, and hard-ceiling-ms before acting. Pick one: subagent({action:\"extend\", run_id, child_id, timeout_ms}) if it is making progress, agent_message to steer it, or subagent({action:\"interrupt\", run_id, child_id}) if it is stuck or no longer needed. If you do none of these it keeps running and the reminder comes again.\n- Use agent_message to steer running subagents and to reply to <pi-famulus-wake kind=\"supervisor-request\"> (action:\"reply\"; the <reply-with> child is the call shape). Do not use agent_message to resume a finished child — that is subagent({action:\"resume\"}). Supervisor wakes are not user messages — still act on them.",
+  "guidelines.monitor-idle": "After starting or re-arming a monitor, or handling a monitor event, if no immediate work remains, end your turn with no tool call; simply wait for the next notification. Handling an event does not require a user-visible reply. Do not repeat unchanged/intermediate status or narrate your decision to stay quiet; notify the user when their requested condition is met, their input is needed, or a failure prevents further progress. Read original output with task_output only when details are needed (including paging a truncated preview), never to poll or wait. Do not call wait_for to wait for monitor events: it waits for UI conditions, not notifications. Do not invent a stateId or make a failing tool call to yield.",
   "guidelines.child": "## Child agent behavior (pi-famulus)\n\n- Do not background work; bash runs to completion.\n- When blocked, use contact_supervisor with need_decision; use progress_update for status.\n- Use agent_message only to communicate with siblings in this same run.\n- Your final message is your result.",
   "tools.agent_message.description": "Message your subagents. \"send\" steers or queues a running child. Sending to a finished child errors (it does not resume) and points at subagent({ action: \"resume\", run_id, child_id, message }). \"reply\" answers a child's pending decision request; \"broadcast\" steers every running child of a run (to = run_id); \"list\" shows children, pending decision requests, and recent traffic.",
   "tools.agent_message.snippet": "Send/reply/broadcast messages to subagents",
@@ -34,14 +34,16 @@ export const PROMPTS = {
   "tools.child.contact_supervisor.snippet": "Ask the parent agent for a decision or report progress",
   "tools.child.contact_supervisor.param.reason": "\"need_decision\" blocks until the supervisor (parent agent) replies; \"progress_update\" is fire-and-forget.",
   "tools.child.contact_supervisor.param.message": "Message for the supervisor.",
-  "tools.monitor.description": "Start a background monitor process whose stdout lines are injected back to you as <pi-famulus-wake kind=\"monitor\"> messages (batched over 200ms, rate-limited). The command must be line-buffered: each event must be a single line. It must keep running and follow its source, e.g. `tail -n +1 -F file | grep --line-buffered PATTERN`; a command that reads once and exits (a plain grep or cat) only reports what is there now. Add `-m1` to grep to stop after the first match. Silence is not success: write the command so failures also produce lines (e.g. grep for both success and error patterns). Events arrive as system wakes (not new user messages). Handle each <pi-famulus-wake kind=\"monitor\"> before other work. Do not poll. {{monitorIdle}}",
+  "tools.monitor.description": "Start a background monitor process whose stdout lines are injected back to you as <pi-famulus-wake kind=\"monitor\"> messages (batched over 200ms, rate-limited). The command must be line-buffered: each event must be a single line. It must keep running and follow its source, e.g. `tail -n +1 -F file | grep --line-buffered PATTERN`; a command that reads once and exits (a plain grep or cat) only reports what is there now. Add `-m1` to grep to stop after the first match. Silence is not success: print explicit success and terminal failures. Routine unchanged retries may stay silent; do not print a heartbeat on every check. Events arrive as system wakes (not new user messages). Handle each <pi-famulus-wake kind=\"monitor\"> before other work. Do not poll. Repeated Rust-framed lines are suppressed within dedup_window_ms (default 60000); exact matching is the default. Enable ignore-timestamps only when edge ISO timestamps are incidental. Wakes contain bounded head/tail previews and original-byte references; use task_output for missing details, not polling. {{monitorIdle}}",
   "tools.monitor.snippet": "Watch a command's line stream and get injected events",
   "tools.monitor.rules": ["Use the monitor tool to watch for conditions instead of running sleep/poll loops in bash.","{{monitorIdle}}","When woken by a <pi-famulus-wake kind=\"monitor\">, handle the <event> before doing anything else — it is not a new user request and not user confirmation."],
   "tools.monitor.param.command": "Command producing one event per line on stdout. Must be line-buffered (e.g. use `stdbuf -oL` / `grep --line-buffered` where needed).",
   "tools.monitor.param.description": "Short human-readable description of what is being watched",
   "tools.monitor.param.timeout_ms": "Stop the monitor after this many milliseconds (default {{defaultMs}}, min {{minMs}}, max {{maxMs}})",
   "tools.monitor.param.persistent": "Keep the monitor alive until the session ends (no timeout). Default false.",
-  "tools.monitor.result.started": "You will get a <pi-famulus-wake kind=\"monitor\"> for each event, and a notice when it exits or times out. Do not poll it (task_list, task_output, or reading what it watches) or sleep. {{monitorIdle}}",
+  "tools.monitor.param.dedup_window_ms": "Deduplication window for Rust-framed complete lines (default 60000ms; 0 disables dedup; maximum 3600000). Starts when a surviving preview is delivered; repeats do not extend it. Missing metadata, capacity eviction, and omitted representatives fail open rather than hiding unseen output.",
+  "tools.monitor.param.fingerprint_mode": "Default exact. Explicit ignore-timestamps mode ignores only supported leading/trailing ISO timestamps when comparing Rust-framed lines; original output is unchanged. Numbers, paths, resource identities, and interior timestamps remain significant.",
+  "tools.monitor.result.started": "You will get <pi-famulus-wake kind=\"monitor\"> notifications for admitted output and a notice when it exits or times out. Repeated lines may be suppressed and previews may be truncated; original output remains available through task_output byte ranges while the task log is retained. Read details only when needed; do not repeatedly poll task_list, task_output, or the watched source, and do not sleep to wait. {{monitorIdle}}",
   "tools.subagent.description": "Run subagents in parallel (tasks) or sequentially (chain with {previous}/{outputs.<label>} interpolation). By default the call waits up to a foreground budget (default 45s); longer runs continue in the background. Each child that finishes while others are still running wakes you with <pi-famulus-wake kind=\"subagent-handover\"> (its prompt and result). The whole run wakes you with <pi-famulus-wake kind=\"subagent-done\">. Never poll or sleep to wait. A subagent still running past its timeout_ms is not stopped; it wakes you with <pi-famulus-wake kind=\"subagent-overrun\"> so you can extend, steer, or interrupt it. Use action=list/get/status/interrupt/resume/steer/extend to manage existing runs.",
   "tools.subagent.snippet": "Fan out subagents in parallel or sequence them in a chain",
   "tools.subagent.rules": ["When a <pi-famulus-wake kind=\"subagent-handover\"> arrives, read <prompt> and <result> immediately and continue: subagent({action:\"resume\", run_id, child_id, message}) for that child, or agent_message to steer children that are still running. Do not wait for the rest of the run.","Subagent runs that exceed the foreground budget continue in the background; you are notified per finished child and again when the run completes — do not poll.","A failed subagent does not fail the whole run; inspect per-subagent sections in the result.","<pi-famulus-wake> is a system wake, not a user reply. kind=subagent-handover is one child; kind=subagent-done is the whole run."],
@@ -72,17 +74,18 @@ export const PROMPTS = {
   "tools.task_list.snippet": "List background shell/monitor tasks and subagents",
   "tools.task_list.param.all": "Also include finished work (default: running only). Always limited to this session.",
   "tools.task_list.hint.running": "Running work wakes you with a <pi-famulus-wake> when it finishes. Reply to the user now with no tool call instead of checking again.",
-  "tools.task_output.description": "Read output of a background task. Without a cursor, returns the tail of the output plus the current file pointer; pass the returned next_cursor as cursor for incremental reads. Not a way to wait: a running task wakes you when it finishes, so reply with no tool call instead of calling this again.",
+  "tools.task_output.description": "Read original output of a background task, including a monitor's truncated or deduplicated output. Without a cursor, returns the tail plus the current file pointer; pass next_cursor as cursor to page forward. Use small max_bytes ranges for details. Reading a different range is allowed; while a task is running, recently read ranges may be rejected if the output size is unchanged. This is not a way to wait: when no further details are needed, end your turn with no tool call and resume on the next notification.",
   "tools.task_output.snippet": "Read background task output",
   "tools.task_output.param.task_id": "Task id, e.g. sh_a1b2c3d4",
   "tools.task_output.param.cursor": "Byte offset to read from (for incremental reads). Omit to read the tail of the output.",
-  "tools.task_output.param.max_bytes": "Maximum bytes to return (default 65536)",
-  "tools.task_output.hint.still-running": "The task is still running. Reply to the user now with no tool call; a <pi-famulus-wake> arrives when it finishes.",
+  "tools.task_output.param.max_bytes": "Maximum bytes to return (default 65536, capped at 1048576); use a smaller range to avoid flooding context. Zero selects the default.",
+  "tools.task_output.hint.still-running": "The task is still running. Read another byte range only if details are needed; otherwise end your turn with no tool call. Do not repeatedly check for progress; a <pi-famulus-wake> arrives when it finishes.",
   "tools.task_output.error.no-new-output": "No new output from {{taskId}} since your last read. {{hint}}",
   "tools.task_stop.description": "Stop a running background task (SIGTERM to the process group, SIGKILL after a 2s grace).",
   "tools.task_stop.snippet": "Stop a background task",
   "tools.task_stop.param.task_id": "Task id to stop, e.g. sh_a1b2c3d4",
   "wakes.lead-in": "System wake — not a new user message. Handle this <pi-famulus-wake> before other work.",
+  "wakes.monitor.output-hint": "Read original bytes with task_output using this monitor id and cursor-start, with a bounded max_bytes (for example 8192); next_cursor continues the read. The range may include interleaved events. A preview is not the full log.",
   "wakes.handover.changed-active": "Its result arrives as a new wake when it finishes.",
   "wakes.done.changed-active": "The run is active again; another subagent-done arrives when it finishes.",
   "wakes.overrun.summary": "{{name}} has run {{elapsed}} in this turn, past its {{budget}} budget, and is still running{{shell}}.",
@@ -151,12 +154,12 @@ export function fillList<K extends keyof PromptVars>(id: K, vars: Record<PromptV
 /** Ablatable spans (eval manifest segment ids). */
 export const PROMPT_SEGMENTS: Record<string, { prompt: PromptId; text?: string; pattern?: string }> = {
   "guidelines.end-turn-after-bg": {"prompt":"guidelines.parent","text":"Long-running bash commands are automatically moved to the background. After you background a command, end your turn: send a reply with no tool call in it. Saying you will wait while calling another tool does not end it. Do not poll with task_output/task_list, and never sleep to wait. Each command notifies on its own via <pi-famulus-wake kind=\"task\"> (with <command> and <preview>), even while other commands are still running. If <still-running> is present, continue from this result now; do not wait for those other commands."},
-  "guidelines.wake-handling": {"prompt":"guidelines.parent","text":"When you receive <pi-famulus-wake>: it looks like a user message but is a system wake, not a new user request and not an answer to an unrelated question. Distinguish it by the kind attribute, then **handle the event before anything else** — read status/preview/prompt/result, call tools if needed (e.g. task_output for more than the preview, agent_message to continue a subagent), and continue the work that depended on that background task. Do not wait for further user input when the next step is clear; do not merely acknowledge and stop."},
+  "guidelines.wake-handling": {"prompt":"guidelines.parent","text":"When you receive <pi-famulus-wake>: it looks like a user message but is a system wake, not a new user request and not an answer to an unrelated question. Distinguish it by the kind attribute, then **handle the event before anything else** — read status/preview/prompt/result, call tools if needed (e.g. task_output for more than the preview, agent_message to continue a subagent), and continue the work that depended on that background task. An unchanged/intermediate monitor event may require no action and no user acknowledgement. Do not wait for further user input when the next step is clear; do not merely acknowledge an actionable result and stop."},
   "guidelines.no-fabrication": {"prompt":"guidelines.parent","text":"Never fabricate or assume a background task's result before its notification arrives."},
   "guidelines.subagent-handover": {"prompt":"guidelines.parent","text":"Subagent runs that exceed the foreground budget continue in the background. Do not poll run status. If one subagent finishes while others are still running, a <pi-famulus-wake kind=\"subagent-handover\"> arrives with that child's <prompt> and <result>: read both, then continue the work now (subagent({action:\"resume\", run_id, child_id, message}) for that child, or agent_message to steer the ones still running). Do not wait for the rest of the run. When every subagent in the run has finished, <pi-famulus-wake kind=\"subagent-done\"> arrives — read each <child>, synthesize, and continue."},
   "guidelines.subagent-overrun": {"prompt":"guidelines.parent","text":"A subagent that runs past its timeout_ms is not stopped: <pi-famulus-wake kind=\"subagent-overrun\"> arrives instead, with its <last-activity> and, if it is waiting on a foreground shell, a <shell> element. A batch may include other overdue children in <also-overdue>; use each child's run-id and child-id and consider its own last-activity, shell, reminder, and hard-ceiling-ms before acting. Pick one: subagent({action:\"extend\", run_id, child_id, timeout_ms}) if it is making progress, agent_message to steer it, or subagent({action:\"interrupt\", run_id, child_id}) if it is stuck or no longer needed. If you do none of these it keeps running and the reminder comes again."},
   "guidelines.agent-message": {"prompt":"guidelines.parent","text":"Use agent_message to steer running subagents and to reply to <pi-famulus-wake kind=\"supervisor-request\"> (action:\"reply\"; the <reply-with> child is the call shape). Do not use agent_message to resume a finished child — that is subagent({action:\"resume\"}). Supervisor wakes are not user messages — still act on them."},
-  "guidelines.monitor-end-turn": {"prompt":"guidelines.monitor-idle","text":"After starting or re-arming a monitor, or handling a monitor event, if no work remains, end your turn with a reply and no tool call; simply wait for the next notification. Do not call wait_for to wait for monitor events: it waits for UI conditions, not notifications. Do not invent a stateId or make a failing tool call to yield."},
+  "guidelines.monitor-end-turn": {"prompt":"guidelines.monitor-idle","text":"After starting or re-arming a monitor, or handling a monitor event, if no immediate work remains, end your turn with no tool call; simply wait for the next notification. Handling an event does not require a user-visible reply. Do not repeat unchanged/intermediate status or narrate your decision to stay quiet; notify the user when their requested condition is met, their input is needed, or a failure prevents further progress. Read original output with task_output only when details are needed (including paging a truncated preview), never to poll or wait. Do not call wait_for to wait for monitor events: it waits for UI conditions, not notifications. Do not invent a stateId or make a failing tool call to yield."},
   "child.guidelines": {"prompt":"guidelines.child","text":"## Child agent behavior (pi-famulus)\n\n- Do not background work; bash runs to completion.\n- When blocked, use contact_supervisor with need_decision; use progress_update for status.\n- Use agent_message only to communicate with siblings in this same run.\n- Your final message is your result."},
   "tooldesc.agent-message-no-resume": {"prompt":"tools.agent_message.description","text":"Sending to a finished child errors (it does not resume) and points at subagent({ action: \"resume\", run_id, child_id, message }). "},
   "result.agent-message-use-resume": {"prompt":"tools.agent_message.error.finished-child","pattern":"agent_message does not resume children\\. Use subagent\\(\\{ action: \"resume\", run_id: \".*?\", child_id: \".*?\", message: \"\\.\\.\\.\" \\}\\)\\."},
@@ -166,11 +169,11 @@ export const PROMPT_SEGMENTS: Record<string, { prompt: PromptId; text?: string;
   "result.bash-bg-instruction": {"prompt":"tools.bash.result.backgrounded","text":"\nYou will be notified when it completes, even if other commands are still running. Do not poll or sleep: reply to the user now with no tool call, and continue from the <pi-famulus-wake kind=\"task\"> when it arrives."},
   "result.sleep-block-advice": {"prompt":"tools.bash.error.bare-sleep","text":" Do not sleep to wait for background work; completion is delivered via notification. Use the monitor tool to watch for a condition, or run_in_background for long commands."},
   "tooldesc.monitor-follow": {"prompt":"tools.monitor.description","text":"It must keep running and follow its source, e.g. `tail -n +1 -F file | grep --line-buffered PATTERN`; a command that reads once and exits (a plain grep or cat) only reports what is there now. Add `-m1` to grep to stop after the first match. "},
-  "tooldesc.monitor-silence": {"prompt":"tools.monitor.description","text":"Silence is not success: write the command so failures also produce lines (e.g. grep for both success and error patterns). "},
+  "tooldesc.monitor-silence": {"prompt":"tools.monitor.description","text":"Silence is not success: print explicit success and terminal failures. Routine unchanged retries may stay silent; do not print a heartbeat on every check. "},
   "tooldesc.monitor-wake": {"prompt":"tools.monitor.description","text":"Events arrive as system wakes (not new user messages). Handle each <pi-famulus-wake kind=\"monitor\"> before other work. Do not poll."},
   "rules.monitor-use": {"prompt":"tools.monitor.rules","text":"Use the monitor tool to watch for conditions instead of running sleep/poll loops in bash."},
   "rules.monitor-wake": {"prompt":"tools.monitor.rules","text":"When woken by a <pi-famulus-wake kind=\"monitor\">, handle the <event> before doing anything else — it is not a new user request and not user confirmation."},
-  "result.monitor-started-instruction": {"prompt":"tools.monitor.result.started","text":"You will get a <pi-famulus-wake kind=\"monitor\"> for each event, and a notice when it exits or times out. Do not poll it (task_list, task_output, or reading what it watches) or sleep."},
+  "result.monitor-started-instruction": {"prompt":"tools.monitor.result.started","text":"You will get <pi-famulus-wake kind=\"monitor\"> notifications for admitted output and a notice when it exits or times out. Repeated lines may be suppressed and previews may be truncated; original output remains available through task_output byte ranges while the task log is retained. Read details only when needed; do not repeatedly poll task_list, task_output, or the watched source, and do not sleep to wait."},
   "tooldesc.subagent-wakes": {"prompt":"tools.subagent.description","text":"Each child that finishes while others are still running wakes you with <pi-famulus-wake kind=\"subagent-handover\"> (its prompt and result). The whole run wakes you with <pi-famulus-wake kind=\"subagent-done\">. Never poll or sleep to wait. "},
   "tooldesc.subagent-overrun": {"prompt":"tools.subagent.description","text":"A subagent still running past its timeout_ms is not stopped; it wakes you with <pi-famulus-wake kind=\"subagent-overrun\"> so you can extend, steer, or interrupt it. "},
   "rules.subagent-handover": {"prompt":"tools.subagent.rules","text":"When a <pi-famulus-wake kind=\"subagent-handover\"> arrives, read <prompt> and <result> immediately and continue: subagent({action:\"resume\", run_id, child_id, message}) for that child, or agent_message to steer children that are still running. Do not wait for the rest of the run."},

package/src/shell-exec.ts

@@ -3,6 +3,7 @@
  * Previously copied in both files.
  */
 import type { BashToolDetails } from "@earendil-works/pi-coding-agent";
+import { shellStartStatus } from "./shell-start";
 import { truncateTail } from "./format";
 import type { ManagerClient } from "./manager-client";
 import { fill } from "./prompts.generated";
@@ -134,9 +135,34 @@ export function appendStatus(text: string, status: string): string {
  * kill for a command still running (eval batch 4).
  */
 export async function killedStatus(client: ManagerClient, taskId: string, timeoutSeconds: number | undefined): Promise<string> {
-  const record = (await client.list(true).catch(() => [])).find((t) => t.task_id === taskId);
+  const record = await taskRecord(client, taskId);
   if (record?.end_reason === "timeout" && timeoutSeconds !== undefined) return timedOutStatus(timeoutSeconds);
-  return killedBy(record?.signal);
+  return shellStartStatus(record?.end_reason) ?? killedBy(record?.signal);
+}
+
+/**
+ * Status line for a non-zero exit. On Windows the manager marks a Git Bash
+ * that crashed while starting (shell-start-failed); elsewhere that cannot
+ * happen, so skip the record lookup.
+ */
+export async function exitedStatus(
+  client: ManagerClient,
+  taskId: string,
+  exitCode: number,
+  platform: NodeJS.Platform = process.platform,
+): Promise<string> {
+  const plain = `Command exited with code ${exitCode}`;
+  if (platform !== "win32") return plain;
+  const hint = shellStartStatus((await taskRecord(client, taskId))?.end_reason);
+  return hint ? `${hint} (exit code ${exitCode})` : plain;
+}
+
+async function taskRecord(client: ManagerClient, taskId: string) {
+  try {
+    return (await client.list(true)).find((t) => t.task_id === taskId);
+  } catch {
+    return undefined;
+  }
 }
 
 /** The one wording of a timeout kill, on every bash path. */

package/src/shell-start.ts

@@ -0,0 +1,25 @@
+/**
+ * Windows Git Bash start-up failures (manager end_reasons, see
+ * manager/src/shellstart.rs). Concurrent MSYS cold starts race while building
+ * the shared mount table (git-for-windows/git#6368). These reasons are
+ * inferred: a nested shell can print the same fatal text after the command
+ * has already had side effects, and a silent builtin-only command looks like
+ * a hung start. Say that, and do not tell the model the command did not run.
+ */
+export const SHELL_START_FAILED = "shell-start-failed";
+export const SHELL_START_HUNG = "shell-start-hung";
+
+/** The status line for a shell start-up failure, or undefined. */
+export function shellStartStatus(endReason: string | undefined): string | undefined {
+  if (endReason === SHELL_START_FAILED) {
+    return "Git Bash reported a Windows runtime startup failure; the command may have partially run. Check for side effects before retrying.";
+  }
+  if (endReason === SHELL_START_HUNG) {
+    return (
+      "Git Bash showed no output and only the shell process for 20s, so it was killed. " +
+      "This is usually a hung start, but a silent builtin-only command looks the same and may have been running. " +
+      "Check for side effects before retrying."
+    );
+  }
+  return undefined;
+}

package/src/subagent/child-bash.ts

@@ -32,6 +32,7 @@ import {
   bareSleepError,
   collectOutput,
   formatFinishedOutput,
+  exitedStatus,
   killedStatus,
   timedOutStatus,
   SHELL_MAX_BYTES,
@@ -172,7 +173,7 @@ export function createChildBashTool(
         const { text, details } = formatFinishedOutput(collected, outputPath);
         const exitCode = waitResult.exit_code ?? null;
         if (exitCode !== 0 && exitCode !== null) {
-          throw new Error(appendStatus(text, `Command exited with code ${exitCode}`));
+          throw new Error(appendStatus(text, await exitedStatus(client, start.task_id, exitCode)));
         }
         // No exit code: killed (timeout, stop, crash), unless the manager
         // finished it as completed with its runner status unobservable.

package/src/subagent/conversation.ts

@@ -7,6 +7,7 @@ import type { ConversationTurn } from "./types";
 interface LooseBlock {
   type?: string;
   text?: string;
+  thinking?: string;
   name?: string;
   arguments?: unknown;
 }
@@ -21,7 +22,8 @@ interface LooseMessage {
 }
 
 function blockText(block: LooseBlock): string {
-  if (block.type === "text" || block.type === "thinking") return block.text ?? "";
+  if (block.type === "thinking") return block.thinking ?? block.text ?? "";
+  if (block.type === "text") return block.text ?? "";
   if (block.type === "toolCall") {
     const args = block.arguments === undefined ? "" : ` ${JSON.stringify(block.arguments)}`;
     return `tool ${block.name ?? "?"}${args}`;
@@ -45,32 +47,75 @@ function contentText(content: unknown): string {
     .join("\n");
 }
 
+function emitAssistantBlocks(message: LooseMessage, turns: ConversationTurn[]): void {
+  if (!Array.isArray(message.content)) {
+    const text = contentText(message.content);
+    if (text) turns.push({ role: message.role ?? "message", text });
+    return;
+  }
+  let thinking = "";
+  let text = "";
+  const flushThinking = () => {
+    const t = thinking.trim();
+    if (t) turns.push({ role: "thinking", text: t });
+    thinking = "";
+  };
+  const flushText = () => {
+    const t = text.trim();
+    if (t) turns.push({ role: message.role ?? "assistant", text: t });
+    text = "";
+  };
+  for (const raw of message.content) {
+    const block = raw && typeof raw === "object" ? (raw as LooseBlock) : null;
+    if (!block?.type) continue;
+    if (block.type === "thinking") {
+      flushText();
+      const part = (block.thinking ?? block.text ?? "").trim();
+      if (part) thinking = thinking ? `${thinking}\n\n${part}` : part;
+      continue;
+    }
+    if (block.type === "toolCall") {
+      flushThinking();
+      flushText();
+      const part = blockText(block);
+      if (part) turns.push({ role: message.role ?? "assistant", text: part });
+      continue;
+    }
+    if (block.type === "text") {
+      flushThinking();
+      const part = block.text ?? "";
+      if (part) text = text ? `${text}\n${part}` : part;
+    }
+  }
+  flushThinking();
+  flushText();
+}
+
 export function turnsFromMessages(messages: readonly LooseMessage[]): ConversationTurn[] {
   const turns: ConversationTurn[] = [];
   let firstUserTurn = true;
   for (const message of messages) {
     if (message.role === "system") continue;
-    const rawText = contentText(message.content);
-    const text = message.role === "user" && firstUserTurn ? visibleUserText(rawText) : rawText;
-    if (message.role === "user") firstUserTurn = false;
     if (message.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted")) {
       // A failed model call often has no text; its error is the only record of what happened.
+      const text = contentText(message.content);
       if (text) turns.push({ role: "assistant", text });
       turns.push({ role: "assistant error", text: message.errorMessage?.trim() || `model stopped: ${message.stopReason}` });
       continue;
     }
-    if (!text) continue;
     if (message.role === "toolResult") {
       const name = message.toolName ?? "tool";
-      turns.push({ role: message.isError ? `tool ${name} error` : `tool ${name}`, text });
+      turns.push({ role: message.isError ? `tool ${name} error` : `tool ${name}`, text: contentText(message.content) });
+      continue;
+    }
+    if (message.role === "user") {
+      const rawText = contentText(message.content);
+      const text = firstUserTurn ? visibleUserText(rawText) : rawText;
+      firstUserTurn = false;
+      if (text) turns.push({ role: "user", text });
       continue;
     }
-    turns.push({ role: message.role ?? "message", text });
+    emitAssistantBlocks(message, turns);
   }
   return turns;
 }
-
-export function formatConversation(turns: readonly ConversationTurn[]): string {
-  if (turns.length === 0) return "(no messages yet)";
-  return turns.map((turn) => `── ${turn.role} ──\n${turn.text}`).join("\n\n");
-}

package/src/subagent/fleet-widget.ts

@@ -1,16 +1,17 @@
 /**
- * Passive fleet summary below the editor — counts only, no keyboard hooks.
+ * Passive fleet line below the editor — live work only, no keyboard hooks.
  *
- * Format: `2 workers · 1 subagent · 1 monitor`
- *   workers   = backgrounded shell tasks (not sync-waited)
- *   subagents = in-process subagent children
- *   monitors  = active monitors
+ * Format: `● 2 shells · 1 monitor · scout 12s   /tasks`
+ *   shells   = backgrounded shell tasks (not sync-waited)
+ *   monitors = active monitors
+ *   then each running subagent by name with its age
  *
  * Driven by WorkIndex changes. Does not poll the manager.
  */
 import { realClock, type Clock, type ClockTimer } from "../clock";
 import { formatAge, nextAgeBoundary, type WorkIndex, type WorkItem } from "../work-index";
 import { truncateToWidth } from "../tui/pi-tui-load";
+import { statusGlyph } from "../tui/tool-component";
 
 export const FLEET_WIDGET_KEY = "pi-famulus-fleet";
 
@@ -207,10 +208,9 @@ export class FleetWidget {
       parts.push(`${name} ${theme.fg("dim", formatAge(item.startedAt, item.endedAt, now))}`);
     }
     if (parts.length === 0) return [];
-    const line = `  ${theme.fg("accent", "●")} ${parts.join(theme.fg("dim", " · "))}   ${theme.fg("dim", "/tasks")}`;
+    const live = statusGlyph("running");
+    const line = `  ${theme.fg(live.color, live.glyph)} ${parts.join(theme.fg("dim", " · "))}   ${theme.fg("dim", "/tasks")}`;
     return [truncateToWidth(line, Math.max(1, width), "…")];
   }
 }
 
-/** @deprecated Use FleetWidget — kept as alias for older imports. */
-export { FleetWidget as FleetStatus };

package/src/subagent/runner.ts

@@ -16,7 +16,7 @@
  *   the next one. See design.md §4.6 "Child lifecycle".
  * - `hardTimeoutMs` (opt-in, default off) is the abort ceiling per turn:
  *   abort -> result {status:"interrupted", error:"timeout"};
- * - a stall watchdog aborts the child after `stallMs` (default 10min) without
+ * - a stall watchdog aborts the child after `stallMs` (default 5min) without
  *   any session event. A stall is treated as transient (a silently dropped
  *   provider stream): the child is aborted and auto-resumed on the SAME
  *   session with a continuation prompt, up to `stallRetries` times
@@ -79,7 +79,7 @@ export interface AdmissionTicket {
 
 export interface InProcessRunnerOptions {
   createSession: CreateSessionFn;
-  /** Stall watchdog timeout (ms). Default 10 minutes. */
+  /** Stall watchdog timeout (ms). Default 5 minutes. */
   stallMs?: number;
   /** Auto-resume attempts after a stall. Default 1; 0 settles stalled at once. */
   stallRetries?: number;

package/src/subagent/tool.ts

@@ -21,6 +21,7 @@ import { realClock, type Clock, type ClockTimer } from "../clock";
 
 import type { NotifyCenter } from "../notify";
 import { statusGlyph, toolComponent } from "../tui/tool-component";
+import { scrubTty } from "../tui/conversation-view";
 import type { WorkIndex } from "../work-index";
 import { fill, PROMPTS } from "../prompts.generated";
 import { runChain, runTasks, validateChainSteps } from "./pool";
@@ -706,7 +707,7 @@ export function createSubagentTool(
         .filter((c): c is { type: "text"; text: string } => c.type === "text")
         .map((c) => c.text)
         .join("\n");
-      const all = text.split("\n");
+      const all = scrubTty(text).split("\n");
       const shown = expanded ? all : all.slice(0, 10);
       const out = shown.map((l) => theme.fg("toolOutput", l));
       if (shown.length < all.length) out.push(theme.fg("muted", `... (${all.length - shown.length} more lines, ctrl+o to expand)`));

package/src/task-tools.ts

@@ -5,6 +5,7 @@ import { Type } from "typebox";
 import { realClock, type Clock } from "./clock";
 import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { ManagerClient, TaskRecord } from "./manager-client";
+import { fnv1a64 } from "./config";
 import { fill, PROMPTS } from "./prompts.generated";
 import {
   formatAgentCommand,
@@ -196,19 +197,32 @@ export interface TaskOutputDetails {
 }
 
 const DEFAULT_OUTPUT_BYTES = 65536;
+// manager/src/daemon.rs MAX_OUTPUT_READ: clamp before selecting a tail window.
+const MAX_OUTPUT_BYTES = 1024 * 1024;
 
 export function createTaskOutputTool(
   deps: TaskToolsDeps,
 ): ToolDefinition<typeof taskOutputParameters, TaskOutputDetails> {
-  // total_size at the last read of each running task. A repeat read that finds
-  // the same size is polling: the prompt forbids it, but models still loop.
-  const lastRunningSize = new Map<string, number>();
-  const guardPoll = (id: string, running: boolean, size: number) => {
-    if (running && lastRunningSize.get(id) === size) {
+  // Reading another page is retrieval, not polling. Remember actual returned
+  // ranges so tail/explicit reads (or different limits hitting EOF) agree.
+  // Bound both task and range histories for long-lived extension sessions.
+  const runningReads = new Map<string, { size: number; ranges: Set<string> }>();
+  const guardPoll = (id: string, running: boolean, size: number, start: number, end: number, identity = "") => {
+    if (!running) {
+      runningReads.delete(id);
+      return;
+    }
+    const previous = runningReads.get(id);
+    const entry = previous?.size === size ? previous : { size, ranges: new Set<string>() };
+    const range = `${start === end ? "empty" : `${start}:${end}`}:${identity}`;
+    if (entry.ranges.has(range)) {
       throw new Error(fill("tools.task_output.error.no-new-output", { taskId: id, hint: END_TURN_HINT }));
     }
-    if (running) lastRunningSize.set(id, size);
-    else lastRunningSize.delete(id);
+    entry.ranges.add(range);
+    if (entry.ranges.size > 256) entry.ranges.delete(entry.ranges.values().next().value!);
+    runningReads.delete(id);
+    runningReads.set(id, entry);
+    if (runningReads.size > 128) runningReads.delete(runningReads.keys().next().value!);
   };
   return {
     name: "task_output",
@@ -217,11 +231,19 @@ export function createTaskOutputTool(
     promptSnippet: PROMPTS["tools.task_output.snippet"],
     parameters: taskOutputParameters,
     async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      for (const field of ["cursor", "max_bytes"] as const) {
+        const value = params[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+          throw new TypeError(`${field} must be a nonnegative safe integer`);
+        }
+      }
       const agentText = agentTextFor(deps, params.task_id);
       if (agentText !== undefined) {
         const status = deps.getIndex?.()?.get(params.task_id)?.status ?? "unknown";
         const running = status === "pending" || status === "running";
-        guardPoll(params.task_id, running, agentText.length);
+        // Length alone hides a same-length conversation rewrite. Hash the
+        // snapshot so a changed child transcript is a new range.
+        guardPoll(params.task_id, running, agentText.length, 0, agentText.length, fnv1a64(agentText));
         const body = (agentText || "(no output yet)") + (running ? `\n\n${END_TURN_HINT}` : "");
         return {
           content: [{ type: "text", text: body }],
@@ -236,10 +258,7 @@ export function createTaskOutputTool(
         };
       }
       const client = await requireClient(deps);
-      const maxBytes =
-        params.max_bytes !== undefined && params.max_bytes > 0
-          ? Math.floor(params.max_bytes)
-          : DEFAULT_OUTPUT_BYTES;
+      const maxBytes = Math.min(params.max_bytes || DEFAULT_OUTPUT_BYTES, MAX_OUTPUT_BYTES);
 
       let cursor = params.cursor;
       if (cursor === undefined) {
@@ -250,7 +269,7 @@ export function createTaskOutputTool(
 
       const res = await client.output(params.task_id, cursor, maxBytes);
       const running = res.status === "running";
-      guardPoll(params.task_id, running, res.total_size);
+      guardPoll(params.task_id, running, res.total_size, cursor, res.next_cursor);
       const details: TaskOutputDetails = {
         task_id: params.task_id,
         status: res.status,