pi-daddy 0.48.2 → 0.49.0

package/extensions/run-delegation.ts

@@ -2,6 +2,7 @@ import {
   claimDelegationOperation,
   existingOperationOutcome,
   finishDelegationOperation,
+  operationFinalScope,
 } from "./delegation-operations.ts";
 import type { OperationClaim } from "../src/kernel/dispatch-operation.ts";
 import { reconcileDelegationCapacity, reserveDelegationCapacity } from "./session-capacity.ts";
@@ -552,6 +553,7 @@ export async function runOneDelegation(
   ...args: Parameters<typeof runOneDelegationImplementation>
 ): Promise<DelegationOutcome> {
   const [session, spec, ids, , ctx, signal] = args;
+  const finalScope = operationFinalScope(session);
   const options = args[6] ?? {};
   const claim = options.operationClaim ?? (await claimDelegationOperation(session, spec, ids, ctx, signal));
   if (claim?.reused) {
@@ -571,7 +573,7 @@ export async function runOneDelegation(
     const result = await runOneDelegationImplementation(...args);
     if (claim) {
       try {
-        await finishDelegationOperation(claim, result);
+        await finishDelegationOperation(claim, result, session, finalScope);
       } catch (error) {
         // A post-execution observation failure must not erase the native final or settlement receipt.
         result.control = "failed";

package/extensions/runtime-snapshot.ts

@@ -5,6 +5,7 @@ import { openRuntimeSettlement, settlementHash } from "../src/governance/runtime
 import { reconcileDelegationCapacity } from "./session-capacity.ts";
 import { agentDir } from "../src/kernel/project-paths.ts";
 import type { GrantsSession } from "./session.ts";
+import { bindOperationFinals, operationFinal } from "./delegation-operations.ts";
 export const OPERATION_STATUS_EVENT = "pi-daddy:operation-status:v1";
 export const RUNTIME_SNAPSHOT_EVENT = "pi-daddy:runtime-snapshot:v1";
 export function registerRuntimeSnapshot(
@@ -99,6 +100,7 @@ export function registerRuntimeSnapshot(
       sessionId?: string;
       cwd?: string;
       operationId?: string;
+      includeFinal?: boolean;
       reply?: (value: unknown) => void;
     };
     if (
@@ -139,7 +141,12 @@ export function registerRuntimeSnapshot(
           lifecycle.runtimeSnapshotGeneration !== generation
         )
           throw Error("operation owner changed during read");
-        request.reply!({ ...envelope, qualified: true, operation });
+        request.reply!({
+          ...envelope,
+          qualified: true,
+          operation,
+          ...(request.includeFinal === true && operation ? { final: operationFinal(session, operation) } : {}),
+        });
       } catch (error) {
         request.reply!({ ...envelope, qualified: false, operation: null, reason: String(error) });
       }
@@ -172,6 +179,7 @@ export function registerRuntimeSnapshot(
         }
         if (sequence !== bindSequence || session.reloadLifecycle !== lifecycle) return;
         lifecycle.runtimeSettlement = runtime;
+        bindOperationFinals(session, sessionId, cwd);
         bound = { sessionId, cwd, lifecycle: session.reloadLifecycle };
       } catch (error) {
         if (sequence === bindSequence && session.reloadLifecycle === lifecycle) problem = String(error);

package/extensions/session.ts

@@ -694,14 +694,9 @@ export function createGrantsSession(
         skillPaths: skillPathsFromCatalog(await delegationCatalog(session)),
         // ADR-0016: operator-authored SKILL.md definitions, so `delegate({agent})` can name one.
         definitions: session.definitions,
-        // The herdr executor drives the child after starting it, so its plan must NOT carry `--print`.
-        // Threaded through the plan rather than patched afterwards: the argv is what the ledger records, and
-        // an executor quietly rewriting it would make the record describe a spawn that did not happen.
-        //
-        // Read live off `session.executor` (ADR-0031) rather than a boolean captured in the factory: the probe
-        // has not run when this session object is built, so a captured value would plan `--print` for a session
-        // that turns out to use panes — and `runHerdrPane` refuses a plan containing `--print` by design.
-        interactive: false, // Both qualified backends use the same one-shot Pi JSON protocol.
+        // Plan the real terminal invocation explicitly; the captured backend remains one-shot JSON.
+        // Read the selected executor at dispatch, after its live qualification completes.
+        interactive: session.executor.kind === "herdr",
         ...(approved ? { approved } : {}),
       };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-daddy",
-  "version": "0.48.2",
+  "version": "0.49.0",
   "description": "Capability governance for pi sub-agents: spawn Agent Skills (SKILL.md) definitions whose allowed-tools becomes a grant that can only narrow going down a delegation tree, enforced by pi's own --tools allowlist, with an append-only ledger.",
   "keywords": [
     "pi-package",

package/src/cli.ts

@@ -50,6 +50,7 @@ Usage:
   pi-daddy report [--since <date>] [--definition <name>] [--model <id>]
                   [--group-by definition|model|thinking] [--json]
   pi-daddy outcomes                       append changed episode outcomes from Git and CI
+  pi-daddy diagnostics export <selection.json> <new-directory>  private filtered local evidence
   pi-daddy --help | --version
 
 init references skills already enabled in Pi at their installed or local paths. Legacy unregistered npm
@@ -61,8 +62,11 @@ stays unspawnable. Capabilities that can change your machine
             It never rewrites ${SETTINGS_REL} — delete that file if you want it regenerated.`;
 
 export interface ParsedArgs {
-  command: "init" | "ledger-repair" | "ledger-import" | "report" | "outcomes" | "help" | "version";
+  command:
+    "init" | "ledger-repair" | "ledger-import" | "report" | "outcomes" | "diagnostics-export" | "help" | "version";
   importTarget?: string;
+  selectionPath?: string;
+  exportDirectory?: string;
   /** `ledger repair <path>`: the ledger file; `yes` applies, otherwise preview only. */
   ledgerPath?: string;
   yes?: boolean;
@@ -91,6 +95,19 @@ export function parseArgs(argv: string[]): ParsedArgs {
   if (args.includes("--version") || args.includes("-v")) return { command: "version", force: false, errors: [] };
 
   const [command, ...tail] = args;
+  if (command === "diagnostics") {
+    const [verb, selectionPath, exportDirectory, ...extra] = tail;
+    if (
+      verb !== "export" ||
+      !selectionPath ||
+      !exportDirectory ||
+      selectionPath.startsWith("-") ||
+      exportDirectory.startsWith("-") ||
+      extra.length
+    )
+      return { command: "help", force: false, errors: ["diagnostics needs: export <selection.json> <new-directory>"] };
+    return { command: "diagnostics-export", force: false, errors: [], selectionPath, exportDirectory };
+  }
   if (command === "ledger") {
     // ADR-0076 PR 3d: `ledger repair <path> [--yes]` previews, --yes truncates; `ledger import <source> <target>`.
     const [verb, target, ...flags] = tail;
@@ -388,6 +405,12 @@ export async function main(
     console.log(USAGE);
     return 0;
   }
+  if (parsed.command === "diagnostics-export") {
+    const { exportDiagnostics } = await import("./products/diagnostic-export.ts");
+    const result = await exportDiagnostics(parsed.selectionPath!, parsed.exportDirectory!);
+    console.log(JSON.stringify(result));
+    return result.missing ? 1 : 0;
+  }
   if (parsed.command === "outcomes") {
     const cwd = process.cwd();
     const result = await updateEpisodeOutcomes({

package/src/executors/captured-execution.ts

@@ -2,6 +2,7 @@
 import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { runOwnedChild, type OwnedChildRunRequest, type OwnedChildRunResult } from "./owned-worker.ts";
 import type { BoundedReadCleanupError } from "../kernel/bounded-read.ts";
 import { ChildFinalCapture, type ChildFinal } from "./child-final.ts";
@@ -36,7 +37,18 @@ export async function runCapturedExecution(
     };
   }
   const capture = new ChildFinalCapture(request.onOutput, request.onReadCleanup);
-  const args = [...request.args.slice(0, -1), "--mode", "json", request.args.at(-1)!];
+  const args = [...request.args];
+  if (request.terminalUi) {
+    const extension = (name: string) =>
+      fileURLToPath(new URL("./" + name + (import.meta.url.endsWith(".ts") ? ".ts" : ".js"), import.meta.url));
+    // Pi enables editor commands before awaiting session_start handlers. The view guard must be first;
+    // the event observer remains last so earlier message transformations are captured exactly.
+    const firstExtension = args.findIndex(
+      (arg, index) => index < args.length - 1 && ["--no-extensions", "-ne", "-e", "--extension"].includes(arg),
+    );
+    args.splice(firstExtension < 0 ? args.length - 1 : firstExtension, 0, "-e", extension("owned-pi-view"));
+    args.splice(args.length - 1, 0, "-e", extension("owned-pi-ui"), "--tui-mode", "regular");
+  } else args.splice(args.length - 1, 0, "--mode", "json");
   const output = await runOwned({
     ...request,
     args,

package/src/executors/herdr-launcher.ts

@@ -10,6 +10,7 @@ export async function launchHerdrWorker(socketPath: string, token: string): Prom
   const abort = new AbortController();
   let started = false,
     authenticated = false,
+    terminalUi = false,
     acknowledge: (() => void) | undefined,
     rejectGate: ((error: Error) => void) | undefined;
   const lost = (error: Error) => {
@@ -32,7 +33,7 @@ export async function launchHerdrWorker(socketPath: string, token: string): Prom
         return;
       }
       if (message?.type === "display" && authenticated && typeof message.text === "string") {
-        process.stdout.write(message.text);
+        if (!terminalUi) process.stdout.write(message.text);
         return;
       }
       if (message?.type !== "request" || started) {
@@ -43,11 +44,14 @@ export async function launchHerdrWorker(socketPath: string, token: string): Prom
       started = true;
       authenticated = true;
       const request = message.request as OwnedChildRunRequest & { sessionPath?: string };
+      terminalUi = request.terminalUi === true;
       let childPid: number | undefined;
       const display = herdrAgentDisplay(message.display);
       let settled = false;
       void (async () => {
+        const wasRaw = process.stdin.isRaw;
         try {
+          if (terminalUi && process.stdin.isTTY) process.stdin.setRawMode(true);
           const result = await runOwnedChild({
             ...request,
             signal: abort.signal,
@@ -88,10 +92,13 @@ export async function launchHerdrWorker(socketPath: string, token: string): Prom
               childPid = pid;
               void display.working();
               send({ type: "spawned", pid });
-              process.stdout.write("pi-daddy: governed child running\n");
+              if (!terminalUi) process.stdout.write("pi-daddy: governed child running\n");
             },
           });
           settled = result.cleanup.state === "settled" || result.cleanup.state === "not-started";
+          // Mark only this owned terminal as settled; this is cosmetic, not process or sidebar authority.
+          // Unknown cleanup keeps its existing title, and a killed launcher cannot reset it.
+          if (terminalUi && settled) process.stdout.write("\x1b]0;Task settled\x07");
           const displayReleased = await display.finish(settled);
           if (!socket.destroyed) {
             send({ type: "result", result, displayReleased: settled && displayReleased });
@@ -107,6 +114,12 @@ export async function launchHerdrWorker(socketPath: string, token: string): Prom
               socket.end();
             }
           }
+        } finally {
+          try {
+            if (terminalUi && process.stdin.isTTY) process.stdin.setRawMode(wasRaw);
+          } catch {
+            // A lost pane cannot be restored; native cleanup remains independently recorded.
+          }
         }
       })();
     },

package/src/executors/owned-pi-ui.ts

@@ -0,0 +1,116 @@
+/** Install LAST: observe final extension-transformed Pi events through the private inherited pipe. */
+import { fstatSync } from "node:fs";
+import { Socket } from "node:net";
+import { getAgentDir, ProjectTrustStore, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, MessageUpdateEvent } from "@earendil-works/pi-coding-agent";
+
+import { OWNED_PI_VIEW_READY, failOwnedPiUi as fail } from "./owned-pi-view.ts";
+
+const EVENT_FD = 6;
+
+export default function ownedPiUi(pi: ExtensionAPI): void {
+  try {
+    const channel = fstatSync(EVENT_FD);
+    if (!channel.isFIFO() && !channel.isSocket()) throw Error("fd 6 is not an inherited event pipe");
+    const output = new Socket({ fd: EVENT_FD, readable: false, writable: true });
+    output.on("error", fail);
+    let pending = Promise.resolve();
+    const send = (event: unknown): Promise<void> => {
+      let record: string;
+      try {
+        record = JSON.stringify(event) + "\n";
+      } catch (error) {
+        return fail(error);
+      }
+      pending = pending
+        .then(
+          () =>
+            new Promise<void>((resolve) => {
+              output.write(record, (error) => (error ? fail(error) : resolve()));
+            }),
+        )
+        .catch(fail);
+      return pending;
+    };
+    // Keep the previous noninteractive trust policy; native UI must not introduce a blocking trust dialog.
+    pi.on("project_trust", (event) => {
+      try {
+        const agentDir = getAgentDir();
+        const remembered = new ProjectTrustStore(agentDir).get(event.cwd);
+        const trusted =
+          remembered ??
+          SettingsManager.create(event.cwd, agentDir, { projectTrusted: false }).getDefaultProjectTrust() === "always";
+        return { trusted: trusted ? "yes" : "no", remember: false };
+      } catch (error) {
+        return fail(error);
+      }
+    });
+    let guardedSession: { sessionManager: unknown; sessionId: unknown } | undefined;
+    pi.events.on(OWNED_PI_VIEW_READY, (ready) => {
+      if (ready && typeof ready === "object" && "sessionManager" in ready && "sessionId" in ready)
+        guardedSession = { sessionManager: ready.sessionManager, sessionId: ready.sessionId };
+    });
+    let started = false;
+    pi.on("session_start", (_event, ctx) => {
+      try {
+        if (started) throw Error("the owned session cannot be replaced");
+        if (
+          ctx.mode !== "tui" ||
+          guardedSession?.sessionManager !== ctx.sessionManager ||
+          guardedSession.sessionId !== ctx.sessionManager.getSessionId()
+        )
+          throw Error("the native Pi view guard is not ready for this session");
+        const header = ctx.sessionManager.getHeader();
+        if (
+          !header ||
+          header.type !== "session" ||
+          header.version !== 3 ||
+          header.id !== ctx.sessionManager.getSessionId()
+        )
+          throw Error("missing or mismatched actual Pi session header");
+        started = true;
+        return send(header);
+      } catch (error) {
+        return fail(error);
+      }
+    });
+    const forward = (event: unknown): Promise<void> => {
+      if (!started) fail("Pi event arrived before the guarded session");
+      return send(event);
+    };
+    pi.on("agent_start", forward);
+    pi.on("agent_end", forward);
+    pi.on("turn_start", forward);
+    pi.on("turn_end", forward);
+    pi.on("message_start", forward);
+    pi.on("message_end", forward);
+    pi.on("tool_execution_start", forward);
+    pi.on("tool_execution_update", forward);
+    pi.on("tool_execution_end", forward);
+    pi.on("message_update", (event: MessageUpdateEvent) => {
+      // Match Pi's JSON delta projection without copying growing partial-message snapshots.
+      if (event.message.role !== "assistant") fail("message_update is not an assistant message");
+      const usage = event.message.usage,
+        update = event.assistantMessageEvent;
+      if (!("partial" in update)) return forward({ type: event.type, usage, assistantMessageEvent: update });
+      const { partial, ...delta } = update;
+      if (update.type === "toolcall_start") {
+        const tool = partial.content[update.contentIndex];
+        if (tool?.type !== "toolCall") fail("toolcall_start lacks its actual tool call");
+        return forward({
+          type: event.type,
+          usage,
+          assistantMessageEvent: { ...delta, id: tool.id, toolName: tool.name },
+        });
+      }
+      return forward({ type: event.type, usage, assistantMessageEvent: delta });
+    });
+    pi.on("agent_settled", async (event, ctx) => {
+      await forward(event);
+      // The pipe has flushed before orderly shutdown; native receipt/session checks remain authoritative.
+      ctx.shutdown();
+    });
+  } catch (error) {
+    fail(error);
+  }
+}

package/src/executors/owned-pi-view.ts

@@ -0,0 +1,58 @@
+/** Install FIRST: native Pi remains observable, but only its parent can control work. */
+import { writeSync } from "node:fs";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export const OWNED_PI_VIEW_READY = "pi-daddy:owned-pi-view-ready";
+export function failOwnedPiUi(error: unknown): never {
+  try {
+    writeSync(2, "pi-daddy: owned Pi UI refused: " + String(error) + "\n");
+  } finally {
+    process.exit(70);
+  }
+}
+
+export default function ownedPiView(pi: ExtensionAPI): void {
+  try {
+    if (typeof pi.registerMarkdownTransformer !== "function") throw Error("Pi lacks its public markdown renderer hook");
+    pi.registerMarkdownTransformer((markdown, context) =>
+      context.messageType === "assistant-thinking" ? "Thinking hidden" : markdown,
+    );
+    let guarded = false;
+    // No await here: the first session handler installs the guard before another handler can yield.
+    pi.on("session_start", (_event, ctx) => {
+      try {
+        if (guarded) throw Error("the owned session cannot be replaced");
+        if (
+          ctx.mode !== "tui" ||
+          typeof ctx.ui.onTerminalInput !== "function" ||
+          typeof ctx.ui.getToolsExpanded !== "function" ||
+          typeof ctx.ui.setToolsExpanded !== "function"
+        )
+          throw Error("Pi lacks the required native TUI controls");
+        const unsubscribe = ctx.ui.onTerminalInput((data) => {
+          // The renderer consumes this exact terminal response before dispatching any user action.
+          if (/^\x1b\[6;\d+;\d+t$/.test(data)) return;
+          try {
+            if (["\x0f", "\x1b[111;5u", "\x1b[111;5:1u", "\x1b[111;5:2u", "\x1b[27;5;111~"].includes(data))
+              ctx.ui.setToolsExpanded(!ctx.ui.getToolsExpanded());
+          } catch (error) {
+            failOwnedPiUi(error);
+          }
+          return { consume: true };
+        });
+        if (typeof unsubscribe !== "function") throw Error("Pi did not install the terminal input guard");
+        ctx.ui.setEditorText("");
+        ctx.ui.setStatus("pi-daddy-owned", "View only · parent controls the task · Ctrl+O expands tools");
+        guarded = true;
+        pi.events.emit(OWNED_PI_VIEW_READY, {
+          sessionManager: ctx.sessionManager,
+          sessionId: ctx.sessionManager.getSessionId(),
+        });
+      } catch (error) {
+        failOwnedPiUi(error);
+      }
+    });
+  } catch (error) {
+    failOwnedPiUi(error);
+  }
+}

package/src/executors/owned-worker.ts

@@ -25,6 +25,8 @@ export interface OwnedChildRunRequest extends ChildRunRequest {
   onOwnership?: (identity: CapturedWorkerIdentity) => Promise<void> | void;
   /** JSON protocol consumers observe all bytes without capturing enormous replay streams as answer text. */
   captureStdout?: boolean;
+  /** Actual pane terminal for Pi's native view. Protocol events arrive separately on fd 6. */
+  terminalUi?: boolean;
   /** Bounded diagnostics may truncate without stopping independently captured primary output. */
   stopOnOutputLimit?: boolean;
 }
@@ -46,6 +48,8 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
   if (request.signal?.aborted) return notStarted("cancelled before helper launch", true);
   if (process.platform !== "linux" || process.arch !== "x64")
     return notStarted("captured worker requires qualified Linux x64 helper");
+  if (request.terminalUi && (!process.stdin.isTTY || !process.stdout.isTTY || !process.stderr.isTTY))
+    return notStarted("native Pi view requires a real pane terminal on stdin, stdout and stderr");
   let helper: string, root: string, hash: string;
   const nonce = randomUUID();
   let binary: import("node:fs/promises").FileHandle | undefined;
@@ -95,13 +99,26 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       {
         cwd: root,
         env: request.env,
-        stdio: ["ignore", "pipe", "pipe", "pipe", "pipe", binary!.fd],
-        detached: true,
+        stdio: request.terminalUi
+          ? ["inherit", "inherit", "inherit", "pipe", "pipe", binary!.fd, "pipe"]
+          : ["ignore", "pipe", "pipe", "pipe", "pipe", binary!.fd],
+        // The UI shares the pane's foreground process group for raw input and SIGWINCH.
+        // Cleanup still targets owned descendants by pidfd, never by process group.
+        detached: !request.terminalUi,
       },
     );
     void binary!.close();
     const control = child.stdio[3] as import("node:stream").Duplex;
     const status = child.stdio[4] as import("node:stream").Readable;
+    const streams = {
+      stdout: request.terminalUi ? (child.stdio.at(6) as import("node:stream").Readable) : child.stdout,
+      stderr: child.stderr,
+    };
+    const closeObservations = () => {
+      streams.stdout?.destroy();
+      streams.stderr?.destroy();
+      status.destroy();
+    };
     let identity: CapturedWorkerIdentity | undefined;
     let text = "",
       count = 0,
@@ -146,9 +163,7 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       stopWatchdog = setTimeout(() => {
         failure ??= "worker helper failed to establish cleanup before its bound";
         child.kill("SIGKILL");
-        child.stdout?.destroy();
-        child.stderr?.destroy();
-        status.destroy();
+        closeObservations();
       }, cleanupCeiling + 1000);
     };
     function armIdle() {
@@ -160,10 +175,15 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
         stop();
       }, request.idleTimeoutMs);
     }
-    child.stdout?.on("data", (bytes) => observe("stdout", bytes));
-    child.stderr?.on("data", (bytes) => observe("stderr", bytes));
+    streams.stdout?.on("data", (bytes: Buffer) => observe("stdout", bytes));
+    streams.stderr?.on("data", (bytes: Buffer) => observe("stderr", bytes));
+    for (const stream of Object.values(streams))
+      stream?.on("error", (error) => {
+        failure ??= "child event channel failed: " + String(error);
+        stop();
+      });
     for (const stream of ["stdout", "stderr"] as const)
-      child[stream]?.on("end", () => {
+      streams[stream]?.on("end", () => {
         const tail = decoders[stream].end();
         if (tail && !(stream === "stdout" && request.captureStdout === false)) {
           const kept = takeBytes(tail, Math.max(0, (request.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES) - count));
@@ -276,9 +296,7 @@ export async function runOwnedChild(request: OwnedChildRunRequest): Promise<Owne
       void (async () => {
         if (!identity || !(await readCapturedWorkerReceipt(identity))) {
           failure ??= "helper exited without an independent settlement receipt";
-          child.stdout?.destroy();
-          child.stderr?.destroy();
-          status.destroy();
+          closeObservations();
         }
       })();
     });

package/src/governance/approval-prompt.ts

@@ -80,7 +80,7 @@ export interface PromptOutcome {
 
 export interface ApprovalGateOptions {
   ui: ApprovalUI;
-  /** pi's `ctx.hasUI` — false in print/json mode, and therefore in every governed child. */
+  /** Whether a human can answer here. False in print/json mode and view-only child tabs. */
   hasUI: boolean;
   /** pi's `ctx.mode`, quoted back in the refusal so an operator can see why. */
   mode: string;

package/src/index.ts

@@ -191,3 +191,5 @@ export {
   type WorkspacePins,
   type ParsedPin,
 } from "./kernel/workspace-pin.ts";
+
+export { exportDiagnostics, parseDiagnosticSelection, type DiagnosticSelection } from "./products/diagnostic-export.ts";

package/src/kernel/selected-definitions.ts

@@ -12,7 +12,8 @@ export interface SelectedCommand {
   name: string;
   sourceInfo?: { path?: string };
 }
-const phases = ["plan", "build", "review", "debug", "investigate"];
+const requiredPhases = ["plan", "build", "review", "debug", "investigate"];
+const phases = [...requiredPhases, "test-review"];
 const hash = (value: string) => createHash("sha256").update(value, "utf8").digest("hex");
 const object = (x: unknown): x is Record<string, unknown> => !!x && typeof x === "object" && !Array.isArray(x);
 const exact = (x: Record<string, unknown>, keys: string[]) =>
@@ -57,10 +58,10 @@ async function principalBinding(
     manifest.version !== 1 ||
     manifest.package !== "principal-pi-skills" ||
     !object(manifest.bindings) ||
-    !exact(manifest.bindings, phases)
+    !exact(manifest.bindings, Object.hasOwn(manifest.bindings, "test-review") ? phases : requiredPhases)
   )
     throw Error("invalid Principal binding manifest");
-  for (const name of phases) {
+  for (const name of Object.keys(manifest.bindings)) {
     const row = manifest.bindings[name];
     if (
       !object(row) ||
@@ -74,6 +75,7 @@ async function principalBinding(
     )
       throw Error("invalid Principal binding row");
   }
+  if (!Object.hasOwn(manifest.bindings, phase)) throw Error("selected Principal phase has no binding row");
   const row = manifest.bindings[phase] as Record<string, string>;
   const agentPath = join(root, row.agent);
   if (

package/src/products/dashboard-cli.ts

@@ -376,6 +376,17 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       notice = (await connection.change({ action: "set", edits: trimmed.slice(2).trim() }))
         ? "Session models updated"
         : connection.state.error || "Session controls unavailable";
+    } else if (trimmed.startsWith("limit ")) {
+      const edit = /^limit (wall|idle) ([0-9]+)$/.exec(trimmed);
+      if (!edit) notice = "Use limit wall <seconds> or limit idle <seconds>; 0 restores default";
+      else
+        notice = (await connection.change({
+          action: "set-limit",
+          key: edit[1] as "wall" | "idle",
+          seconds: Number(edit[2]),
+        }))
+          ? "Session limit updated for future children; running children unchanged"
+          : connection.state.error || "Settings unavailable";
     } else notice = display.input(line) ? "" : `Unknown command: ${trimmed}. Press ? for help.`;
     redraw();
   };
@@ -397,7 +408,7 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       redraw();
       return;
     }
-    const action = display.key(
+    let action = display.key(
       key.name === "return"
         ? "return"
         : ["up", "down", "escape", "tab"].includes(key.name || "")
@@ -409,6 +420,32 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       return;
     }
     if (action === "command") command = "";
+    if (action === "setting") {
+      const selected = display.screen.settingKey ?? "auto";
+      const settings = connection.state.snapshot?.settings;
+      if (!settings?.editable) notice = "Settings can only be changed in the connected owning parent";
+      else if (selected === "auto") action = "auto";
+      else if (selected === "wall" || selected === "idle") command = `limit ${selected} `;
+      else if (selected === "descendants") notice = "Startup only: set PI_DADDY_FANOUT before restarting Pi";
+      else if (selected === "depth") notice = "Startup only: set PI_DADDY_MAX_DEPTH before restarting Pi";
+      else if (selected === "perCall") notice = "Children per call is a fixed safety bound";
+      else if (!settings.jev.available)
+        notice = "JEV controls unavailable; load skill-harness in the parent Pi session";
+      else {
+        void connection
+          .change({ action: "set-jev", enabled: !(settings.jev.enabled || settings.jev.pending) })
+          .then((changed) => {
+            const jev = connection.state.snapshot?.settings?.jev;
+            notice = !changed
+              ? connection.state.error || "JEV change already pending"
+              : jev?.pending
+                ? "Complete JEV paid-call and LoRA-storage choices in the parent Pi session"
+                : jev?.error ||
+                  `JEV ${jev?.enabled ? "enabled" : "disabled"}; ${jev?.availability ?? "status unknown"}`;
+            redraw();
+          });
+      }
+    }
     if (action === "auto") {
       const snapshot = connection.state.snapshot;
       if (!snapshot) notice = "Daddy permission controls unavailable";

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

@@ -1,3 +1,4 @@
+import { DASHBOARD_SETTING_KEYS } from "./dashboard-settings.ts";
 /** 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";
@@ -16,16 +17,17 @@ export function createDashboardDisplayControls(details: boolean, ledger: boolean
   return {
     state,
     screen,
-    key(key: string): "auto" | "quit" | "command" | undefined {
+    key(key: string): "auto" | "quit" | "command" | "setting" | undefined {
       if (key === "a") return "auto";
       if (key === "q" || key === "ctrl-c") return "quit";
       if (key === ":") return "command";
+      if (screen.view === "settings" && (key === "return" || key === "d")) return "setting";
       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";
+      } else if (key === "?" || key === "m" || key === "v" || key === "s") {
+        screen.view = key === "?" ? "help" : key === "v" ? "versions" : key === "s" ? "settings" : "models";
         state.activityDetail = undefined;
         screen.offset = 0;
       } else if (key === "return" || key === "d") {
@@ -33,7 +35,11 @@ export function createDashboardDisplayControls(details: boolean, ledger: boolean
         screen.offset = 0;
       } else if (["up", "down", "j", "k"].includes(key)) {
         const delta = key === "up" || key === "k" ? -1 : 1;
-        if (screen.view === "versions") {
+        if (screen.view === "settings") {
+          const index = DASHBOARD_SETTING_KEYS.indexOf(screen.settingKey ?? "auto");
+          screen.settingKey =
+            DASHBOARD_SETTING_KEYS[Math.max(0, Math.min(DASHBOARD_SETTING_KEYS.length - 1, index + delta))];
+        } else 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;