pi-better-subagents 0.1.16 → 0.1.17

package/index.ts

@@ -96,6 +96,7 @@ import {
     WIDGET_CLEAR,
     fmtElapsed,
     fmtSpend,
+    fmtTokens,
     shortModel,
     isSpendCacheFresh,
     resolveHealthLogExtraction,
@@ -587,6 +588,8 @@ export function setIdentityProbeForTests(probe: ProcessProbe | undefined): void
 
 let unregisterSubagentProvider: (() => void) | undefined;
 const TERMINAL_NAVIGATOR_RETENTION_MS = 30_000;
+let mainAgentStartedAt: number | undefined;
+const mainAgentTools = new Map<string, string>();
 
 /**
  * Observe health for a navigator row/detail (#69). Reuses the size/mtime-gated
@@ -743,6 +746,37 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
     });
 }
 
+function mainAgentWorkRow(now: number): BackgroundWorkRow {
+    let running = mainAgentStartedAt !== undefined;
+    try { running ||= uiCtx?.isIdle() === false; } catch { /* use event state */ }
+    const model = shortModel(uiCtx?.model?.id);
+    const effort = uiCtx?.thinkingLevel;
+    const tool = [...mainAgentTools.values()].at(-1);
+    let contextTokens: number | null | undefined;
+    try { contextTokens = uiCtx?.getContextUsage()?.tokens; } catch { contextTokens = undefined; }
+    const tokens = typeof contextTokens === "number" ? `${fmtTokens(contextTokens)} tok` : undefined;
+    const bits = [
+        effort ? `${model} ${effort}` : model,
+        tool ? `tool ${tool}` : undefined,
+        tokens,
+    ].filter((bit): bit is string => Boolean(bit));
+    return {
+        providerId: "subagents",
+        id: "main",
+        name: "main",
+        model,
+        effort,
+        tool,
+        tokens,
+        status: running ? "running" : "idle",
+        statusTone: running ? "running" : "muted",
+        kind: "main agent",
+        elapsed: running && mainAgentStartedAt !== undefined ? fmtElapsed(now - mainAgentStartedAt) : "idle",
+        primary: bits.join(" · "),
+        sortStartedAt: mainAgentStartedAt ?? now,
+    };
+}
+
 function subagentWorkDetail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null {
     const detail = navigatorDetail(id, now);
     if (!detail) return null;
@@ -780,6 +814,7 @@ function ensureSubagentProvider(): void {
         label: "Subagents",
         priority: 10,
         visibleCount: () => navigatorRunningCount(),
+        parentRow: (now) => mainAgentWorkRow(now),
         listRows: (now) => subagentWorkRows(now),
         detail: (id, now, options) => subagentWorkDetail(id, now, options),
         armCloseLabel: (row) => row.status === "running" || row.status === "orphaned" ? "x again to stop" : "x again to dismiss",
@@ -1322,11 +1357,49 @@ export default function (pi: ExtensionAPI) {
     pi.registerTool(subagentStopTool(Type, { onStopped: renderWidget }));
 
     // ---- live-status lifecycle -----------------------------------------
+    pi.on("agent_start", async (_event, ctx) => {
+        uiCtx = ctx;
+        mainAgentStartedAt = Date.now();
+        mainAgentTools.clear();
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("tool_execution_start", async (event, ctx) => {
+        mainAgentTools.set(event.toolCallId, event.toolName);
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("tool_execution_end", async (event, ctx) => {
+        mainAgentTools.delete(event.toolCallId);
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("message_end", async (event, ctx) => {
+        if (event.message.role === "assistant") refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("model_select", async (_event, ctx) => {
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("thinking_level_select", async (_event, ctx) => {
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
+    pi.on("agent_settled", async (_event, ctx) => {
+        mainAgentStartedAt = undefined;
+        mainAgentTools.clear();
+        refreshBackgroundWorkNavigator(ctx);
+    });
+
     // Capture a UI-bearing context and, if runs from a prior session are still
     // alive, resume the ticking widget. Deferred out of the factory per pi's
     // "no background resources at load" rule.
     pi.on("session_start", async (_event, ctx) => {
         uiCtx = ctx;
+        try { mainAgentStartedAt = ctx.isIdle() ? undefined : Date.now(); }
+        catch { mainAgentStartedAt = undefined; }
+        mainAgentTools.clear();
         activeCallbackOrigin = callbackOriginFromContext(ctx);
         // Reload / session switch hardening (#48):
         // - Drop any leftover overlay timers/confirm state from a prior session
@@ -1359,6 +1432,8 @@ export default function (pi: ExtensionAPI) {
 
     pi.on("session_before_switch", () => {
         activeCallbackOrigin = undefined;
+        mainAgentStartedAt = undefined;
+        mainAgentTools.clear();
         disposeBackgroundWorkNavigator();
     });
 
@@ -1369,6 +1444,8 @@ export default function (pi: ExtensionAPI) {
         // cannot become live process groups with no coordinator.
         stopCurrentSessionSubagents(ctx);
         activeCallbackOrigin = undefined;
+        mainAgentStartedAt = undefined;
+        mainAgentTools.clear();
         stopTicker();
         stopHealthTicker();
         spendCache.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/shared-navigator.ts

@@ -54,6 +54,7 @@ export type BackgroundWorkProvider = {
   label: string;
   priority: number;
   visibleCount(): number;
+  parentRow?(now: number): BackgroundWorkRow | null;
   listRows(now: number): BackgroundWorkRow[];
   detail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null;
   armCloseLabel(row: BackgroundWorkRow): string;
@@ -411,6 +412,16 @@ function buildMainListLines(
     const group = grouped.get(label)!;
     if (i > 0) lines.push("");
     lines.push(providerGroupLabel(label, fg));
+    const provider = state().providers.get(group[0]!.providerId);
+    let parentRow: BackgroundWorkRow | null = null;
+    try { parentRow = provider?.parentRow?.(Date.now()) ?? null; } catch { parentRow = null; }
+    if (parentRow) {
+      lines.push(formatMainListRow({
+        ...parentRow,
+        navigatorId: rowKey(parentRow.providerId, parentRow.id),
+        providerLabel: label,
+      }, false, fg, width));
+    }
     for (const row of group) {
       const selected = options.focused && row.navigatorId === options.selectedId;
       lines.push(formatMainListRow(row, selected === true, fg, width));
@@ -976,7 +987,10 @@ function buildDetailLines(
   } else {
     const evidenceLabel = /log/i.test(detail.evidence.label) ? `${detail.evidence.label} · latest ${tailRows} rows` : detail.evidence.label;
     lines.push(dim(section(evidenceLabel, width), fg));
-    for (const raw of body.split(/\r?\n/)) lines.push(raw ? `   ${raw}` : "   ");
+    const wrapped = /log/i.test(detail.evidence.label)
+      ? wrapLogText(body, width - 6)
+      : body.split(/\r?\n/);
+    for (const raw of wrapped) lines.push(raw ? `   ${raw}` : "   ");
   }
   lines.push("");
   const footerLines = [dim(`   ← back · ${actions}`, fg), dim(rule("", width), fg)];
@@ -1042,6 +1056,82 @@ function wrapEvidenceText(text: string, width: number): string[] {
   return rows.length ? rows : ["(no output yet)"];
 }
 
+/**
+ * Wrap terminal log rows without flattening entries together. Continuations
+ * retain the source indentation, and long paths/JSON tokens are hard-wrapped
+ * so the final width guard never has to discard their suffix.
+ */
+export function wrapLogText(text: string, width: number): string[] {
+  const max = Math.max(8, Math.floor(width));
+  const rows: string[] = [];
+  for (const source of String(text ?? "").split(/\r?\n/)) {
+    if (!source) {
+      rows.push("");
+      continue;
+    }
+    const sourceIndent = source.match(/^[ \t]*/)?.[0] ?? "";
+    const indent = sourceIndent.replace(/\t/g, "  ");
+    let remaining = source.slice(sourceIndent.length);
+    const contentWidth = Math.max(1, max - visibleWidth(indent));
+    if (!remaining) {
+      rows.push(indent);
+      continue;
+    }
+    while (visibleWidth(remaining) > contentWidth) {
+      let [head, tail] = splitVisiblePrefix(remaining, contentWidth);
+      const minSoftBreak = Math.floor(contentWidth * 0.45);
+      const delimiterBreak = lastDelimiterBreak(head);
+      const whitespace = head.match(/\s+\S*$/)?.index;
+      if (delimiterBreak > minSoftBreak) {
+        tail = head.slice(delimiterBreak) + tail;
+        head = head.slice(0, delimiterBreak);
+      } else if (whitespace !== undefined && whitespace > minSoftBreak) {
+        tail = head.slice(whitespace).trimStart() + tail;
+        head = head.slice(0, whitespace).trimEnd();
+      }
+      rows.push(indent + head);
+      remaining = tail.trimStart();
+    }
+    rows.push(indent + remaining);
+  }
+  return rows.length ? rows : [""];
+}
+
+function lastDelimiterBreak(value: string): number {
+  let last = -1;
+  for (const match of value.matchAll(/[\/,}:]/g)) last = match.index + 1;
+  return last;
+}
+
+function splitVisiblePrefix(value: string, width: number): [string, string] {
+  const max = Math.max(0, Math.floor(width));
+  let visible = 0;
+  let index = 0;
+  while (index < value.length && visible < max) {
+    if (value[index] === "\u001b" || value[index] === "\u009b") {
+      const match = value.slice(index).match(ANSI_RE);
+      if (match?.index === 0) {
+        index += match[0].length;
+        continue;
+      }
+    }
+    if (value[index] === "<") {
+      const close = value.indexOf(">", index);
+      if (close !== -1) {
+        const tag = value.slice(index, close + 1);
+        if (/^<\/?[a-zA-Z][\w-]*>$/.test(tag) || tag === "</>") {
+          index = close + 1;
+          continue;
+        }
+      }
+    }
+    const codePoint = value.codePointAt(index)!;
+    index += codePoint > 0xFFFF ? 2 : 1;
+    visible += 1;
+  }
+  return [value.slice(0, index), value.slice(index)];
+}
+
 function cycleLogTailRows(current: number): number {
   const idx = LOG_TAIL_ROW_CHOICES.findIndex((value) => value === current);
   return LOG_TAIL_ROW_CHOICES[(idx + 1) % LOG_TAIL_ROW_CHOICES.length];