pi-daddy 0.47.0 → 0.48.0

package/src/governance/retention-contract.ts

@@ -31,7 +31,7 @@ export const RETENTION_SCHEMA = freeze({
   $schema: "https://json-schema.org/draft/2020-12/schema",
   $id: "https://pi-daddy.local/contracts/execution-retention/v2/manifest.schema.json",
   ...closed({
-    version: literal("2.0"),
+    version: { enum: ["2.0", "2.1"] },
     archiveId: uuid,
     identity: closed({
       executionId: string(),
@@ -54,7 +54,7 @@ export const RETENTION_SCHEMA = freeze({
       branchLeafId: nullable(string(128)),
     }),
     nativeSession: closed({
-      source: { enum: [null, "herdr-id", "herdr-path", "pi-session-file", "pi-session-manager"] },
+      source: { enum: [null, "herdr-id", "herdr-path", "pi-session-file", "pi-session-manager", "pi-captured-final"] },
       status: { enum: ["missing", "verified", "invalid", "changed", "truncated", "unsupported"] },
       sessionId: nullable(uuid),
       sessionPath: nullable(string(4096)),
@@ -101,6 +101,10 @@ export const RETENTION_SCHEMA = freeze({
     acceptance: literal("not-assessed"),
   }),
   allOf: [
+    {
+      if: { properties: { version: literal("2.0") } },
+      then: { properties: { nativeSession: { properties: { source: { not: literal("pi-captured-final") } } } } },
+    },
     {
       if: { properties: { state: literal("running") } },
       then: { properties: { outcome: literal(null) } },
@@ -162,7 +166,7 @@ export function buildExecutionRetentionManifest(value: unknown): ExecutionRetent
     }
   };
   inspect(value, 0);
-  if (!validator.Check(value)) throw new TypeError("invalid execution-retention 2.0 manifest");
+  if (!validator.Check(value)) throw new TypeError("invalid execution-retention 2.x manifest");
   const m = JSON.parse(JSON.stringify(value)) as ExecutionRetentionManifest;
   if (
     m.native.sessionId !== m.nativeSession.sessionId ||
@@ -178,7 +182,8 @@ export function buildExecutionRetentionManifest(value: unknown): ExecutionRetent
   }
   if (
     m.nativeSession.branchState === "observed" &&
-    (m.nativeSession.source !== "pi-session-manager" || m.nativeSession.status !== "verified")
+    (!["pi-session-manager", "pi-captured-final"].includes(m.nativeSession.source ?? "") ||
+      m.nativeSession.status !== "verified")
   )
     throw new TypeError("unverified active native branch");
   if (

package/src/kernel/auto-mode.ts

@@ -19,6 +19,7 @@ export interface AutoModeRef {
 }
 export interface AutoModeReader {
   readonly reference: AutoModeRef;
+  readonly operations?: import("./dispatch-operation.ts").OperationAccess;
   read(): Promise<AutoModeSnapshot>;
   /** Linearization point: only a current ON answer admits new work. No approval is banked. */
   admit(signal?: AbortSignal): Promise<boolean>;

package/src/kernel/chain.ts

@@ -152,6 +152,7 @@ export function composeStepTask(template: string, previous: string | undefined):
 
 /** One chain step as `runOneDelegation` takes it: the operator's spec with its task composed. */
 export interface ChainStep {
+  operation_id?: string;
   definitionId?: string;
   task: string;
   agent?: string;

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-cli.ts

@@ -347,7 +347,8 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
     previous = rendered;
     process.stdout.write(
       interactive
-        ? `\u001b[H${frame}\u001b[J`
+        ? // Erase every row: clearing only below the final cursor leaves old suffixes on shorter rows.
+          `\u001b[H\u001b[2K${frame.replace(/\n/g, "\r\n\u001b[2K")}\u001b[J`
         : clear
           ? `\u001b]0;PI-DADDY\u0007\u001b[2J\u001b[H${rendered}`
           : `${rendered}\n`,

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}`,