pi-daddy 0.27.3 → 0.28.0

package/src/dashboard-cli.ts

@@ -8,6 +8,7 @@ import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseDashboardLedger } from "./dashboard-projection.ts";
 import { renderDashboard } from "./dashboard-render.ts";
+import { defaultActivityTimelinePath, detailForTimeline, parseActivityTimeline, renderActivityTimeline, type TimelineFilter } from "./activity-timeline.ts";
 import { createDashboardDisplayControls } from "./dashboard-display-controls.ts";
 import { createDailyViewReader, isDailyViewReader, readDailyView, type DailyViewOptions } from "./daily-view.ts";
 import { renderDailyView } from "./daily-view-render.ts";
@@ -46,6 +47,8 @@ export interface DashboardFrameOptions {
   width?: number;
   details?: boolean;
   history?: boolean;
+  filter?: TimelineFilter;
+  activityDetail?: { taskKey: string; field: "prompt" | "final" };
   now?: Date;
   dailyView?: DailyViewOptions;
   dailyReader?: ReturnType<typeof createDailyViewReader>;
@@ -137,9 +140,24 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
       return "PI-DADDY — DAILY VIEW UNAVAILABLE\nInvalid or unavailable read-only input. No previous acceptance or continuity was substituted.";
     }
   }
-  if (!options.ledgerPath) return setupFrame(options.cwd);
+  // Timeline is the default local activity surface. Retain the existing setup frame until a real
+  // extension-owned timeline exists, so opening a plugin before Pi has run remains explanatory.
+  const configuredPath = options.ledgerPath ?? defaultActivityTimelinePath(options.cwd);
+  if (!options.ledgerPath) {
+    try {
+      const activityPath = resolve(options.cwd, configuredPath);
+      const activity = await readFile(activityPath, "utf8");
+      const timeline = parseActivityTimeline(activity);
+      let content: { taskKey: string; field: "prompt" | "final"; text: string } | undefined;
+      if (options.activityDetail) try { content = await detailForTimeline(activityPath, options.activityDetail.taskKey, options.activityDetail.field); } catch (error) { return `PI-DADDY — ACTIVITY DETAIL UNAVAILABLE\n${error instanceof Error ? error.message : String(error)}`; }
+      return renderActivityTimeline(timeline, { details: options.details, filter: options.filter, content });
+    } catch (error) {
+      if ((error as { code?: string }).code === "ENOENT") return setupFrame(options.cwd);
+      return "PI-DADDY — ACTIVITY UNAVAILABLE\nTimeline could not be read; no substitute view was shown.";
+    }
+  }
 
-  const ledgerPath = resolve(options.cwd, options.ledgerPath);
+  const ledgerPath = resolve(options.cwd, configuredPath);
   let text = "";
   let waiting = false;
   try {
@@ -157,7 +175,14 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
     }
   }
 
