pi-daddy 0.47.1 → 0.48.1

package/src/kernel/delegate.ts

@@ -201,6 +201,20 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
     requested = (request.tools ?? []).map(normaliseCapability);
   }
 
+  // Coordinator-only qualification does not authorize loading native Codemode or its raw model API in children.
+  const coordinatorOnly = requested.filter((capability) =>
+    ["tool:codemode", "ext:codemode", "tool:principal_codemode", "ext:principal_codemode"].includes(capability),
+  );
+  if (coordinatorOnly.length)
+    return denied(
+      {
+        ...empty,
+        requested,
+        reason: `Codemode is qualified only for the coordinator; governed children cannot receive ${coordinatorOnly.join(", ")}`,
+      },
+      "UNKNOWN_TOOL",
+    );
+
   // ADR-0078. A declared `context:` id is a CEILING, not a request: a definition that permits forking must not
   // fork on every spawn. So the declared modes come out of `requested` and exactly the one this call asked for
   // goes back in.

package/src/kernel/dispatch-operation.ts

@@ -0,0 +1,38 @@
+/** Explicit operation identity prevents duplicate dispatch, never authorizes work or caches results. */
+export interface OperationReference {
+  operationId: string;
+  executionId: string;
+  state: "admitting" | "running" | "settled" | "not-started" | "uncertain";
+  cwd: string;
+  workspaceId: string | null;
+  startedAt: string;
+  updatedAt: string;
+  runtime?: {
+    control?: "failed";
+    work?: "succeeded" | "failed" | "unknown";
+    final?: { state: string; sessionId?: string; messageId?: string; leafId?: string; sha256?: string };
+    cleanup?: { state: string; receiptPath?: string; executionId?: string };
+  };
+}
+export interface OperationRequest {
+  operationId: string;
+  requestDigest: string;
+  executionId: string;
+  cwd: string;
+  workspaceId: string | null;
+}
+export interface OperationClaim {
+  operation: OperationReference;
+  reused: boolean;
+  /** Only the elected caller receives these methods. Neither grants execution authority. */
+  started?(cwd: string, workspaceId: string | null): Promise<void>;
+  finish?(state: "settled" | "not-started" | "uncertain", runtime?: OperationReference["runtime"]): Promise<void>;
+}
+export interface OperationAccess {
+  claim(request: OperationRequest, signal?: AbortSignal): Promise<OperationClaim>;
+  read(operationId: string): Promise<OperationReference | null>;
+  close(): void;
+}
+export function validOperationId(value: unknown): value is string {
+  return typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9._:/-]{0,159}$/.test(value);
+}

package/src/kernel/propagation.ts

@@ -410,7 +410,24 @@ export function mergeChildEnv(parentEnv: NodeJS.ProcessEnv, planEnv: Record<stri
 }
 
 /** Extract bare tool names from a provider payload's tool array, tolerating provider shape differences. */
