pi-daddy 0.46.1 → 0.47.1

package/src/products/dashboard-display-controls.ts

@@ -1,4 +1,5 @@
 /** Local display controls; these never dispatch actions to an owner or change ledger state. */
+import { dashboardScreenState } from "./dashboard-screen.ts";
 import { ActivityTimelineAliases } from "./activity-timeline.ts";
 
 export function createDashboardDisplayControls(details: boolean, ledger: boolean) {
@@ -10,14 +11,63 @@ export function createDashboardDisplayControls(details: boolean, ledger: boolean
   } = { details, history: false, ...(ledger ? { filter: "everything" as const } : {}) };
   // Held by the panel process, so a refresh or a newly observed root cannot renumber an already displayed alias.
   const aliases = new ActivityTimelineAliases();
+  const screen = dashboardScreenState();
+  if (details) screen.view = "details";
   return {
     state,
+    screen,
+    key(key: string): "auto" | "quit" | "command" | undefined {
+      if (key === "a") return "auto";
+      if (key === "q" || key === "ctrl-c") return "quit";
+      if (key === ":") return "command";
+      if (key === "escape") {
+        screen.view = screen.view === "version-details" ? "versions" : "main";
+        state.activityDetail = undefined;
+        screen.offset = 0;
+      } else if (key === "?" || key === "m" || key === "v") {
+        screen.view = key === "?" ? "help" : key === "v" ? "versions" : "models";
+        state.activityDetail = undefined;
+        screen.offset = 0;
+      } else if (key === "return" || key === "d") {
+        screen.view = screen.view === "versions" ? "version-details" : "details";
+        screen.offset = 0;
+      } else if (["up", "down", "j", "k"].includes(key)) {
+        const delta = key === "up" || key === "k" ? -1 : 1;
+        if (screen.view === "versions") {
+          const rows = screen.versionRows ?? [],
+            index = rows.findIndex((row) => row.id === screen.versionId);
+          screen.versionId = rows[Math.max(0, Math.min(rows.length - 1, index + delta))]?.id;
+        } else if (screen.view !== "main") screen.offset = Math.max(0, screen.offset + delta);
+        else {
+          const index = Math.max(
+            0,
+            screen.items.findIndex((item) => item.key === screen.selectedKey),
+          );
+          screen.selectedKey = screen.items[Math.max(0, Math.min(screen.items.length - 1, index + delta))]?.key;
+          state.activityDetail = undefined;
+        }
+      } else if (key === "tab") {
+        const filters = ["everything", "agents", "skills", "needs-you"] as const;
+        state.filter = filters[(filters.indexOf(state.filter ?? "everything") + 1) % filters.length];
+        screen.view = "main";
+        state.activityDetail = undefined;
+      } else if (key === "p" || key === "f") {
+        const selected = screen.items.find((item) => item.key === screen.selectedKey);
+        if (selected?.taskKey) {
+          state.activityDetail = { taskKey: selected.taskKey, field: key === "p" ? "prompt" : "final" };
+          screen.view = "details";
+          screen.offset = 0;
+        }
+      } else if (key === "h") state.history = !state.history;
+      return undefined;
+    },
     aliases,
     input(line: string): boolean {
       const input = line.trim(),
         key = input.toLowerCase();
       if (key === "d") {
         state.details = !state.details;
+        screen.view = state.details ? "details" : "main";
         return true;
       }
       if (ledger && key === "h") {
@@ -30,6 +80,8 @@ export function createDashboardDisplayControls(details: boolean, ledger: boolean
       }
       const detail = /^(p|f)\s+([^\s]{1,1400})$/i.exec(input);
       if (ledger && detail) {
+        screen.view = "details";
+        screen.offset = 0;
         state.activityDetail = { field: detail[1]!.toLowerCase() === "p" ? "prompt" : "final", taskKey: detail[2]! };
         return true;
       }

package/src/products/dashboard-render.ts

@@ -38,11 +38,11 @@ const displayIdentifier = (value: string | undefined): string => (isLedgerDispla
 const ANSI_SGR = /\u001b\[[0-9;]*m/g;
 const WIDE_CELL = /\p{Extended_Pictographic}|[\u2E80-\u9FFF\uF900-\uFAFF]/u;
 
-function cellWidth(value: string): number {
+export function cellWidth(value: string): number {
   return [...value.replace(ANSI_SGR, "")].reduce((sum, char) => sum + (WIDE_CELL.test(char) ? 2 : 1), 0);
 }
 
-function truncate(value: string, width: number): string {
+export function truncate(value: string, width: number): string {
   if (cellWidth(value) <= width) return value;
   const target = Math.max(0, width - 1);
   let cells = 0;

package/src/products/dashboard-screen.ts

@@ -0,0 +1,339 @@
+/** Height-bounded, task-first view. Permission state is always supplied by the owner. */
+import type { EcosystemVersionRow } from "./ecosystem-versions.ts";
+import type { DashboardProjection } from "./dashboard-projection.ts";
+import { ActivityTimelineAliases, activityTaskKey, type ActivityTimeline } from "./activity-timeline.ts";
+import { cellWidth, truncate } from "./dashboard-render.ts";
+import type { DashboardSessionSnapshot } from "./dashboard-session-client.ts";
+
+export interface DashboardItem {
+  key: string;
+  label: string;
+  status: string;
+  elapsed: string;
+  details: string[];
+  taskKey?: string;
+  timelinePath?: string;
+  approval?: boolean;
+  skills?: boolean;
+  agent?: boolean;
+}
+export interface DashboardScreenState {
+  view: "main" | "details" | "models" | "help" | "versions" | "version-details";
+  versionId?: EcosystemVersionRow["id"];
+  versionRows?: EcosystemVersionRow[];
+  selectedKey?: string;
+  offset: number;
+  items: DashboardItem[];
+}
+export const dashboardScreenState = (): DashboardScreenState => ({ view: "main", offset: 0, items: [] });
+export const dashboardText = (value: string) =>
+  value
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/[\p{Cc}\p{Cf}]/gu, " ");
+const clean = (value: string) => dashboardText(value).replace(/\s+/g, " ").trim();
+function wrapped(lines: string[], width: number): string[] {
+  return lines.flatMap((line) => {
+    const result: string[] = [];
+    let row = "";
+    for (const character of dashboardText(line)) {
+      if (row && cellWidth(row + character) > width) {
+        result.push(row);
+        row = "";
+      }
+      row += character;
+    }
+    result.push(row);
+    return result;
+  });
+}
+function elapsed(ms: number): string {
+  const seconds = Math.max(0, Math.floor(ms / 1000));
+  return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+}
+const friendlyStatus = (status: string) =>
+  ({
+    active: "Running",
+    running: "Running",
+    starting: "Starting",
+    authorised: "Approved",
+    "needs-you": "Needs you",
+    completed: "Finished",
+    finished: "Finished",
+    failed: "Failed",
+    refused: "Blocked",
+    incomplete: "Incomplete",
+    cancelled: "Canceled",
+    historical: "Recorded",
+  })[status] ?? status;
+const versionStatus = (row: EcosystemVersionRow): string => {
+  if (row.state === "reload-required") return row.id === "pi" ? "Restart needed" : "Reload needed";
+  if (row.state === "not-reported") return "Loaded version unknown";
+  if (row.state === "multiple") return "Multiple sources";
+  if (row.state === "current" && row.loadedVersion && row.loadedVersion === row.installedVersion)
+    return "Up to date on disk";
+  return "Unavailable";
+};
+const attention = (status: string) => ["failed", "refused", "incomplete"].includes(status);
+const active = (status: string) => ["active", "running", "starting", "authorised", "needs-you"].includes(status);
+export function ledgerDashboardItems(projection: DashboardProjection): DashboardItem[] {
+  return projection.nodes.map((node) => ({
+    key: node.executionId,
+    label: node.agentName || "Governed execution",
+    status: node.state,
+    elapsed: elapsed(node.durationMs),
+    agent: true,
+    details: [
+      `Execution: ${node.executionId}`,
+      `State: ${friendlyStatus(node.state)} (observation, not acceptance)`,
+      `Grant: ${node.effectiveGrant.join(", ") || "none"}`,
+      ...(node.workspace ? [`Workspace: ${node.workspace.id} (${node.workspace.access})`] : []),
+      ...(node.runtime?.herdrPaneId ? [`Pane: ${node.runtime.herdrPaneId}`] : []),
+      ...(node.correlation?.phase ? [`Phase: ${node.correlation.phase}`] : []),
+      ...(node.executor ? [`Executor: ${node.executor}`] : []),
+    ],
+  }));
+}
+export function activityDashboardItems(
+  timeline: ActivityTimeline,
+  aliases: ActivityTimelineAliases,
+  now: Date,
+): DashboardItem[] {
+  return timeline.tasks.map((task) => ({
+    key: activityTaskKey(task.rootId, task.id),
+    taskKey: activityTaskKey(task.rootId, task.id),
+    label: `${task.agent || "User turn"} [${aliases.selector(task)}]`,
+    status: task.status,
+    elapsed: elapsed(Date.parse(task.endedAt ?? now.toISOString()) - Date.parse(task.startedAt)),
+    agent: Boolean(task.agent || task.agents.length),
+    skills: task.skills.length > 0,
+    details: [
+      `Task: ${aliases.selector(task)}`,
+      `State: ${friendlyStatus(task.status)} (observation, not acceptance)`,
+      ...(task.parentTaskId ? [`Parent: ${task.parentTaskId}`] : []),
+      ...(task.model ? [`Model: ${task.model}`] : []),
+      ...(task.thinking ? [`Thinking: ${task.thinking}`] : []),
+      ...task.skills.map(
+        (skill) =>
+          `Skill ${skill.name}: ${skill.active ? "declared active" : skill.read ? "read" : "available"}${skill.superseded ? ", superseded" : ""}`,
+      ),
+      ...(task.prompt || task.final ? ["p prompt / f final (retained content only)"] : []),
+    ],
+  }));
+}
+export interface DashboardScreenOptions {
+  width: number;
+  height: number;
+  screen: DashboardScreenState;
+  items: DashboardItem[];
+  session?: DashboardSessionSnapshot;
+  history?: boolean;
+  filter?: string;
+  notice?: string;
+  pending?: boolean;
+  problem?: string;
+  current?: string;
+  currentStatus?: string;
+  color?: boolean;
+  content?: { title: string; text: string };
+  command?: string;
+}
+/** Selection follows stable identity through refresh, never an unrelated task at the old row index. */
+export function renderDashboardScreen(options: DashboardScreenOptions): string {
+  const width = Math.max(1, Math.floor(options.width)),
+    height = Math.max(1, Math.floor(options.height));
+  const { screen, session } = options,
+    pending = session?.pendingApprovals ?? [];
+  const approvals: DashboardItem[] = pending.map((approval) => ({
+    key: `approval:${approval.id}`,
+    label: `${approval.subject} · ${approval.capability.replace(/^tool:/, "")}`,
+    status: "needs-you",
+    elapsed: "",
+    approval: true,
+    details: [
+      `Approval: ${approval.id}`,
+      `Subject: ${approval.subject}`,
+      `Capability: ${approval.capability}`,
+      "Waiting for Daddy permission in the owner session.",
+      "Use the owner's prompt, or a to enable Auto.",
+    ],
+  }));
+  const allItems = [...approvals, ...options.items];
+  const items = allItems.filter((item) =>
+    options.filter === "agents"
+      ? item.agent
+      : options.filter === "skills"
+        ? item.skills
+        : options.filter === "needs-you"
+          ? item.status === "needs-you"
+          : true,
+  );
+  const live = items.filter((item) => active(item.status)),
+    needsAttention = items.filter((item) => attention(item.status)),
+    past = items.filter((item) => !active(item.status) && !attention(item.status)).reverse();
+  screen.items = [...live, ...needsAttention, ...(options.history ? past : [])];
+  if (screen.view === "details" && !screen.items.some((item) => item.key === screen.selectedKey)) {
+    const detail = items.find((item) => item.key === screen.selectedKey);
+    if (detail) screen.items.push(detail);
+  }
+  if (!screen.items.some((item) => item.key === screen.selectedKey)) screen.selectedKey = screen.items[0]?.key;
+  const selectedIndex = screen.items.findIndex((item) => item.key === screen.selectedKey),
+    selected = screen.items[selectedIndex];
+  screen.versionRows = session?.versions?.rows ?? [];
+  if (!screen.versionRows.some((row) => row.id === screen.versionId)) screen.versionId = screen.versionRows[0]?.id;
+  const selectedVersion = screen.versionRows.find((row) => row.id === screen.versionId);
+  const mode = session ? `Auto ${session.auto.enabled ? "ON" : "OFF"}` : "Auto unavailable";
+  const header = `PI DADDY | ${mode}${options.pending ? " …" : session ? " [a]" : ""}`;
+  const footer =
+    options.command !== undefined
+      ? [`: ${clean(options.command)}`]
+      : screen.view === "main" || screen.view === "versions"
+        ? ["↑↓ select · Enter details · a Auto", "m models · v versions · Tab filter · ?"]
+        : [
+            "↑↓ scroll · Esc back · a Auto",
+            screen.view === "details" ? "p prompt · f final · : command · ? help" : ": command · ? help",
+          ];
+  const fixed = [
+    header,
+    session
+      ? `Permissions connected${pending.length ? ` · ${pending.length} needs you` : ""}`
+      : "Permission controls disconnected",
+  ];
+  if (options.notice || options.problem) fixed.push(`! ${clean(options.notice || options.problem || "")}`);
+  const body: string[] = [];
+  if (screen.view === "help")
+    body.push(
+      "DASHBOARD KEYS",
+      "↑/↓ or j/k: select; Enter/d: details",
+      "a: toggle Daddy permission Auto",
+      "m: session models; v: ecosystem versions",
+      "h: show/hide finished history",
+      "Tab: Everything / Agents / Skills / Needs-you",
+      "p/f: selected retained prompt/final",
+      ": opens commands (legacy selectors and m edits)",
+      "Esc: back; q/Ctrl-C: close dashboard",
+      "Auto changes future Daddy permission handling.",
+      "OFF does not cancel already admitted work.",
+      "Auto does not enable JEV or change LoRA consent.",
+      "Finished means observed completion, not acceptance.",
+    );
+  else if (screen.view === "versions" || screen.view === "version-details") {
+    body.push("VERSIONS");
+    if (!session?.versions) body.push("Owner has not reported versions.");
+    else if (screen.view === "versions") {
+      body.push("Loaded -> on disk");
+      for (const row of screen.versionRows)
+        body.push(
+          `${row.id === screen.versionId ? ">" : " "} ${row.label}: ${row.loadedVersion ?? "?"} -> ${row.installedVersion ?? "?"}`,
+          `  ${versionStatus(row)}`,
+        );
+      if (session.versions.note) body.push(session.versions.note);
+    } else if (selectedVersion) {
+      body.push(
+        `${selectedVersion.label}: ${versionStatus(selectedVersion)}`,
+        `Loaded: ${selectedVersion.loadedVersion ?? "not reported"}`,
+        `Installed: ${selectedVersion.installedVersion ?? "unavailable"}`,
+        `Source: ${selectedVersion.source ?? "unavailable"}`,
+        `Path: ${selectedVersion.path ?? "unavailable"}`,
+        "",
+        "MANAGE · run in a terminal",
+        ...selectedVersion.commands,
+      );
+      if (selectedVersion.note) body.push(selectedVersion.note);
+      if (session.versions.note) body.push(session.versions.note);
+    }
+  } else if (screen.view === "models") {
+    body.push("SESSION MODELS");
+    if (!session) body.push("Connect from /grants dashboard to edit models.");
+    for (const row of session?.rows ?? [])
+      body.push(`${row.definition}: ${row.model}`, `  ${row.thinking} · ${row.source}`);
+    body.push(": m <definition|all> <provider:model> <thinking>");
+  } else if (screen.view === "details") {
+    body.push(
+      selected ? `${selected.label} · ${friendlyStatus(selected.status)}` : "No selected task",
+      ...(selected?.details ?? []),
+    );
+    if (options.content) body.push("", options.content.title, ...options.content.text.split(/\r?\n/));
+  } else {
+    const requestFinished = options.currentStatus && !active(options.currentStatus);
+    body.push(
+      options.current
+        ? requestFinished
+          ? `LATEST REQUEST · ${friendlyStatus(options.currentStatus!)}`
+          : "CURRENT REQUEST"
+        : "CURRENT WORK",
+      clean(options.current ?? live.find((item) => !item.approval)?.label ?? "No active work"),
+      "",
+    );
+    const rows: { text: string; key?: string }[] = [];
+    let group: string | undefined;
+    for (const item of screen.items) {
+      const next = item.approval
+        ? "NEEDS YOU"
+        : attention(item.status)
+          ? "NEEDS ATTENTION"
+          : active(item.status)
+            ? `WORK IN PROGRESS · ${live.filter((value) => !value.approval).length} active`
+            : "HISTORY";
+      if (next !== group) {
+        rows.push({ text: next });
+        group = next;
+      }
+      const tail = `${friendlyStatus(item.status)} ${item.elapsed}`.trim(),
+        labelWidth = Math.max(1, width - tail.length - 4);
+      rows.push({
+        key: item.key,
+        text: `${item.key === screen.selectedKey ? ">" : " "} ${truncate(clean(item.label), labelWidth)}  ${tail}`,
+      });
+    }
+    const hidden = !options.history ? past.length : 0;
+    const history = hidden ? `${hidden} finished · h shows history` : options.history ? "h hides history" : "";
+    const available = Math.max(0, height - fixed.length - footer.length - body.length - (history ? 1 : 0));
+    const rowIndex = rows.findIndex((row) => row.key === selected?.key);
+    const start = Math.max(0, rowIndex - available + 1);
+    body.push(...rows.slice(start, start + available).map((row) => row.text));
+    if (!rows.length)
+      body.push(options.filter && options.filter !== "everything" ? "No matching active work." : "No work is running.");
+    if (history) body.push(history);
+  }
+
+  const detailBody = screen.view === "main" || screen.view === "versions" ? body : wrapped(body, width);
+  const room = Math.max(0, height - fixed.length - footer.length);
+  if (screen.view === "versions" && selectedVersion && room > 0) {
+    const row = 2 + screen.versionRows.findIndex((value) => value.id === screen.versionId) * 2;
+    if (row < screen.offset) screen.offset = row;
+    else if (row + 1 >= screen.offset + room) screen.offset = Math.max(0, row + 2 - room);
+  }
+  const offset =
+    screen.view === "main" ? 0 : Math.max(0, Math.min(screen.offset, Math.max(0, detailBody.length - room)));
+  screen.offset = offset;
+  const lines = [...fixed, ...detailBody.slice(offset, offset + room)];
+  while (lines.length < height - footer.length) lines.push("");
+  const output =
+    height < fixed.length + footer.length
+      ? fixed.slice(0, height)
+      : [...lines.slice(0, Math.max(0, height - footer.length)), ...footer].slice(0, height);
+  return output
+    .map((line, index) => {
+      const safe = truncate(dashboardText(line), width);
+      if (!options.color) return safe;
+      const section =
+        /^(CURRENT REQUEST|LATEST REQUEST|CURRENT WORK|NEEDS YOU|NEEDS ATTENTION|WORK IN PROGRESS|HISTORY|VERSIONS|SESSION MODELS|DASHBOARD KEYS|MANAGE)/.test(
+          safe,
+        );
+      const code =
+        index === 0
+          ? "1;36"
+          : safe.startsWith("!")
+            ? "33"
+            : safe.startsWith(">")
+              ? "36"
+              : section
+                ? "1"
+                : index === 1 || index >= height - footer.length
+                  ? "90"
+                  : undefined;
+      return code ? `\u001b[${code}m${safe}\u001b[0m` : safe;
+    })
+    .join("\n");
+}

package/src/products/dashboard-session-client.ts

@@ -1,14 +1,22 @@
+import type { EcosystemVersions } from "./ecosystem-versions.ts";
 import { createConnection } from "node:net";
 
 export interface DashboardSessionSnapshot {
   rows: Array<{ definition: string; model: string; thinking: string; source: string }>;
   cost: number | null;
+  activity?: { rootId: string; path: string; taskId: string };
+  versions?: EcosystemVersions;
+  auto: { enabled: boolean; source: "default" | "environment" | "session" };
+  pendingApprovals: Array<{ id: string; subject: string; capability: string }>;
 }
 
+export type DashboardSessionAction =
+  { action: "get" } | { action: "set"; edits: string } | { action: "set-auto"; enabled: boolean };
+
 export async function dashboardSessionRequest(
   socketPath: string,
   token: string,
-  request: { action: "get" } | { action: "set"; edits: string },
+  request: DashboardSessionAction,
 ): Promise<DashboardSessionSnapshot> {
   return new Promise((resolve, reject) => {
     const socket = createConnection(socketPath);
@@ -24,6 +32,14 @@ export async function dashboardSessionRequest(
       try {
         const parsed = JSON.parse(output) as DashboardSessionSnapshot & { ok?: boolean; error?: string };
         if (!parsed.ok) throw new Error(parsed.error ?? "dashboard session request failed");
+        if (
+          !parsed.auto ||
+          typeof parsed.auto.enabled !== "boolean" ||
+          !["default", "environment", "session"].includes(parsed.auto.source) ||
+          !Array.isArray(parsed.pendingApprovals) ||
+          !Array.isArray(parsed.rows)
+        )
+          throw new Error("dashboard owner does not provide compatible permission controls");
         resolve(parsed);
       } catch (error) {
         reject(error);
@@ -32,3 +48,46 @@ export async function dashboardSessionRequest(
     socket.once("connect", () => socket.write(`${JSON.stringify({ ...request, token })}\n`));
   });
 }
+
+/** A slow status poll cannot overwrite a newer acknowledged mutation. Failed requests expose no guessed mode. */
+export function createDashboardConnection(
+  request?: (action: DashboardSessionAction) => Promise<DashboardSessionSnapshot>,
+) {
+  const state: { snapshot?: DashboardSessionSnapshot; pending: boolean; error?: string } = { pending: false };
+  let generation = 0;
+  return {
+    state,
+    async refresh() {
+      if (!request || state.pending) return;
+      const observed = generation;
+      try {
+        const snapshot = await request({ action: "get" });
+        if (generation === observed) {
+          state.snapshot = snapshot;
+          state.error = undefined;
+        }
+      } catch (error) {
+        if (generation === observed) {
+          state.snapshot = undefined;
+          state.error = `Controls unavailable: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      }
+    },
+    async change(action: Exclude<DashboardSessionAction, { action: "get" }>) {
+      if (!request || !state.snapshot || state.pending) return false;
+      generation++;
+      state.pending = true;
+      try {
+        state.snapshot = await request(action);
+        state.error = undefined;
+        return true;
+      } catch (error) {
+        state.snapshot = undefined;
+        state.error = `Control change not confirmed: ${error instanceof Error ? error.message : String(error)}`;
+        return false;
+      } finally {
+        state.pending = false;
+      }
+    },
+  };
+}

package/src/products/ecosystem-versions.ts

@@ -0,0 +1,18 @@
+/** Operator version inventory. These observations do not qualify runtime compatibility. */
+export type EcosystemPackageId = "pi" | "pi-daddy" | "principal-pi-skills" | "skill-harness";
+export interface EcosystemVersionRow {
+  id: EcosystemPackageId;
+  label: string;
+  loadedVersion: string | null;
+  installedVersion: string | null;
+  source: string | null;
+  path: string | null;
+  state: "current" | "reload-required" | "not-reported" | "unavailable" | "multiple";
+  commands: string[];
+  note?: string;
+}
+export interface EcosystemVersions {
+  rows: EcosystemVersionRow[];
+  checkedAt: string;
+  note?: string;
+}