-  const rendered = renderDashboard(parseDashboardLedger(text, { now: options.now }), {
+  let timeline: string | undefined;
+  if (text.trimStart().startsWith('{"version":1')) {
+    const activity = parseActivityTimeline(text);
+    let content: { taskKey: string; field: "prompt" | "final"; text: string } | undefined;
+    if (options.activityDetail) try { content = await detailForTimeline(ledgerPath, options.activityDetail.taskKey, options.activityDetail.field); } catch (error) { return `PI-DADDY — ACTIVITY DETAIL UNAVAILABLE\n${error instanceof Error ? error.message : String(error)}`; }
+    timeline = renderActivityTimeline(activity, { details: options.details, filter: options.filter, content });
+  }
+  const rendered = timeline ?? renderDashboard(parseDashboardLedger(text, { now: options.now }), {
     color: options.color,
     width: options.width,
     details: options.details,
@@ -233,7 +258,7 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   }
   const dailyReader = createDailyViewReader();
   const actionMenu=createDashboardMenu();
-  const display = createDashboardDisplayControls(cli.details, Boolean(ledgerPath && !connected && !debrief && !cli.debriefJson && !dailyView));
+  const display = createDashboardDisplayControls(cli.details, Boolean(!connected && !debrief && !cli.debriefJson && !dailyView));
   let previous = "";
   let feedback = "";
   let input: ReturnType<typeof createInterface> | null = null;

package/src/dashboard-display-controls.ts

@@ -1,17 +1,20 @@
 /** Local display controls; these never dispatch actions to an owner or change ledger state. */
 export function createDashboardDisplayControls(details: boolean, ledger: boolean) {
-  const state = { details, history: false };
+  const state: { details: boolean; history: boolean; filter?: "everything" | "agents" | "skills" | "needs-you"; activityDetail?: { taskKey: string; field: "prompt" | "final" } } = { details, history: false, ...(ledger ? { filter: "everything" as const } : {}) };
   return {
     state,
     input(line: string): boolean {
-      const key = line.trim().toLowerCase();
+      const input = line.trim(), key = input.toLowerCase();
       if (key === "d") { state.details = !state.details; return true; }
       if (ledger && key === "h") { state.history = !state.history; return true; }
+      if (ledger && ["everything", "agents", "skills", "needs-you"].includes(key)) { state.filter = key as NonNullable<typeof state.filter>; return true; }
+      const detail = /^(p|f)\s+([^\s]{1,1400})$/i.exec(input);
+      if (ledger && detail) { state.activityDetail = { field: detail[1]!.toLowerCase() === "p" ? "prompt" : "final", taskKey: detail[2]! }; return true; }
       return false;
     },
     prompt(): string {
       return ledger
-        ? `d Details / h ${state.history ? "Collapse" : "Expand"} history, then Enter: `
+        ? `d Details / h ${state.history ? "Collapse" : "Expand"} history / Everything|Agents|Skills|Needs-you / p|f <root-id:task-id>, then Enter: `
         : "Action number / d Details, then Enter: ";
     },
   };

package/src/dashboard-handshake.ts

@@ -13,6 +13,7 @@ import {
 } from "./dashboard-herdr.ts";
 import { DASHBOARD_PROTOCOL_VERSION } from "./dashboard-cli.ts";
 import type { HerdrExec } from "./herdr-cli.ts";
+import { defaultActivityTimelinePath, parseActivityTimeline, renderActivityTimeline } from "./activity-timeline.ts";
 
 export type DashboardPromptChoice = "not-now" | "never";
 interface DashboardPreference {
@@ -87,7 +88,13 @@ export async function offerDashboardHandshake(input: DashboardHandshakeInput): P
     const preference = await loadPreference(input.preferencePath);
     if (preference) return "suppressed";
     const plugin = await inspectDashboardPlugin(exec, input.pluginRoot);
-    if (plugin.state === "compatible") return "already-installed";
+    // A compatible bundled panel is local software already chosen by the operator. Present it by default;
+    // pane identity makes this one panel per caller tab/session and --no-focus avoids focus theft.
+    if (plugin.state === "compatible") {
+      const opened = await openOrReuseDashboard({ exec, host: host.host, ledgerPath: input.ledgerPath ?? "", cwd: input.cwd, statePath: input.paneStatePath, pluginRoot: input.pluginRoot, allowInactive: true });
+      input.ui.notify(`pi-daddy dashboard ${opened.kind} in pane ${opened.paneId} without changing focus.`, "info");
+      return "already-installed";
+    }
     const replacingDifferentPackage = plugin.state === "incompatible" && plugin.incompatibility === "package-root";
     if (plugin.state !== "absent" && !replacingDifferentPackage) {
       input.ui.notify(`pi-daddy dashboard: ${plugin.diagnostic}`, "error");
@@ -157,21 +164,19 @@ export interface DashboardCommandInput {
   paneStatePath: string;
 }
 
-export async function openDashboardCommand(input: DashboardCommandInput): Promise<DashboardOpenResult> {
+export type DashboardCommandResult = DashboardOpenResult | { kind: "fallback"; frame: string; visibleBesideCaller: false };
+async function piFallback(cwd: string, reason: string): Promise<Extract<DashboardCommandResult, { kind: "fallback" }>> {
+  try { return { kind: "fallback", visibleBesideCaller: false, frame: `${reason}\n\n${renderActivityTimeline(parseActivityTimeline(await readFile(defaultActivityTimelinePath(cwd), "utf8")))}` }; }
+  catch { return { kind: "fallback", visibleBesideCaller: false, frame: `${reason}\n\nNo local activity recorded yet.` }; }
+}
+export async function openDashboardCommand(input: DashboardCommandInput): Promise<DashboardCommandResult> {
   const exec = input.exec ?? dashboardHerdrExec;
-  // Order is deliberate: a server elsewhere must not make an outside-pi command look hosted.
+  // A panel can only target this verified process; otherwise /grants dashboard renders the local Pi fallback.
   const host = await verifyHerdrHost({ env: input.env, pid: input.pid, exec });
-  if (!host.ok) throw new Error(host.diagnostic);
-  if (!input.ledgerPath?.trim()) {
-    throw new Error("no pi-daddy ledger is configured — set PI_GRANTS_LEDGER, then retry /grants dashboard");
-  }
+  if (!host.ok) return piFallback(input.cwd, `Herdr panel unavailable: ${host.diagnostic}`);
+  if (!input.ledgerPath?.trim()) return piFallback(input.cwd, "Herdr panel has no governance ledger; showing the local activity timeline.");
   const plugin = await inspectDashboardPlugin(exec, input.pluginRoot);
-  if (plugin.state === "absent") {
-    throw new Error(
-      `the pi-daddy Herdr plugin is not installed. Nothing was installed automatically. Run: ` +
-      `herdr plugin link ${quote(resolve(input.pluginRoot))} --enabled`,
-    );
-  }
+  if (plugin.state === "absent") return piFallback(input.cwd, `Herdr panel is not linked. Run: herdr plugin link ${quote(resolve(input.pluginRoot))} --enabled`);
   if (plugin.state === "disabled") {
     throw new Error(`the pi-daddy Herdr plugin is disabled. Run: herdr plugin enable ${DASHBOARD_PLUGIN_ID}`);
   }

package/src/delegate-types.ts

@@ -61,6 +61,10 @@ export interface DelegationContext {
   ledgerPath?: string;
   /** Path to this extension, so a child granted `tool:delegate` can delegate in turn. */
   extensionPath?: string;
+  /** No-tool activity observer injected only for governed leaf children. */
+  observerExtensionPath?: string;
+  /** Parent-owned local activity identity for this exact turn. */
+  activity?: { rootId: string; path: string; taskId?: string };
   /** Live capability catalog. When supplied, capabilities absent from it are refused as unknown. */
   catalog?: Catalog;
   /**

package/src/delegate.ts

@@ -34,6 +34,7 @@ import {
 import { resolveDelegationApproval } from "./delegation-approval.ts";
 import type { Delegation, DelegationContext, DelegationRequest } from "./delegate-types.ts";
 import { assertCapabilitiesArePropagatable } from "./capabilities.ts";
+import { ENV_ACTIVITY_PARENT_TASK, ENV_ACTIVITY_PATH, ENV_ACTIVITY_ROOT, ENV_ACTIVITY_TASK } from "./activity-timeline.ts";
 export type { Delegation, DelegationContext, DelegationRequest } from "./delegate-types.ts";
 
 export function planDelegation(request: DelegationRequest, ctx: DelegationContext): Delegation {
@@ -286,13 +287,11 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
     }, "DEFINITION_UNREADABLE");
   }
 
-  // A child may only delegate further if it was granted the capability AND has the extension to do it.
+  // `-e` loads even under `--no-extensions`. A delegate-capable child loads the governance extension;
+  // a leaf gets only the no-tool observer. Neither path alters --tools or the computed grant.
   const args = [...plan.args];
-  if (canSubDelegate && ctx.extensionPath) {
-    // `-e` loads even under `--no-extensions`, which planSpawn sets — that is precisely why the
-    // extension is added explicitly here and nowhere else.
-    args.splice(args.length - 1, 0, "-e", ctx.extensionPath);
-  }
+  const observer = canSubDelegate ? ctx.extensionPath : ctx.observerExtensionPath;
+  if (observer) args.splice(args.length - 1, 0, "-e", observer);
 
   // `inheritableGrant`, not `result.effective` directly: this is the path a DELEGATED child's grant
   // actually travels, and the "held but never inherited" rule for `tool:*` and `workspace:*` was enforced
@@ -322,6 +321,14 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
   // reason on the other path.
   env[ENV_APPROVED] = inheritApprovals(ctx.approved ?? [], inheritable).join(",");
   if (ctx.ledgerPath) env[ENV_LEDGER] = ctx.ledgerPath;
+  // These local observation values are per-child argv environment, never process-global grant state.
+  // A child cannot acquire a tool or a larger grant by receiving them.
+  if (ctx.activity?.taskId && ctx.childExecutionId) {
+    env[ENV_ACTIVITY_PATH] = ctx.activity.path;
+    env[ENV_ACTIVITY_ROOT] = ctx.activity.rootId;
+    env[ENV_ACTIVITY_TASK] = ctx.childExecutionId;
+    env[ENV_ACTIVITY_PARENT_TASK] = ctx.activity.taskId;
+  }
 
   return {
     ok: true,

package/src/herdr-name.ts

@@ -1,61 +1,21 @@
 /**
- * Naming a herdr agent: the grammar herdr enforces, and uniqueness it does not.
- *
- * Split out of `src/run-herdr.ts` at the 400-line ceiling, and a real seam: both rules below come from **herdr's
- * own validation and lifecycle**, not from anything this package decides. Two shipping defects lived here, and
- * both were invisible to every test because the unit fake accepts whatever name it is handed and the integration
- * suite never reaches a real herdr spawn. They surfaced from two real spawns against the live daemon.
+ * Herdr reserves agent names across all parents until their tabs close.
+ * A counter alone is process-local: parallel parents and module reloads repeat it.
+ * Keep the readable base separate from a fresh, 80-bit execution suffix.
  */
+import { randomBytes } from "node:crypto";
 
-/** Monotonic within this process. See `uniqueAgentName`. */
-let spawnSeq = 0;
-
-/**
- * herdr's agent-name grammar, measured from its own rejection message.
- *
- * `agent name must start with a lowercase letter and contain only lowercase letters, digits, '-' or '_'
- * (1-32 characters)`.
- */
 const AGENT_NAME_MAX = 32;
 
-/**
- * Make a herdr agent name that is **valid** and cannot collide with a live one.
- *
- * **Validity is a separate, PRE-EXISTING defect, and it is the more serious half.** Callers build a name as
- * `${definition}-${childId}`, and a ledger child id is hierarchical — `d0.1`, `d0.1.2` (ADR-0008/F8). Those dots
- * are **not in herdr's grammar**, so `agent start review-d0.1 …` is rejected with `invalid_agent_name`. Every
- * `delegate({agent})` on the herdr path has therefore failed at `agent start` since the executor was written.
- *
- * Nothing could see it. The unit fake accepts any name it is handed, and the integration suite never reaches a
- * real herdr spawn — so both were green while the feature could not work. It surfaced only by running two real
- * spawns against the live daemon, which is the argument for doing that at all.
- *
- * **Measured, and a shipping defect without it.** herdr binds an agent name to its **tab**, and only closing
- * the tab frees the name: a second `agent start` with a name still held returns
- * `agent_name_taken: agent <name> is already used; … tab_id=…`. `herdr agent stop` does not exist (see
- * `cleanup`), so nothing else releases it.
- *
- * Callers build a name from the definition and the ledger child id — and for a plain blocking `delegate` that
- * id is **constant** (`d0.1`, index 0 of the session), so every delegation in a session asked for the same
- * name. That was harmless while the pane closed at the end of each call. Once ADR-0032 kept panes alive to
- * `agent_settled`, the **first** delegation of a turn worked and every later one failed with
- * `agent_name_taken`, on the executor ADR-0031 had just made the default.
- *
- * Uniquified HERE rather than at the call site, so no caller can forget: the constraint belongs to herdr, and
- * this module is the only thing that talks to herdr. The suffix is a counter rather than a random token so a
- * pane label stays readable and reproducible within a run.
- */
+/** Valid Herdr identity independent of process counters, parent labels and reloads. */
 export function uniqueAgentName(base: string): string {
-  spawnSeq += 1;
-  const suffix = `-${spawnSeq}`;
+  const suffix = "-" + randomBytes(10).toString("hex");
   const cleaned = base
     .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, "-") // dots from a child id, and anything else outside the grammar
+    .replace(/[^a-z0-9_-]+/g, "-")
     .replace(/-{2,}/g, "-")
-    .replace(/^[^a-z]+/, ""); // must START with a lowercase letter, so a leading digit or dash goes
-  // Truncated so the whole name fits, and trimmed of a trailing separator so the join stays readable. The
-  // fallback covers a base that sanitises to nothing at all (a definition named entirely in non-Latin script).
+    .replace(/^[^a-z]+/, "");
   const room = AGENT_NAME_MAX - suffix.length;
   const head = cleaned.slice(0, room).replace(/[-_]+$/, "") || "agent";
-  return `${head}${suffix}`;
+  return head + suffix;
 }