-export function observeToolNames(payload: unknown): string[] | null {
+export function observeToolNames(
+  payload: unknown,
+  registered?: readonly { name: string; exposure?: string }[],
+  active?: readonly string[],
+): string[] | null {
+  // Pi's provider projection may hide declarations while tools remain callable from Codemode.
+  // Exposure metadata is native inventory, not authorization; deriveOwnGrant still intersects inheritance.
+  if (registered && active && registered.length > 0 && registered.every((tool) => typeof tool.exposure === "string")) {
+    const declared = new Set(active);
+    return registered
+      .filter(
+        (tool) =>
+          tool.exposure === "codemode" ||
+          tool.exposure === "deferred" ||
+          ((tool.exposure === "direct" || tool.exposure === "model-only") && declared.has(tool.name)),
+      )
+      .map((tool) => tool.name);
+  }
   if (!payload || typeof payload !== "object") return null;
   const record = payload as Record<string, unknown>;
   for (const key of ["tools", "functions"]) {

package/src/products/activity-timeline.ts

@@ -44,6 +44,8 @@ export interface ActivityEvent {
   agentId?: string;
   agent?: string;
   outcome?: string;
+  tool?: string;
+  cwd?: string;
   model?: string;
   thinking?: string;
   prompt?: ContentReference;
@@ -63,6 +65,8 @@ export interface TimelineTask {
   agent?: string;
   startedAt: string;
   endedAt?: string;
+  lastEvent?: { at: string; kind: string; tool?: string };
+  cwd?: string;
   status: "active" | "finished" | "failed" | "cancelled" | "needs-you";
   model?: string;
   thinking?: string;
@@ -122,6 +126,8 @@ function eventOf(value: unknown): ActivityEvent | null {
   )
     return null;
   if (
+    (event.tool !== undefined && !validId(event.tool)) ||
+    (event.cwd !== undefined && (typeof event.cwd !== "string" || !event.cwd || event.cwd.length > 4096)) ||
     (event.parentTaskId && !validId(event.parentTaskId)) ||
     (event.agentId && !validId(event.agentId)) ||
     (event.agent && !validId(event.agent)) ||
@@ -170,6 +176,10 @@ export function parseActivityTimeline(text: string): ActivityTimeline {
       };
       tasks.set(key, task);
     }
+    if (!task.lastEvent || Date.parse(event.at) >= Date.parse(task.lastEvent.at)) {
+      task.lastEvent = { at: event.at, kind: event.kind, ...(event.tool ? { tool: event.tool } : {}) };
+      if (event.cwd) task.cwd = event.cwd;
+    }
     if (event.kind === "task_started") {
       task.model = event.model;
       task.thinking = event.thinking;

package/src/products/dashboard-screen.ts

@@ -11,6 +11,7 @@ export interface DashboardItem {
   status: string;
   elapsed: string;
   details: string[];
+  observation?: string;
   taskKey?: string;
   timelinePath?: string;
   approval?: boolean;
@@ -49,7 +50,10 @@ function wrapped(lines: string[], width: number): string[] {
 }
 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 minutes = Math.floor(seconds / 60);
+  return seconds >= 3600
+    ? `${Math.floor(minutes / 60)}:${String(minutes % 60).padStart(2, "0")}:${String(seconds % 60).padStart(2, "0")}`
+    : `${minutes}:${String(seconds % 60).padStart(2, "0")}`;
 }
 const friendlyStatus = (status: string) =>
   ({
@@ -87,7 +91,10 @@ export function ledgerDashboardItems(projection: DashboardProjection): Dashboard
       `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.workspace
+        ? [`Workspace: ${node.workspace.id} (${node.workspace.access})`, `Root: ${node.workspace.root}`]
+        : ["Workspace binding: none recorded"]),
+      `Last lifecycle event: ${node.updatedAt}`,
       ...(node.runtime?.herdrPaneId ? [`Pane: ${node.runtime.herdrPaneId}`] : []),
       ...(node.correlation?.phase ? [`Phase: ${node.correlation.phase}`] : []),
       ...(node.executor ? [`Executor: ${node.executor}`] : []),
@@ -105,11 +112,21 @@ export function activityDashboardItems(
     label: `${task.agent || "User turn"} [${aliases.selector(task)}]`,
     status: task.status,
     elapsed: elapsed(Date.parse(task.endedAt ?? now.toISOString()) - Date.parse(task.startedAt)),
+    observation: task.lastEvent
+      ? `${task.lastEvent.tool ? `${task.lastEvent.tool} ` : ""}${task.lastEvent.kind.replaceAll("_", " ")} · ${elapsed(Date.parse(now.toISOString()) - Date.parse(task.lastEvent.at))} ago`
+      : undefined,
     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.cwd ? [`Working directory: ${task.cwd}`] : ["Working directory: not recorded"]),
+      ...(task.lastEvent
+        ? [
+            `Last observed: ${task.lastEvent.kind}${task.lastEvent.tool ? ` (${task.lastEvent.tool})` : ""} at ${task.lastEvent.at}`,
+          ]
+        : []),
+      "Silence is not proof of a stalled process. Finished is not review approval.",
       ...(task.parentTaskId ? [`Parent: ${task.parentTaskId}`] : []),
       ...(task.model ? [`Model: ${task.model}`] : []),
       ...(task.thinking ? [`Thinking: ${task.thinking}`] : []),
@@ -281,6 +298,8 @@ export function renderDashboardScreen(options: DashboardScreenOptions): string {
       }
       const tail = `${friendlyStatus(item.status)} ${item.elapsed}`.trim(),
         labelWidth = Math.max(1, width - tail.length - 4);
+      if (item.key === screen.selectedKey && item.observation)
+        rows.push({ text: `  Observed: ${clean(item.observation)}` });
       rows.push({
         key: item.key,
         text: `${item.key === screen.selectedKey ? ">" : " "} ${truncate(clean(item.label), labelWidth)}  ${tail}`,