@gotgenes/pi-permission-system 20.1.0 → 20.3.0

package/src/authority/forwarding-io.ts

@@ -15,6 +15,7 @@ import {
   createPermissionForwardingLocation,
   type ForwardedPermissionRequest,
   type ForwardedPermissionResponse,
+  type ForwardedSessionApproval,
   type PermissionForwardingLocation,
 } from "#src/permission-forwarding";
 import type { DebugReviewLogger } from "#src/session-logger";
@@ -41,6 +42,31 @@ function asNullableDisplayString(value: unknown): string | null | undefined {
   return undefined;
 }
 
+/**
+ * Narrow an unknown value to a `ForwardedSessionApproval`, or `undefined`.
+ *
+ * Tolerant read: the child's session-approval suggestion is optional (absent
+ * on an older child) and only accepted when well-formed — a non-empty surface
+ * and an all-string patterns array.
+ */
+function asForwardedSessionApproval(
+  value: unknown,
+): ForwardedSessionApproval | undefined {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  const candidate = value as Partial<ForwardedSessionApproval>;
+  if (
+    typeof candidate.surface !== "string" ||
+    candidate.surface.length === 0 ||
+    !Array.isArray(candidate.patterns) ||
+    !candidate.patterns.every((pattern) => typeof pattern === "string")
+  ) {
+    return undefined;
+  }
+  return { surface: candidate.surface, patterns: [...candidate.patterns] };
+}
+
 export function formatUnknownErrorMessage(error: unknown): string {
   if (error instanceof Error && error.message) {
     return error.message;
@@ -323,6 +349,7 @@ export function readForwardedPermissionRequest(
       source: asUiPromptSource(parsed.source),
       surface: asNullableDisplayString(parsed.surface),
       value: asNullableDisplayString(parsed.value),
+      sessionApproval: asForwardedSessionApproval(parsed.sessionApproval),
     };
   } catch (error) {
     logPermissionForwardingWarning(

package/src/authority/local-user-authorizer.ts

@@ -1,13 +1,15 @@
+import { buildForwardedScopeLabels } from "#src/pattern-suggest";
 import type {
   PermissionDecisionUi,
   PermissionPromptDecision,
+  RequestPermissionOptions,
   requestPermissionDecisionFromUi,
 } from "#src/permission-dialog";
 import {
   emitUiPromptEvent,
   type PermissionEventBus,
 } from "#src/permission-events";
-import { buildDirectUiPrompt } from "#src/permission-ui-prompt";
+import { buildUiPrompt } from "#src/permission-ui-prompt";
 import type { Authorizer } from "./authorizer";
 import type { PromptPermissionDetails } from "./permission-prompter";
 
@@ -26,7 +28,10 @@ export interface LocalUserAuthorizerDeps {
  *
  * Emits the `permissions:ui_prompt` broadcast (moved here from
  * `PermissionPrompter`'s `ctx.hasUI` arm) before showing the dialog, so
- * observers know a decision is imminent.
+ * observers know a decision is imminent. This is the single emit site: a
+ * forwarded ask carries its provenance on `details.forwarding`, which this
+ * class renders (populated `forwarding` context + "(Subagent)" title) so the
+ * broadcast stays non-degraded (#292) without a second emission path.
  */
 export class LocalUserAuthorizer implements Authorizer {
   constructor(private readonly deps: LocalUserAuthorizerDeps) {}
@@ -34,13 +39,38 @@ export class LocalUserAuthorizer implements Authorizer {
   authorize(
     details: PromptPermissionDetails,
   ): Promise<PermissionPromptDecision> {
-    const uiPrompt = buildDirectUiPrompt(details);
+    const uiPrompt = buildUiPrompt(details);
     emitUiPromptEvent(this.deps.events, uiPrompt);
     return this.deps.requestPermissionDecisionFromUi(
       this.deps.ui,
-      "Permission Required",
+      details.forwarding
+        ? "Permission Required (Subagent)"
+        : "Permission Required",
       details.message,
-      details.sessionLabel ? { sessionLabel: details.sessionLabel } : undefined,
+      buildRequestOptions(details),
     );
   }
 }
+
+/**
+ * A forwarded ask carrying a session-approval suggestion offers the scope
+ * choice (subagent vs whole session); any other ask keeps its single
+ * "for this session" option (custom label when the gate supplied one).
+ */
+function buildRequestOptions(
+  details: PromptPermissionDetails,
+): RequestPermissionOptions | undefined {
+  const pattern = details.sessionApproval?.patterns[0];
+  if (details.forwarding && details.sessionApproval && pattern) {
+    return {
+      sessionScope: buildForwardedScopeLabels(
+        details.forwarding.requesterAgentName,
+        details.sessionApproval.surface,
+        pattern,
+      ),
+    };
+  }
+  return details.sessionLabel
+    ? { sessionLabel: details.sessionLabel }
+    : undefined;
+}

package/src/authority/permission-prompter.ts

@@ -1,9 +1,23 @@
 import type { PermissionPromptDecision } from "#src/permission-dialog";
+import type { ForwardedSessionApproval } from "#src/permission-forwarding";
 import type { ReviewLogger } from "#src/session-logger";
 import type { Authorizer } from "./authorizer";
 
 export type PermissionReviewSource = "tool_call" | "skill_input" | "skill_read";
 
+/**
+ * Provenance of a forwarded ask: who is really asking, one hop below.
+ *
+ * Present on {@link PromptPermissionDetails} only when the ask was forwarded
+ * from a subagent. Structurally identical to the event's `ForwardedPromptContext`
+ * so the details flow straight into `buildUiPrompt`, but declared here to keep
+ * the prompter layer free of an events-module import.
+ */
+export interface ForwardedAskProvenance {
+  requesterAgentName: string | null;
+  requesterSessionId: string | null;
+}
+
 /** Details passed when prompting the user for a permission decision. */
 export interface PromptPermissionDetails {
   requestId: string;
@@ -19,6 +33,19 @@ export interface PromptPermissionDetails {
   toolInputPreview?: string;
   /** Override label for the "for this session" dialog option. */
   sessionLabel?: string;
+  /** Explicit display-surface override (a forwarded ask carries the child's original). */
+  surface?: string | null;
+  /** Explicit display-value override (a forwarded ask carries the child's original). */
+  value?: string | null;
+  /** Present iff this ask was forwarded from a subagent; drives the non-degraded broadcast + "(Subagent)" title. */
+  forwarding?: ForwardedAskProvenance;
+  /**
+   * The session-approval suggestion for this ask. On the child's escalation it
+   * rides into the forwarded request; on the serving node it lets the dialog
+   * offer a whole-session grant scope. Absent when the gate computed no
+   * suggestion.
+   */
+  sessionApproval?: ForwardedSessionApproval;
 }
 
 /**
@@ -75,7 +102,9 @@ export class PermissionPrompter implements PermissionPrompterApi {
         : "permission_request.denied",
       {
         ...details,
-        resolution: decision.state,
+        resolution: decision.confirmationUnavailable
+          ? "confirmation_unavailable"
+          : decision.state,
         denialReason: decision.denialReason,
       },
     );

package/src/handlers/gates/helpers.ts

@@ -53,13 +53,14 @@ export function buildDecisionEvent(
  * @param action    - The gate's resulting action ("allow" | "block").
  * @param hasSession - True when the gate result carries a sessionApproval
  *                    (indicates the user chose "for this session").
- * @param canConfirm - Whether an interactive prompt was available.
+ * @param confirmationUnavailable - True when the denial came from the
+ *                    DenyingAuthorizer (no live authority was reachable).
  */
 export function deriveResolution(
   state: "allow" | "deny" | "ask",
   action: "allow" | "block",
   hasSession: boolean,
-  canConfirm: boolean,
+  confirmationUnavailable: boolean,
   autoApproved = false,
 ): PermissionDecisionResolution {
   if (state === "allow") return autoApproved ? "auto_approved" : "policy_allow";
@@ -69,5 +70,5 @@ export function deriveResolution(
     if (autoApproved) return "auto_approved";
     return hasSession ? "user_approved_for_session" : "user_approved";
   }
-  return canConfirm ? "user_denied" : "confirmation_unavailable";
+  return confirmationUnavailable ? "confirmation_unavailable" : "user_denied";
 }

package/src/handlers/gates/runner.ts

@@ -1,10 +1,10 @@
+import type { AskEscalator } from "#src/authority/authorizer-selection";
 import type { DecisionReporter } from "#src/decision-reporter";
 import {
   formatDenyReason,
   formatUnavailableReason,
   formatUserDeniedReason,
 } from "#src/denial-messages";
-import type { GatePrompter } from "#src/gate-prompter";
 import type { PermissionPromptDecision } from "#src/permission-dialog";
 import { applyPermissionGate } from "#src/permission-gate";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
@@ -30,7 +30,7 @@ export class GateRunner {
   constructor(
     private readonly resolver: ScopedPermissionResolver,
     private readonly recorder: SessionApprovalRecorder,
-    private readonly prompter: GatePrompter,
+    private readonly prompter: AskEscalator,
     private readonly reporter: DecisionReporter,
   ) {}
 
@@ -127,8 +127,8 @@ export class GateRunner {
       return { action: "allow" };
     }
 
-    // 3. Apply the deny/ask/allow gate
-    const canConfirm = this.prompter.canConfirm();
+    // 3. Apply the deny/ask/allow gate — always escalate on ask; the selected
+    // Authorizer answers (the DenyingAuthorizer by denying with a marker).
 
     // Construct messages from the centralized formatter.
     const messages = {
@@ -139,16 +139,20 @@ export class GateRunner {
     };
 
     let autoApproved = false;
+    let confirmationUnavailable = false;
     const gateResult = await applyPermissionGate({
       state: check.state,
-      canConfirm,
       sessionApproval: descriptor.sessionApproval?.toGateApproval(),
       promptForApproval: async () => {
-        const decision = await this.prompter.prompt({
+        const decision = await this.prompter.escalate({
           requestId: toolCallId,
           ...descriptor.promptDetails,
+          ...(descriptor.sessionApproval
+            ? { sessionApproval: descriptor.sessionApproval.toForwardedData() }
+            : {}),
         });
         autoApproved = decision.autoApproved === true;
+        confirmationUnavailable = decision.confirmationUnavailable === true;
         return decision;
       },
       writeLog: (event, details) =>
@@ -172,7 +176,7 @@ export class GateRunner {
           check.state,
           gateResult.action,
           hasSessionApproval,
-          canConfirm,
+          confirmationUnavailable,
           autoApproved,
         ),
       ),

package/src/index.ts

@@ -3,7 +3,7 @@ import { getAgentDir, getPackageDir } from "@earendil-works/pi-coding-agent";
 import { AuthorizerSelection } from "./authority/authorizer-selection";
 import {
   ForwardedRequestServer,
-  type ForwardedRequestServerDeps,
+  type ServingPolicy,
 } from "./authority/forwarded-request-server";
 import { PermissionPrompter } from "./authority/permission-prompter";
 import { SubagentDetection } from "./authority/subagent-detection";
@@ -25,6 +25,7 @@ import { GateRunner } from "./handlers/gates/runner";
 import { SkillInputGatePipeline } from "./handlers/gates/skill-input-gate-pipeline";
 import { ToolCallGatePipeline } from "./handlers/gates/tool-call-gate-pipeline";
 import { createFailClosedToolCall } from "./handlers/tool-call-boundary";
+import { buildAccessIntentForSurface } from "./input-normalizer";
 import { requestPermissionDecisionFromUi } from "./permission-dialog";
 import { PermissionManager } from "./permission-manager";
 import { PermissionResolver } from "./permission-resolver";
@@ -90,15 +91,6 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
     logger,
   });
 
-  const requestServerDeps: ForwardedRequestServerDeps = {
-    forwardingDir: paths.forwardingDir,
-    logger,
-    events: pi.events,
-    requestPermissionDecisionFromUi,
-    config: configStore,
-  };
-  const requestServer = new ForwardedRequestServer(requestServerDeps);
-
   const prompter = new PermissionPrompter({ logger });
 
   const authorizerSelection = new AuthorizerSelection({
@@ -111,6 +103,42 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
     prompter,
   });
 
+  // Resolver composes the manager + session ruleset and owns the
+  // access-path → path-values unwrap. Constructed here (before `session`) so
+  // the forwarded-request server's ServingPolicy can resolve against it; the
+  // service and gates below share this one instance.
+  const resolver = new PermissionResolver(permissionManager, sessionRules);
+
+  // Serving a forwarded request is resolution: evaluate (surface, value)
+  // against the serving node's composed base ruleset (agentName undefined —
+  // the child already applied its own per-agent overrides before forwarding).
+  // The session.getPathNormalizer() read is deferred behind the closure: inbox
+  // polling starts at session_start, after `session` is assigned — the same
+  // deferred-binding precedent as the logger notify sink below.
+  const servingPolicy: ServingPolicy = {
+    check: (surface, value) =>
+      resolver.resolve(
+        buildAccessIntentForSurface(
+          surface,
+          value ?? undefined,
+          session.getPathNormalizer(),
+          undefined,
+        ),
+      ),
+  };
+
+  const requestServer = new ForwardedRequestServer({
+    forwardingDir: paths.forwardingDir,
+    logger,
+    policy: servingPolicy,
+    escalator: authorizerSelection,
+    // Records a whole-session grant into the same SessionRules the resolver and
+    // gate runner read, so a serving-scope grant governs the parent and future
+    // forwarded resolutions.
+    recorder: sessionRules,
+    registry: subagentRegistry,
+  });
+
   session = new PermissionSession(
     paths,
     new ForwardingManager(subagentDetection, requestServer),
@@ -136,11 +164,6 @@ export default function piPermissionSystemExtension(pi: ExtensionAPI): void {
       ),
   });
 
-  // Resolver composes the manager + session ruleset and owns the
-  // access-path → path-values unwrap; the service routes its policy
-  // queries through it, so it is constructed before it.
-  const resolver = new PermissionResolver(permissionManager, sessionRules);
-
   const permissionsService = new LocalPermissionsService(
     resolver,
     session,

package/src/pattern-suggest.ts

@@ -62,6 +62,35 @@ export function suggestMcpPattern(target: string): string {
   return "*";
 }
 
+/** Scope labels for the forwarded-approval two-step scope select. */
+export interface ForwardedScopeLabels {
+  /** Least-privilege default: record on the requesting subagent only. */
+  subagentLabel: string;
+  /** Record on the serving node — covers the parent and all subagents. */
+  servingSessionLabel: string;
+}
+
+/**
+ * Build the two scope labels shown when a human grants a forwarded request
+ * "for this session."
+ *
+ * The subagent option names the requester (least privilege); the whole-session
+ * option restates the surface + pattern being granted session-wide.
+ */
+export function buildForwardedScopeLabels(
+  agentName: string | null,
+  surface: string,
+  pattern: string,
+): ForwardedScopeLabels {
+  const subagentLabel = agentName
+    ? `This subagent ('${agentName}') only`
+    : "This subagent only";
+  return {
+    subagentLabel,
+    servingSessionLabel: `The whole session — allow ${surface} "${pattern}" for parent and all subagents`,
+  };
+}
+
 /** Surface-aware human-readable labels for the session-approval option. */
 function buildLabel(pattern: string, surface: string): string {
   switch (surface) {

package/src/permission-dialog.ts

@@ -1,6 +1,7 @@
 export type PermissionDecisionState =
   | "approved"
   | "approved_for_session"
+  | "approved_for_serving_session"
   | "denied"
   | "denied_with_reason";
 
@@ -14,6 +15,14 @@ export type PermissionPromptDecision = {
    * rather than "user_approved" in the permissions:decision broadcast.
    */
   autoApproved?: true;
+  /**
+   * True when no live authority was reachable and the DenyingAuthorizer denied
+   * this ask (a no-UI, non-subagent session). Consumed by deriveResolution (the
+   * decision-event resolution), the gate (block reason), and PermissionPrompter
+   * (review-entry resolution) to emit "confirmation_unavailable" rather than a
+   * plain user denial.
+   */
+  confirmationUnavailable?: true;
 };
 
 export interface PermissionDecisionUi {
@@ -59,6 +68,7 @@ export function isPermissionDecisionState(
   return (
     value === "approved" ||
     value === "approved_for_session" ||
+    value === "approved_for_serving_session" ||
     value === "denied" ||
     value === "denied_with_reason"
   );
@@ -67,6 +77,15 @@ export function isPermissionDecisionState(
 export interface RequestPermissionOptions {
   /** Override the "for this session" option label (e.g. to show the suggested pattern). */
   sessionLabel?: string;
+  /**
+   * Forwarded asks only: when set, choosing the "for this session" option opens
+   * a second select asking whether the grant applies to the requesting subagent
+   * only (the least-privilege default) or the whole serving session.
+   */
+  sessionScope?: {
+    subagentLabel: string;
+    servingSessionLabel: string;
+  };
 }
 
 export async function requestPermissionDecisionFromUi(
@@ -95,6 +114,21 @@ export async function requestPermissionDecisionFromUi(
   }
 
   if (selected === sessionOption) {
+    if (options?.sessionScope) {
+      const scope = await ui.select(`${title}\nApply this session grant to:`, [
+        options.sessionScope.subagentLabel,
+        options.sessionScope.servingSessionLabel,
+      ]);
+      return {
+        approved: true,
+        // A cancelled scope select (undefined) falls back to the
+        // least-privilege subagent scope.
+        state:
+          scope === options.sessionScope.servingSessionLabel
+            ? "approved_for_serving_session"
+            : "approved_for_session",
+      };
+    }
     return {
       approved: true,
       state: "approved_for_session",

package/src/permission-forwarding.ts

@@ -44,7 +44,8 @@ const SESSION_FORWARDING_RESPONSES_DIRECTORY_NAME = "responses";
  * can emit a non-degraded `permissions:ui_prompt` event.
  *
  * Carried separately from the prompt message because the parent reconstructs
- * the original event through `buildForwardedUiPrompt`, not from the message text.
+ * the original event from the escalated ask's details (`buildUiPrompt`), not
+ * from the message text.
  */
 export interface ForwardedPromptDisplay {
   source: PermissionUiPromptSource;
@@ -52,6 +53,20 @@ export interface ForwardedPromptDisplay {
   value: string | null;
 }
 
+/**
+ * The child's session-approval suggestion, relayed to the serving node so a
+ * human who grants "the whole session" records the same pattern the child
+ * would have recorded locally.
+ *
+ * A plain data shape (not the `SessionApproval` value object) so it serializes
+ * onto the forwarded request; the serving node rebuilds a `SessionApproval`
+ * from it via `SessionApproval.multiple`.
+ */
+export interface ForwardedSessionApproval {
+  surface: string;
+  patterns: readonly string[];
+}
+
 export type ForwardedPermissionRequest = {
   id: string;
   createdAt: number;
@@ -68,6 +83,13 @@ export type ForwardedPermissionRequest = {
   source?: PermissionUiPromptSource;
   surface?: string | null;
   value?: string | null;
+  /**
+   * The child's session-approval suggestion. Present when the child computed a
+   * "for this session" pattern for the ask; lets the serving node record a
+   * whole-session grant. Optional for version-skew tolerance (an older child
+   * omits it, and the serving dialog then offers no scope choice).
+   */
+  sessionApproval?: ForwardedSessionApproval;
 };
 
 export type ForwardedPermissionResponse = {

package/src/permission-gate.ts

@@ -10,10 +10,11 @@ export interface PermissionGateParams {
   /** The resolved permission state from checkPermission(). */
   state: "allow" | "deny" | "ask";
 
-  /** Whether the current context supports interactive prompts. */
-  canConfirm: boolean;
-
-  /** Prompt the user for approval. Only called when state === "ask" and canConfirm is true. */
+  /**
+   * Escalate the ask to the session's Authorizer for a decision. Called for
+   * every `ask`; the DenyingAuthorizer answers by denying with the
+   * `confirmationUnavailable` marker when no live authority is reachable.
+   */
   promptForApproval: () => Promise<PermissionPromptDecision>;
 
   /**
@@ -45,14 +46,7 @@ export interface PermissionGateParams {
 export async function applyPermissionGate(
   params: PermissionGateParams,
 ): Promise<PermissionGateResult> {
-  const {
-    state,
-    canConfirm,
-    promptForApproval,
-    writeLog,
-    logContext,
-    messages,
-  } = params;
+  const { state, promptForApproval, writeLog, logContext, messages } = params;
 
   if (state === "deny") {
     writeLog("permission_request.blocked", {
@@ -63,17 +57,17 @@ export async function applyPermissionGate(
   }
 
   if (state === "ask") {
-    if (!canConfirm) {
-      writeLog("permission_request.blocked", {
-        ...logContext,
-        resolution: "confirmation_unavailable",
-      });
-      return { action: "block", reason: messages.unavailableReason };
-    }
-
     const decision = await promptForApproval();
     if (!decision.approved) {
-      return { action: "block", reason: messages.userDeniedReason(decision) };
+      // The gate writes no review entry for an ask denial — the prompter
+      // brackets it (waiting/denied). The block reason distinguishes an
+      // absent-authority denial (confirmationUnavailable) from a user denial.
+      return {
+        action: "block",
+        reason: decision.confirmationUnavailable
+          ? messages.unavailableReason
+          : messages.userDeniedReason(decision),
+      };
     }
     if (decision.state === "approved_for_session" && params.sessionApproval) {
       return { action: "allow", sessionApproval: params.sessionApproval };

package/src/permission-ui-prompt.ts

@@ -1,9 +1,10 @@
 /**
  * Centralized construction for `permissions:ui_prompt` payloads.
  *
- * Every emit site builds its event through one of these functions, so the
- * public contract's shape — including the normalized `surface`/`value`
- * projection — lives in exactly one place and cannot drift by source.
+ * The single builder `buildUiPrompt` handles both direct and forwarded asks, so
+ * the public contract's shape — including the normalized `surface`/`value`
+ * projection and the `forwarding` context — lives in exactly one place and
+ * cannot drift by source.
  *
  * This module is a leaf: it owns narrow input types that each call site's
  * domain object satisfies structurally, so it imports nothing from the
@@ -11,8 +12,8 @@
  */
 
 import type {
+  ForwardedPromptContext,
   PermissionUiPromptEvent,
-  PermissionUiPromptSource,
 } from "./permission-events";
 
 /** Input for a direct (non-forwarded) tool or skill prompt. */
@@ -28,18 +29,42 @@ export interface DirectPromptInput {
   target?: string;
 }
 
-/** Input for a file-forwarded subagent prompt shown by the parent UI. */
-export interface ForwardedPromptInput {
-  requestId: string;
-  message: string;
-  requesterAgentName: string | null;
-  requesterSessionId: string | null;
-  /** Original prompt origin, when the forwarded request carries it. */
-  source?: PermissionUiPromptSource | null;
-  /** Original normalized surface, when the forwarded request carries it. */
+/**
+ * Input for any UI prompt — direct or forwarded.
+ *
+ * A direct prompt supplies only the `DirectPromptInput` fields and lets
+ * `surface`/`value` derive and `forwarding` default to `null`; a forwarded ask
+ * supplies the child's original `surface`/`value` projection explicitly and a
+ * populated `forwarding` context, so the parent's broadcast stays non-degraded
+ * (the #292 contract hardening).
+ */
+export interface UiPromptInput extends DirectPromptInput {
+  /** Explicit display surface; falls back to the derived projection when omitted. */
   surface?: string | null;
-  /** Original normalized value, when the forwarded request carries it. */
+  /** Explicit display value; falls back to the derived projection when omitted. */
   value?: string | null;
+  /** Forwarding context for a forwarded subagent ask; `null`/omitted for a direct prompt. */
+  forwarding?: ForwardedPromptContext | null;
+}
+
+/**
+ * Build a `permissions:ui_prompt` event from either a direct or a forwarded ask.
+ *
+ * `surface`/`value` use the explicit override when the caller sets them (an
+ * explicit `null` is honored, not treated as "derive"); otherwise they fall
+ * back to the direct-prompt projection. `forwarding` passes through, defaulting
+ * to `null`.
+ */
+export function buildUiPrompt(input: UiPromptInput): PermissionUiPromptEvent {
+  return {
+    requestId: input.requestId,
+    source: input.source,
+    surface: input.surface !== undefined ? input.surface : directSurface(input),
+    value: input.value !== undefined ? input.value : directValue(input),
+    agentName: input.agentName,
+    message: input.message,
+    forwarding: input.forwarding ?? null,
+  };
 }
 
 /** Normalized display surface for a direct prompt. */
@@ -61,43 +86,3 @@ function directValue(input: DirectPromptInput): string | null {
     null
   );
 }
-
-/** Build the UI prompt event for a direct tool/skill prompt. */
-export function buildDirectUiPrompt(
-  input: DirectPromptInput,
-): PermissionUiPromptEvent {
-  return {
-    requestId: input.requestId,
-    source: input.source,
-    surface: directSurface(input),
-    value: directValue(input),
-    agentName: input.agentName,
-    message: input.message,
-    forwarding: null,
-  };
-}
-
-/**
- * Build the UI prompt event for a file-forwarded subagent prompt.
- *
- * `source` defaults to `"tool_call"` (the dominant forwarded origin) when the
- * persisted request predates carrying it — a parent on a newer version may read
- * a request written by an older child during an upgrade. The consumer still
- * receives the notify-now signal, message, and forwarding context.
- */
-export function buildForwardedUiPrompt(
-  input: ForwardedPromptInput,
-): PermissionUiPromptEvent {
-  return {
-    requestId: input.requestId,
-    source: input.source ?? "tool_call",
-    surface: input.surface ?? null,
-    value: input.value ?? null,
-    agentName: input.requesterAgentName,
-    message: input.message,
-    forwarding: {
-      requesterAgentName: input.requesterAgentName,
-      requesterSessionId: input.requesterSessionId,
-    },
-  };
-}