pi-daddy 0.46.1 → 0.47.1

package/src/governance/ledger-report.ts

@@ -211,8 +211,8 @@ export async function verifyLedger(path: string): Promise<LedgerReport> {
         executors: { herdr: 0, process: 0, unknown: 0 },
         definitions: [],
         approvals: {
-          bySource: { prompt: 0, session: 0, persisted: 0, inherited: 0 },
-          distinctBySource: { prompt: 0, session: 0, persisted: 0, inherited: 0 },
+          bySource: { prompt: 0, session: 0, persisted: 0, inherited: 0, auto: 0 },
+          distinctBySource: { prompt: 0, session: 0, persisted: 0, inherited: 0, auto: 0 },
           unattributed: 0,
           humanDenied: 0,
           humanDeniedPairs: 0,
@@ -243,13 +243,14 @@ export async function verifyLedger(path: string): Promise<LedgerReport> {
   let retired = 0;
   let escalationAttempts = 0;
   const executors = { herdr: 0, process: 0, unknown: 0 };
-  const bySource: Record<ApprovalSource, number> = { prompt: 0, session: 0, persisted: 0, inherited: 0 };
+  const bySource: Record<ApprovalSource, number> = { prompt: 0, session: 0, persisted: 0, inherited: 0, auto: 0 };
   // `capability@subject` seen per source, so the report can state a bound as well as a raw count.
   const distinct: Record<ApprovalSource, Set<string>> = {
     prompt: new Set(),
     session: new Set(),
     persisted: new Set(),
     inherited: new Set(),
+    auto: new Set(),
   };
   let unattributed = 0;
   let humanDenied = 0;
@@ -288,6 +289,15 @@ export async function verifyLedger(path: string): Promise<LedgerReport> {
         events += 1;
         return;
       }
+      if (
+        event.ledgerVersion === 3 &&
+        (event.event === "session_config" || event.event === "cost_gate" || event.event === "episode_outcome")
+      ) {
+        // These facts passed the current v3 schema above. They are history, not capability decisions,
+        // and must not inflate approval, executor, lifecycle or retired-event counters.
+        events += 1;
+        return;
+      }
       if (event.ledgerVersion === 3 && isRetiredLedgerEvent(event)) {
         // Written by 0.30.0 or earlier; counted, never treated as corruption (see RETIRED_LEDGER_EVENT_KINDS).
         retired += 1;
@@ -386,6 +396,7 @@ export async function verifyLedger(path: string): Promise<LedgerReport> {
         session: distinct.session.size,
         persisted: distinct.persisted.size,
         inherited: distinct.inherited.size,
+        auto: distinct.auto.size,
       },
       unattributed,
       humanDenied,

package/src/governance/ledger-v3-validation.ts

@@ -21,7 +21,7 @@ export function isRetiredLedgerEvent(event: { event?: unknown }): boolean {
 
 const SHA256_RE = /^[a-f0-9]{64}$/i;
 const EXECUTORS = new Set(["process", "herdr"]);
-const APPROVAL_SOURCES = new Set(["prompt", "session", "persisted", "inherited"]);
+const APPROVAL_SOURCES = new Set(["prompt", "session", "persisted", "inherited", "auto"]);
 const APPROVAL_SCOPES = new Set(["once", "session", "always"]);
 const GATE_OUTCOMES = new Set(["declined", "dismissed", "expired", "aborted", "no-ui", "error"]);
 const LEASE_OUTCOMES = new Set([
@@ -146,7 +146,7 @@ const FIELDS = {
     "outcome",
     "newCeiling",
   ]),
-  session_config: new Set(["ledgerVersion", "event", "ts", "episodeId", "outcome", "trigger", "overrides"]),
+  session_config: new Set(["ledgerVersion", "event", "ts", "episodeId", "outcome", "trigger", "overrides", "autoMode"]),
   episode_outcome: new Set([
     "ledgerVersion",
     "event",
@@ -537,7 +537,7 @@ export function validateLedgerV3Event(event: LedgerV3Object): string | null {
     if (
       !isEpisodeId(event.episodeId) ||
       !["kept", "changed"].includes(String(event.outcome)) ||
-      !["first-delegation", "grants-models"].includes(String(event.trigger)) ||
+      !["first-delegation", "grants-models", "auto-mode"].includes(String(event.trigger)) ||
       !isLedgerObject(event.overrides) ||
       !Object.entries(event.overrides).every(
         ([name, value]) =>
@@ -549,6 +549,20 @@ export function validateLedgerV3Event(event: LedgerV3Object): string | null {
       )
     )
       return "session config fields are invalid";
+    if (event.trigger === "auto-mode") {
+      const auto = event.autoMode;
+      if (
+        event.outcome !== "changed" ||
+        Object.keys(event.overrides).length !== 0 ||
+        !isLedgerObject(auto) ||
+        Object.keys(auto).length !== 3 ||
+        typeof auto.enabled !== "boolean" ||
+        !["default", "environment", "session"].includes(String(auto.source)) ||
+        !Number.isSafeInteger(auto.revision) ||
+        (auto.revision as number) < 0
+      )
+        return "auto mode config fields are invalid";
+    } else if (event.autoMode !== undefined) return "auto mode config requires its own trigger";
     return null;
   }
   if (kind === "episode_outcome") return validateEpisodeOutcome(event);

package/src/governance/ledger.ts

@@ -414,6 +414,7 @@ export {
   buildEpisodeCostGateEvent,
   buildEpisodeOutcomeEvent,
   buildSessionConfigEvent,
+  buildAutoModeConfigEvent,
   buildWorkspaceLeaseEvent,
   type CapabilityDecisionEvent,
   type EpisodeCostGateEvent,

package/src/kernel/approval.ts

@@ -18,7 +18,7 @@ export const APPROVAL_SCOPES = ["once", "session", "always"] as const;
 export type ApprovalScope = (typeof APPROVAL_SCOPES)[number];
 
 /** Where a yes came from, for the ledger. These call for different follow-ups, so they stay distinct. */
-export const APPROVAL_SOURCES = ["prompt", "session", "persisted", "inherited"] as const;
+export const APPROVAL_SOURCES = ["prompt", "session", "persisted", "inherited", "auto"] as const;
 export type ApprovalSource = (typeof APPROVAL_SOURCES)[number];
 
 /** Which call site is asking. Determines the scopes offered — see `offeredScopes`. */

package/src/kernel/auto-mode.ts

@@ -0,0 +1,56 @@
+/** Live session permission policy. This does not widen a grant or convey stored approval. */
+export type AutoModeSource = "default" | "environment" | "session";
+export interface PendingApproval {
+  id: string;
+  subject: string;
+  capability: string;
+}
+export interface AutoModeSnapshot {
+  enabled: boolean;
+  source: AutoModeSource;
+  ownerId: string;
+  revision: number;
+  pendingApprovals: PendingApproval[];
+}
+export interface AutoModeRef {
+  socketPath: string;
+  token: string;
+  ownerId: string;
+}
+export interface AutoModeReader {
+  readonly reference: AutoModeRef;
+  read(): Promise<AutoModeSnapshot>;
+  /** Linearization point: only a current ON answer admits new work. No approval is banked. */
+  admit(signal?: AbortSignal): Promise<boolean>;
+  /** Notification only. A waiter must read again and later admit its own operation. */
+  waitEnabled(signal: AbortSignal): Promise<void>;
+  trackPending(approval: PendingApproval): () => void;
+  close(): Promise<void>;
+}
+export function parseAutoModeDefault(raw: string | undefined): { enabled: boolean; source: AutoModeSource } {
+  if (raw === undefined) return { enabled: false, source: "default" };
+  if (raw === "0" || raw === "1") return { enabled: raw === "1", source: "environment" };
+  throw new Error("PI_DADDY_AUTO_MODE must be literal 1 or 0 (unset defaults to OFF)");
+}
+export function parseAutoModeRef(raw: string): AutoModeRef {
+  let ref: AutoModeRef;
+  try {
+    ref = JSON.parse(raw);
+  } catch {
+    throw new Error("PI_DADDY_AUTO_MODE_REF is malformed");
+  }
+  if (
+    !ref ||
+    typeof ref !== "object" ||
+    Object.keys(ref).sort().join(",") !== "ownerId,socketPath,token" ||
+    typeof ref.socketPath !== "string" ||
+    !ref.socketPath.startsWith("/") ||
+    ref.socketPath.length > 107 ||
+    typeof ref.token !== "string" ||
+    !/^[a-f0-9]{48}$/.test(ref.token) ||
+    typeof ref.ownerId !== "string" ||
+    !/^[a-f0-9]{32}$/.test(ref.ownerId)
+  )
+    throw new Error("PI_DADDY_AUTO_MODE_REF is malformed");
+  return ref;
+}

package/src/kernel/delegate-types.ts

@@ -1,3 +1,4 @@
+import type { AutoModeRef } from "./auto-mode.ts";
 /**
  * The shapes `planDelegation` consumes and produces. Split out of `./delegate.ts` only to stay under the
  * 400-line module ceiling this project enforces mechanically; `./delegate.ts` re-exports all three, so
@@ -58,6 +59,7 @@ export interface DelegationRequest {
 }
 
 export interface DelegationContext {
+  autoModeRef?: AutoModeRef;
   ownGrant: Capability[];
   /** Stable identity shared by the root session and every descendant. */
   episodeId?: string;

package/src/kernel/delegate.ts

@@ -26,6 +26,7 @@ import {
   ENV_PARENT_ID,
   inheritableGrant,
   workspacePinEnv,
+  autoModeEnv,
 } from "./propagation.ts";
 import { DELEGATE_SUBJECT, inheritApprovals, type InheritableApproval } from "./approval.ts";
 import { explainDoubledNamespace, suggestForUnknown, unknownCapabilities, type Catalog } from "./catalog.ts";
@@ -421,7 +422,7 @@ export function planDelegation(request: DelegationRequest, ctx: DelegationContex
   // spelled once in `childEnv` and not here is a rule that does not hold on the path a delegated child
   // actually takes. Without this a routed grandchild inherits no pin and can route nowhere — fail-closed,
   // but wrong, and silently so.
-  Object.assign(env, workspacePinEnv(ctx.workspacePin, inheritable));
+  Object.assign(env, workspacePinEnv(ctx.workspacePin, inheritable), autoModeEnv(ctx.autoModeRef));
   // Composition-supplied per-child environment (the activity timeline's observation identity today).
   // Never process-global grant state: a key in the governance namespace is a programming error in the
   // caller, refused loudly rather than letting a product widen what the child inherits.

package/src/kernel/env-names.ts

@@ -20,6 +20,8 @@ export const ENV_MAX_DEPTH = "PI_DADDY_MAX_DEPTH";
 export const ENV_GATED = "PI_DADDY_GATED";
 export const ENV_LEDGER = "PI_DADDY_LEDGER";
 export const ENV_APPROVED = "PI_DADDY_APPROVED";
+export const ENV_AUTO_MODE = "PI_DADDY_AUTO_MODE";
+export const ENV_AUTO_MODE_REF = "PI_DADDY_AUTO_MODE_REF";
 export const ENV_FANOUT = "PI_DADDY_FANOUT";
 export const ENV_PARENT_ID = "PI_DADDY_PARENT_ID";
 export const ENV_EXECUTION_ID = "PI_DADDY_EXECUTION_ID";
@@ -86,6 +88,8 @@ export const GOVERNANCE_ENV_KEYS: readonly string[] = Object.freeze([
   ENV_GATED,
   ENV_LEDGER,
   ENV_APPROVED,
+  ENV_AUTO_MODE,
+  ENV_AUTO_MODE_REF,
   ENV_FANOUT,
   ENV_PARENT_ID,
   ENV_EXECUTION_ID,

package/src/kernel/propagation.ts

@@ -25,7 +25,8 @@
  * interceptor and pi handed the child more than the parent held, the intersection clamps it back.
  */
 
-import { ENV_PUBLIC_EVIDENCE_DIR } from "./env-names.ts";
+import { ENV_AUTO_MODE, ENV_AUTO_MODE_REF, ENV_PUBLIC_EVIDENCE_DIR } from "./env-names.ts";
+import type { AutoModeRef } from "./auto-mode.ts";
 import type { Capability } from "./resolve.ts";
 import { attenuateWorkspacePin, formatWorkspacePin, type WorkspacePins } from "./workspace-pin.ts";
 import { WILDCARD } from "./pi-tools.ts";
@@ -87,6 +88,8 @@ export {
  * to give it.
  */
 export const GRANT_ENV_KEYS = [
+  ENV_AUTO_MODE,
+  ENV_AUTO_MODE_REF,
   ENV_PUBLIC_EVIDENCE_DIR,
   // Not governance state, but the same rule applies for a stronger reason: neither a credential the parent holds
   // nor the switch that points it at a third party is something a child inherits by being spawned (ADR-0077).
@@ -265,6 +268,7 @@ export function gatedFromEnv(raw: string | undefined): Capability[] {
 }
 
 export interface ChildEnvInput {
+  autoModeRef?: AutoModeRef;
   /** This session's own grant — becomes the child's inherited parent grant. */
   ownGrant: Capability[];
   /**
@@ -362,7 +366,7 @@ export function childEnv(input: ChildEnvInput): Record<string, string> {
   // `ENV_APPROVED` is: an omitted key does not overwrite, so a child would inherit the PARENT's unnarrowed pin
   // through the process-global publication path. An empty value parses back as "a pin was established and you
   // got nothing from it", which refuses at routing with a different message from "no pin exists".
-  Object.assign(env, workspacePinEnv(input.workspacePin, inheritable));
+  Object.assign(env, workspacePinEnv(input.workspacePin, inheritable), autoModeEnv(input.autoModeRef));
   return env;
 }
 
@@ -427,3 +431,8 @@ export function observeToolNames(payload: unknown): string[] | null {
   }
   return null;
 }
+
+/** A root preference is never copied; every descendant receives the same live owner reference. */
+export function autoModeEnv(ref: AutoModeRef | undefined): Record<string, string> {
+  return { [ENV_AUTO_MODE]: "0", ...(ref ? { [ENV_AUTO_MODE_REF]: JSON.stringify(ref) } : {}) };
+}

package/src/products/dashboard-cli.ts

@@ -9,11 +9,12 @@ import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { createInterface } from "node:readline";
+import { createInterface, emitKeypressEvents, type Key } from "node:readline";
 import { parseDashboardLedger } from "./dashboard-projection.ts";
 import { renderDashboard } from "./dashboard-render.ts";
 import {
   ActivityTimelineAliases,
+  activityTaskKey,
   defaultActivityTimelinePath,
   detailForTimeline,
   parseActivityTimeline,
@@ -22,9 +23,20 @@ import {
   type TimelineFilter,
 } from "./activity-timeline.ts";
 import { createDashboardDisplayControls } from "./dashboard-display-controls.ts";
-import { dashboardSessionRequest, type DashboardSessionSnapshot } from "./dashboard-session-client.ts";
+import {
+  createDashboardConnection,
+  dashboardSessionRequest,
+  type DashboardSessionSnapshot,
+} from "./dashboard-session-client.ts";
 import { adoptLegacyEnvironment, ENV_LEDGER, legacyEnvironmentWarning } from "../kernel/env-names.ts";
 import { projectLedgerPath } from "../kernel/project-paths.ts";
+import {
+  activityDashboardItems,
+  ledgerDashboardItems,
+  renderDashboardScreen,
+  type DashboardItem,
+  type DashboardScreenState,
+} from "./dashboard-screen.ts";
 
 export const DASHBOARD_PROTOCOL_VERSION = 1 as const;
 export const ENV_DASHBOARD_LEDGER = ENV_LEDGER; // one ledger path variable for children and the dashboard (ADR-0076 PR 3b)
@@ -47,6 +59,11 @@ export interface DashboardFrameOptions {
   activityAliases?: ActivityTimelineAliases;
   now?: Date;
   session?: DashboardSessionSnapshot;
+  height?: number;
+  screen?: DashboardScreenState;
+  notice?: string;
+  pending?: boolean;
+  command?: string;
 }
 
 function shellQuote(value: string): string {
@@ -102,7 +119,106 @@ async function renderTimelineFile(path: string, text: string, options: Dashboard
   });
 }
 
+function isActivityTimelineText(text: string): boolean {
+  try {
+    const first = JSON.parse(text.trimStart().split("\n")[0] || "{}");
+    return first?.kind === "activity" || first?.version === 1;
+  } catch {
+    return false;
+  }
+}
+
+async function compactFrame(options: DashboardFrameOptions): Promise<string> {
+  const path = resolve(options.cwd, options.ledgerPath ?? defaultActivityTimelinePath(options.cwd));
+  let items: DashboardItem[] = [],
+    problem: string | undefined,
+    current: string | undefined,
+    currentStatus: string | undefined;
+  let content: { title: string; text: string } | undefined;
+  const aliases = options.activityAliases ?? new ActivityTimelineAliases();
+  if (options.protocol !== undefined && options.protocol !== DASHBOARD_PROTOCOL_VERSION)
+    return renderDashboardScreen({
+      ...options,
+      width: options.width ?? 80,
+      height: options.height!,
+      screen: options.screen!,
+      items: [],
+      problem: "INCOMPATIBLE dashboard protocol; relink this package.",
+    });
+  try {
+    const text = await readFile(path, "utf8");
+    if (!options.ledgerPath || isActivityTimelineText(text)) {
+      const timeline = parseActivityTimeline(text);
+      items = activityDashboardItems(timeline, aliases, options.now ?? new Date()).map((item) => ({
+        ...item,
+        timelinePath: path,
+      }));
+      problem = timeline.refusals[0];
+    } else {
+      const projection = parseDashboardLedger(text, { now: options.now });
+      items = ledgerDashboardItems(projection);
+      if (projection.corrupt.length) problem = `Ledger unavailable: ${projection.corrupt.length} corrupt line(s)`;
+    }
+  } catch (error) {
+    problem =
+      (error as { code?: string }).code === "ENOENT"
+        ? "Waiting for local work; open from /grants dashboard."
+        : `Evidence unavailable: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  // The owner supplies this exact current turn. No sibling timeline or unrelated history is merged.
+  const activity = options.session?.activity;
+  if (activity) {
+    const key = activityTaskKey(activity.rootId, activity.taskId);
+    current = `Task ${activity.taskId}`;
+    try {
+      const timeline = parseActivityTimeline(await readFile(activity.path, "utf8"));
+      timeline.tasks = timeline.tasks.filter((task) => activityTaskKey(task.rootId, task.id) === key);
+      const item = activityDashboardItems(timeline, aliases, options.now ?? new Date())[0];
+      if (item) {
+        current = item.label;
+        currentStatus = item.status;
+        if (!items.some((existing) => existing.key === key)) items.unshift({ ...item, timelinePath: activity.path });
+        try {
+          current = (await detailForTimeline(activity.path, key, "prompt")).text.slice(0, 600);
+        } catch {
+          /* Metadata-only/off and unavailable retained content retain the exact task identity. */
+        }
+      }
+    } catch {
+      /* The owner identity remains useful when its local timeline is unavailable. */
+    }
+  }
+  if (options.activityDetail) {
+    try {
+      const requested = aliases.resolve(options.activityDetail.taskKey) ?? options.activityDetail.taskKey;
+      const key = items.find((value) => value.taskKey === requested)?.taskKey;
+      if (!key) throw Error("unknown task selector");
+      options.screen!.selectedKey = key;
+      const source = items.find((value) => value.taskKey === key)?.timelinePath;
+      if (!source) throw Error("task has no retained activity source");
+      content = {
+        title: `PRIVATE ${options.activityDetail.field.toUpperCase()}`,
+        text: (await detailForTimeline(source, key, options.activityDetail.field)).text,
+      };
+    } catch (error) {
+      problem = `Activity detail unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  return renderDashboardScreen({
+    ...options,
+    width: options.width ?? 80,
+    height: options.height!,
+    screen: options.screen!,
+    items,
+    problem,
+    content,
+    current,
+    currentStatus,
+  });
+}
+
 export async function dashboardFrame(options: DashboardFrameOptions): Promise<string> {
+  if (options.screen && options.height !== undefined) return compactFrame(options);
   if (options.protocol !== undefined && options.protocol !== DASHBOARD_PROTOCOL_VERSION) {
     return incompatibleFrame(options.protocol);
   }
@@ -136,7 +252,7 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
       ].join("\n");
     }
   }
-  const rendered = text.trimStart().startsWith('{"version":1')
+  const rendered = isActivityTimelineText(text)
     ? await renderTimelineFile(ledgerPath, text, options)
     : renderDashboard(parseDashboardLedger(text, { now: options.now }), {
         color: options.color,
@@ -186,17 +302,21 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   process.title = `pi-daddy-dashboard${key ? `:${key.slice(0, 12)}` : ""}`;
 
   const display = createDashboardDisplayControls(cli.details, true);
-  let previous = "";
-  let notice = "";
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !cli.once;
+  const connection = createDashboardConnection(
+    sessionSocket && sessionToken
+      ? (action) => dashboardSessionRequest(sessionSocket, sessionToken, action)
+      : undefined,
+  );
+  let previous = "",
+    notice = "",
+    command: string | undefined;
   let input: ReturnType<typeof createInterface> | null = null;
+  let stopped = false,
+    drawing = false;
   const draw = async (clear: boolean): Promise<void> => {
-    let session: DashboardSessionSnapshot | undefined;
-    if (sessionSocket && sessionToken)
-      try {
-        session = await dashboardSessionRequest(sessionSocket, sessionToken, { action: "get" });
-      } catch (error) {
-        notice ||= `session controls unavailable: ${error instanceof Error ? error.message : String(error)}`;
-      }
+    await connection.refresh();
+    if (stopped) return;
     const view = await dashboardFrame({
       cwd,
       ledgerPath,
@@ -205,62 +325,145 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       width: process.stdout.columns || 80,
       ...display.state,
       activityAliases: display.aliases,
-      session,
+      session: connection.state.snapshot,
+      ...(interactive
+        ? {
+            height: process.stdout.rows || 24,
+            screen: display.screen,
+            notice: connection.state.error || notice,
+            pending: connection.state.pending,
+            command,
+          }
+        : {}),
     });
-    const frame = notice ? `${notice}\n\n${view}` : view;
-    if (frame === previous && !clear) return;
-    previous = frame;
-    const prompt = display.prompt();
-    const draft = input?.line ?? "";
+    if (stopped) return; // A read may complete after q/SIGTERM restored the parent terminal.
+    const frame = interactive
+      ? view
+      : `${connection.state.error || notice ? `${connection.state.error || notice}\n\n` : ""}${view}`;
+    const prompt = display.prompt(),
+      draft = input?.line ?? "";
+    const rendered = `${frame}${!interactive && input ? `\n\n${prompt}${draft}` : ""}`;
+    if (rendered === previous) return;
+    previous = rendered;
     process.stdout.write(
-      clear ? `\u001b]0;PI-DADDY\u0007\u001b[2J\u001b[H${frame}\n\n${input ? prompt + draft : ""}` : `${frame}\n`,
+      interactive
+        ? // 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`,
     );
-    if (input) input.setPrompt(prompt);
+    input?.setPrompt(prompt);
   };
-
   if (cli.once) {
     await draw(false);
     return;
   }
-  input = createInterface({ input: process.stdin, output: process.stdout, terminal: Boolean(process.stdin.isTTY) });
-  await draw(true);
-  let drawing = false;
   const redraw = (): void => {
-    if (drawing) return;
+    if (drawing || stopped) return;
     drawing = true;
-    void draw(true).finally(() => {
-      drawing = false;
-    });
+    void draw(true)
+      .catch((error) => {
+        notice = `Dashboard unavailable: ${String(error)}`;
+      })
+      .finally(() => {
+        drawing = false;
+      });
   };
-  input.on("line", (line) => {
+  const runCommand = async (line: string): Promise<void> => {
     const trimmed = line.trim();
-    if (trimmed.startsWith("m ") && sessionSocket && sessionToken) {
-      void dashboardSessionRequest(sessionSocket, sessionToken, { action: "set", edits: trimmed.slice(2).trim() })
-        .then(() => {
-          notice = "session model defaults updated";
-        })
-        .catch((error) => {
-          notice = `model edit refused: ${error instanceof Error ? error.message : String(error)}`;
-        })
-        .finally(redraw);
+    if (trimmed.startsWith("m ")) {
+      notice = (await connection.change({ action: "set", edits: trimmed.slice(2).trim() }))
+        ? "Session models updated"
+        : connection.state.error || "Session controls unavailable";
+    } else notice = display.input(line) ? "" : `Unknown command: ${trimmed}. Press ? for help.`;
+    redraw();
+  };
+  let stop: () => void = () => {};
+  const keypress = (text: string | undefined, key: Key): void => {
+    if (key.ctrl && key.name === "c") {
+      stop();
+      return;
+    }
+    if (command !== undefined) {
+      if (key.name === "escape") command = undefined;
+      else if (key.name === "return") {
+        const line = command;
+        command = undefined;
+        void runCommand(line);
+      } else if (key.name === "backspace") command = [...command].slice(0, -1).join("");
+      else if (text && !key.ctrl && !key.meta && !/[\p{Cc}\p{Cf}]/u.test(text) && command.length < 2048)
+        command += text;
+      redraw();
+      return;
+    }
+    const action = display.key(
+      key.name === "return"
+        ? "return"
+        : ["up", "down", "escape", "tab"].includes(key.name || "")
+          ? key.name!
+          : text || "",
+    );
+    if (action === "quit") {
+      stop();
       return;
     }
-    // Rule 8: a line the display controls do not understand is said so, never swallowed.
-    notice = display.input(line) ? "" : `not a display command: ${JSON.stringify(trimmed)}. ${display.prompt()}`;
+    if (action === "command") command = "";
+    if (action === "auto") {
+      const snapshot = connection.state.snapshot;
+      if (!snapshot) notice = "Daddy permission controls unavailable";
+      else {
+        const enabled = !snapshot.auto.enabled;
+        void connection.change({ action: "set-auto", enabled }).then((changed) => {
+          notice = changed
+            ? `Daddy permission Auto ${enabled ? "ON" : "OFF"}; ${enabled ? "future prompts auto-approved" : "admitted work continues"}`
+            : connection.state.error || "Permission change already pending";
+          redraw();
+        });
+      }
+    }
     redraw();
-  });
-  const timer = setInterval(redraw, DASHBOARD_REFRESH_MS);
-  process.on("SIGWINCH", redraw);
-  await new Promise<void>((settle) => {
-    const stop = () => {
-      clearInterval(timer);
-      input?.close();
-      process.off("SIGWINCH", redraw);
-      settle();
-    };
-    process.once("SIGINT", stop);
-    process.once("SIGTERM", stop);
-  });
+  };
+  let timer: ReturnType<typeof setInterval> | undefined;
+  const oldRaw = process.stdin.isRaw;
+  try {
+    if (interactive) {
+      emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdout.write("\u001b[?1049h\u001b[?25l");
+    } else {
+      input = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+      input.on("line", (line) => {
+        void runCommand(line);
+      });
+    }
+    await new Promise<void>((settle) => {
+      stop = () => {
+        stopped = true;
+        settle();
+      };
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      if (interactive) process.stdin.on("keypress", keypress);
+      process.on("SIGWINCH", redraw);
+      timer = setInterval(redraw, DASHBOARD_REFRESH_MS);
+      redraw();
+    });
+  } finally {
+    stopped = true;
+    if (timer) clearInterval(timer);
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+    process.off("SIGWINCH", redraw);
+    input?.close();
+    if (interactive) {
+      process.stdin.off("keypress", keypress);
+      process.stdin.setRawMode(oldRaw || false);
+      process.stdin.pause();
+      process.stdout.write("\u001b[?25h\u001b[?1049l");
+    }
+  }
 }
 
 const invoked = (() => {