pi-famulus 0.1.7 → 0.1.9

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,