pi-daddy 0.47.1 → 0.48.0

package/src/governance/auto-mode-policy.ts

@@ -1,3 +1,5 @@
+import { createDispatchOperations } from "./dispatch-operations.ts";
+import { connectDispatchOperations } from "./dispatch-operation-client.ts";
 /** Root-owned live Auto authority. Descendants receive read/admit access, never mutation access. */
 import { randomBytes, randomUUID } from "node:crypto";
 import { chmod, unlink } from "node:fs/promises";
@@ -38,6 +40,7 @@ export async function createAutoModeAuthority(initial: {
     source = initial.source,
     revision = 0,
     closed = false;
+  const operations = createDispatchOperations();
   const pending = new Map<string, PendingApproval>();
   const waiters = new Set<() => void>();
   const sockets = new Set<Socket>();
@@ -92,12 +95,14 @@ export async function createAutoModeAuthority(initial: {
     const controller = new AbortController();
     let input = "",
       handled = false,
-      untrack: (() => void) | undefined;
+      untrack: (() => void) | undefined,
+      abandonOperation: (() => void) | undefined;
     socket.on("error", () => {});
     socket.once("close", () => {
       sockets.delete(socket);
       controller.abort();
       untrack?.();
+      abandonOperation?.();
     });
     const reply = (value: unknown) => {
       if (!socket.destroyed) socket.end(JSON.stringify(value) + "\n");
@@ -129,6 +134,21 @@ export async function createAutoModeAuthority(initial: {
         } else if (request.action === "pending" && validPending(request.approval)) {
           socket.setTimeout(0);
           untrack = trackPending(request.approval);
+        } else if (request.action === "operation-claim") {
+          const value = operations.claim(request.request);
+          if (!value.reused) {
+            socket.setTimeout(0);
+            abandonOperation = () => operations.abandoned(value.operation.operationId, value.ticket!);
+            socket.write(JSON.stringify({ ok: true, value }) + "\n");
+          } else reply({ ok: true, value });
+        } else if (request.action === "operation-read") {
+          reply({ ok: true, value: operations.read(request.operationId) });
+        } else if (request.action === "operation-started") {
+          operations.started(request.operationId, request.ticket, request.cwd, request.workspaceId);
+          reply({ ok: true });
+        } else if (request.action === "operation-finish") {
+          operations.finish(request.operationId, request.ticket, request.state, request.runtime);
+          reply({ ok: true });
         } else throw new Error("Unknown Auto policy action");
       } catch (error) {
         reply({ ok: false, error: String(error) });
@@ -153,7 +173,9 @@ export async function createAutoModeAuthority(initial: {
     } catch {}
   };
   process.once("exit", exit);
+  const operationAccess = connectDispatchOperations(reference);
   return {
+    operations: operationAccess,
     reference,
     snapshot,
     read: async () => snapshot(),
@@ -175,6 +197,7 @@ export async function createAutoModeAuthority(initial: {
     close: async () => {
       if (closed) return;
       closed = true;
+      operationAccess.close();
       enabled = false;
       for (const wake of [...waiters]) wake();
       for (const socket of sockets) socket.destroy();
@@ -233,6 +256,7 @@ function request(ref: AutoModeRef, action: "read" | "admit" | "wait", signal?: A
 }
 
 export function connectAutoMode(reference: AutoModeRef): AutoModeReader {
+  const operations = connectDispatchOperations(reference);
   let closed = false;
   const active = new Set<AbortController>();
   const pending = new Set<Socket>();
@@ -252,6 +276,7 @@ export function connectAutoMode(reference: AutoModeRef): AutoModeReader {
   };
   return {
     reference,
+    operations,
     read: async () => {
       const value = (await call("read")) as AutoModeSnapshot;
       if (
@@ -290,6 +315,7 @@ export function connectAutoMode(reference: AutoModeRef): AutoModeReader {
     },
     close: async () => {
       closed = true;
+      operations.close();
       for (const controller of active) controller.abort();
       for (const socket of pending) socket.destroy();
     },

package/src/governance/dispatch-operation-client.ts

@@ -0,0 +1,96 @@
+/** A held claim connection makes caller loss uncertain; another caller never inherits execution. */
+import { createConnection, type Socket } from "node:net";
+import type { AutoModeRef } from "../kernel/auto-mode.ts";
+import type {
+  OperationAccess,
+  OperationClaim,
+  OperationReference,
+  OperationRequest,
+} from "../kernel/dispatch-operation.ts";
+
+export function connectDispatchOperations(reference: AutoModeRef): OperationAccess {
+  const sockets = new Set<Socket>();
+  let closed = false;
+  const request = (
+    action: string,
+    input: object,
+    signal?: AbortSignal,
+    hold = false,
+  ): Promise<{ value: any; socket: Socket }> =>
+    new Promise((resolve, reject) => {
+      if (closed || signal?.aborted) return reject(Error("Operation owner unavailable or request aborted"));
+      const socket = createConnection(reference.socketPath);
+      sockets.add(socket);
+      let output = "",
+        answered = false;
+      const cleanup = () => signal?.removeEventListener("abort", abort);
+      const fail = (error: Error) => {
+        cleanup();
+        socket.destroy();
+        if (!answered) {
+          answered = true;
+          reject(error);
+        }
+      };
+      const abort = () => fail(Error("Operation request aborted"));
+      signal?.addEventListener("abort", abort, { once: true });
+      socket.setEncoding("utf8");
+      socket.setTimeout(2000, () => fail(Error("Operation owner unavailable")));
+      socket.once("error", () => fail(Error("Operation owner unavailable")));
+      socket.once("connect", () => socket.write(JSON.stringify({ ...reference, action, ...input }) + "\n"));
+      socket.once("close", () => {
+        sockets.delete(socket);
+        cleanup();
+        if (!answered) fail(Error("Operation owner disconnected"));
+      });
+      socket.on("data", (chunk) => {
+        if (answered) return;
+        output += chunk;
+        if (output.length > 65536) return fail(Error("Operation response too large"));
+        const end = output.indexOf("\n");
+        if (end < 0) return;
+        try {
+          const reply = JSON.parse(output.slice(0, end));
+          if (reply.ok !== true) throw Error(reply.error ?? "Operation request failed");
+          answered = true;
+          cleanup();
+          socket.setTimeout(0);
+          if (!hold || reply.value?.reused) socket.destroy();
+          resolve({ value: reply.value, socket });
+        } catch (error) {
+          fail(error instanceof Error ? error : Error(String(error)));
+        }
+      });
+    });
+  return {
+    claim: async (input: OperationRequest, signal?: AbortSignal): Promise<OperationClaim> => {
+      const { value, socket } = await request("operation-claim", { request: input }, signal, true);
+      if (value.reused) return { operation: value.operation, reused: true };
+      const update = async (action: string, data: object) => {
+        if (socket.destroyed) throw Error("Operation claim owner disconnected; settlement is uncertain");
+        return request(action, { operationId: input.operationId, ticket: value.ticket, ...data });
+      };
+      return {
+        operation: value.operation,
+        reused: false,
+        started: async (cwd, workspaceId) => {
+          await update("operation-started", { cwd, workspaceId });
+        },
+        finish: async (state, runtime) => {
+          try {
+            await update("operation-finish", { state, runtime });
+            Object.assign(value.operation, (await request("operation-read", { operationId: input.operationId })).value);
+          } finally {
+            socket.destroy();
+          }
+        },
+      };
+    },
+    read: async (operationId: string) =>
+      (await request("operation-read", { operationId })).value as OperationReference | null,
+    close: () => {
+      closed = true;
+      for (const socket of sockets) socket.destroy();
+    },
+  };
+}

package/src/governance/dispatch-operations.ts

@@ -0,0 +1,81 @@
+/** Atomic leader election at the tree owner. No task text, execution permission or cached output. */
+import { randomBytes } from "node:crypto";
+import type { OperationReference, OperationRequest } from "../kernel/dispatch-operation.ts";
+import { validOperationId } from "../kernel/dispatch-operation.ts";
+
+export function createDispatchOperations() {
+  const records = new Map<string, { digest: string; ticket: string; value: OperationReference }>();
+  const copy = (value: OperationReference) => structuredClone(value);
+  const requireTicket = (id: string, ticket: string) => {
+    const row = records.get(id);
+    if (!row || typeof ticket !== "string" || row.ticket !== ticket) throw Error("Operation owner mismatch");
+    return row;
+  };
+  return {
+    claim(request: OperationRequest) {
+      if (
+        !request ||
+        !validOperationId(request.operationId) ||
+        typeof request.requestDigest !== "string" ||
+        !/^[a-f0-9]{64}$/.test(request.requestDigest) ||
+        typeof request.executionId !== "string" ||
+        !request.executionId.startsWith("exec:") ||
+        request.executionId.length > 128 ||
+        typeof request.cwd !== "string" ||
+        !request.cwd.startsWith("/") ||
+        request.cwd.length > 4096 ||
+        !(request.workspaceId === null || typeof request.workspaceId === "string")
+      )
+        throw Error("Invalid dispatch operation request");
+      const old = records.get(request.operationId);
+      if (old) {
+        if (old.digest !== request.requestDigest)
+          throw Error("Operation identity conflict; inspect the original request before choosing a new operation_id");
+        return { reused: true, operation: copy(old.value) };
+      }
+      // Never evict a terminal ID and accidentally permit a mutation to run twice.
+      if (records.size >= 4096) throw Error("Session operation registry is full; no dispatch was admitted");
+      const now = new Date().toISOString(),
+        ticket = randomBytes(24).toString("hex");
+      const value: OperationReference = {
+        operationId: request.operationId,
+        executionId: request.executionId,
+        cwd: request.cwd,
+        workspaceId: request.workspaceId,
+        state: "admitting",
+        startedAt: now,
+        updatedAt: now,
+      };
+      records.set(request.operationId, { digest: request.requestDigest, ticket, value });
+      return { reused: false, operation: copy(value), ticket };
+    },
+    read(id: string) {
+      if (!validOperationId(id)) throw Error("Invalid operation_id");
+      const value = records.get(id)?.value;
+      return value ? copy(value) : null;
+    },
+    started(id: string, ticket: string, cwd: string, workspaceId: string | null) {
+      const row = requireTicket(id, ticket);
+      if (row.value.state !== "admitting") throw Error("Operation is no longer admitting");
+      if (
+        typeof cwd !== "string" ||
+        !cwd.startsWith("/") ||
+        cwd.length > 4096 ||
+        !(workspaceId === null || typeof workspaceId === "string")
+      )
+        throw Error("Invalid operation workspace");
+      row.value = { ...row.value, state: "running", cwd, workspaceId, updatedAt: new Date().toISOString() };
+    },
+    finish(id: string, ticket: string, state: OperationReference["state"], runtime?: OperationReference["runtime"]) {
+      const row = requireTicket(id, ticket);
+      if (!["settled", "not-started", "uncertain"].includes(state)) throw Error("Invalid operation terminal state");
+      if (!["admitting", "running"].includes(row.value.state)) throw Error("Operation already ended");
+      row.value = { ...row.value, state, ...(runtime ? { runtime } : {}), updatedAt: new Date().toISOString() };
+    },
+    abandoned(id: string, ticket: string) {
+      const row = requireTicket(id, ticket);
+      if (["admitting", "running"].includes(row.value.state))
+        row.value = { ...row.value, state: "uncertain", updatedAt: new Date().toISOString() };
+    },
+  };
+}

package/src/governance/execution-retention.ts

@@ -8,6 +8,7 @@ import {
   type NativeSessionObservation,
   type NativeSessionManager,
   type NativeSessionCapture,
+  type CapturedSessionBranch,
 } from "./native-session.ts";
 export {
   buildExecutionRetentionManifest,
@@ -26,7 +27,7 @@ export { ENV_EXECUTION_ARCHIVE } from "../kernel/env-names.ts";
 import { isUnderPiProjectDir } from "../kernel/project-paths.ts";
 
 /** Operator-owned archive boundary; never a model-facing parameter or an authority source. */
-export const RETENTION_VERSION = "2.0";
+export const RETENTION_VERSION = "2.1";
 const LIMIT = 1024 * 1024;
 const MAX_ACTIVE = 32;
 let active = 0;
@@ -49,7 +50,7 @@ export interface RetainedContent {
   bytes: number | null;
 }
 export interface ExecutionRetentionManifest {
-  version: "2.0";
+  version: "2.0" | "2.1";
   archiveId: string;
   identity: RetentionIdentity;
   native: {
@@ -155,9 +156,10 @@ export function beginExecutionRetention(identity: RetentionIdentity, directory =
   let nativeTask: Promise<void> | undefined;
   let nextNative:
     | {
-        source: "herdr-id" | "herdr-path" | "pi-session-file" | "pi-session-manager";
+        source: "herdr-id" | "herdr-path" | "pi-session-file" | "pi-session-manager" | "pi-captured-final";
         value: string;
         manager?: NativeSessionManager;
+        capturedBranch?: CapturedSessionBranch;
       }
     | undefined;
   let pinnedSessionId: string | undefined;
@@ -236,6 +238,7 @@ export function beginExecutionRetention(identity: RetentionIdentity, directory =
       source: reference.source,
       value: reference.value,
       ...(reference.manager ? { manager: reference.manager } : {}),
+      ...(reference.capturedBranch ? { capturedBranch: { ...reference.capturedBranch } } : {}),
     };
     if (nativeTask) return;
     nativeTask = Promise.resolve()
@@ -258,6 +261,7 @@ export function beginExecutionRetention(identity: RetentionIdentity, directory =
                   path: current.value,
                   source: current.source,
                   manager: current.manager,
+                  capturedBranch: current.capturedBranch,
                   expectedSessionId: pinnedSessionId,
                   expectedFile: pinnedFile,
                 });

package/src/governance/native-session.ts

@@ -7,7 +7,8 @@ import { ENV_NATIVE_SESSION_ROOT } from "../kernel/env-names.ts";
 export { ENV_NATIVE_SESSION_ROOT } from "../kernel/env-names.ts";
 
 export const MAX_NATIVE_SESSION_BYTES = 1024 * 1024;
-export type NativeSessionSource = "herdr-id" | "herdr-path" | "pi-session-file" | "pi-session-manager";
+export type NativeSessionSource =
+  "herdr-id" | "herdr-path" | "pi-session-file" | "pi-session-manager" | "pi-captured-final";
 export interface NativeSessionObservation {
   source: NativeSessionSource | null;
   status: "missing" | "verified" | "invalid" | "changed" | "truncated" | "unsupported";
@@ -25,6 +26,13 @@ export interface NativeSessionCapture {
   bytes?: Buffer;
   fileIdentity?: { device: string; inode: string };
 }
+/** Byte-bound metadata from the executor's qualified native final, not a locator-derived branch. */
+export interface CapturedSessionBranch {
+  path: string;
+  sessionId: string;
+  leafId: string;
+  sha256: string;
+}
 /** Read-only methods of pi 0.84.2's public SessionManager; no runtime/session creation or model work. */
 export interface NativeSessionManager {
   getSessionFile(): string | undefined;
@@ -59,6 +67,7 @@ export function parseNativeSessionBytes(
     expectedSessionId?: string;
     truncated?: boolean;
     liveLeaf?: { sessionId: string; leafId: string | null };
+    capturedBranch?: CapturedSessionBranch;
   },
 ): NativeSessionCapture {
   const observation = { ...missingNativeSession(), source: input.source, sessionPath: input.path };
@@ -138,6 +147,23 @@ export function parseNativeSessionBytes(
     observation.branchLeafId = input.liveLeaf.leafId;
     observation.branchState = "observed";
   }
+  if (input.source === "pi-captured-final" && !input.capturedBranch)
+    return fail("invalid", "native-session-final-branch-missing");
+  if (input.capturedBranch) {
+    const branch = input.capturedBranch;
+    if (
+      input.source !== "pi-captured-final" ||
+      branch.path !== input.path ||
+      branch.sessionId !== header.id ||
+      branch.sha256 !== observation.sha256 ||
+      !ids.has(branch.leafId) ||
+      (input.liveLeaf && input.liveLeaf.leafId !== branch.leafId)
+    ) {
+      return fail("changed", "native-session-final-branch-mismatch");
+    }
+    observation.branchLeafId = branch.leafId;
+    observation.branchState = "observed";
+  }
   observation.status = "verified";
   observation.reason = observation.branchState === "unknown" ? "active-branch-unknown" : null;
   return result;
@@ -150,6 +176,7 @@ export async function readNativeSession(input: {
   expectedSessionId?: string;
   allowedRoot?: string;
   manager?: NativeSessionManager;
+  capturedBranch?: CapturedSessionBranch;
   expectedFile?: { device: string; inode: string };
 }): Promise<NativeSessionCapture> {
   const gap = (status: NativeSessionObservation["status"], reason: string): NativeSessionCapture => ({

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