@fitchmultz/pi-subagents 0.47.0 → 0.49.0

package/src/pi-intercom/inbound.ts

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { IntercomConfig } from "./config.ts";
 import type { IntercomLifecycle } from "./lifecycle.ts";
@@ -13,6 +12,7 @@ import type { Message, SessionInfo } from "./types.ts";
 import { requestedDelivery, isBlockingSupervisorMessage } from "./inbound-record.ts";
 import { formatAttachments } from "./message-format.ts";
 import { readQuestionOwner } from "../runs/shared/supervisor-questions.ts";
+import { nativePeerId } from "./session-targets.ts";
 
 type Lifecycle = Readonly<
   Pick<IntercomLifecycle, "generation" | "isIdle" | "live" | "markActivity">
@@ -53,9 +53,7 @@ export class IntercomInbound {
     }
     const owner = readQuestionOwner(origin.runId);
     return (
-      owner?.sessionId === origin.ownerSessionId &&
-      from.id ===
-        `pi-${createHash("sha256").update(origin.ownerSessionId).digest("hex").slice(0, 32)}`
+      owner?.sessionId === origin.ownerSessionId && from.id === nativePeerId(origin.ownerSessionId)
     );
   }
   private normalize(from: SessionInfo, input: Message): Message {

package/src/pi-intercom/index.ts

@@ -9,6 +9,7 @@ import { InboundDeliveryOwner } from "./inbound-delivery.ts";
 import { ReplyWait } from "./reply-wait.ts";
 import { IntercomConnection } from "./connection.ts";
 import { IntercomInbound } from "./inbound.ts";
+import { NativeControls } from "./native-control.ts";
 import { IntercomOutbound } from "./outbound.ts";
 import { IntercomInspection } from "./inspection.ts";
 import { IntercomTopicActions } from "./topic-actions.ts";
@@ -33,7 +34,11 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
   const connection = new IntercomConnection(lifecycle, config, topics, {
     restoring: () => delivery.restoring,
     pendingAsks: () => replies.listPending().length,
-    incoming: (ctx, from, message) => inbound.receive(ctx, from, message),
+    incoming: async (ctx, from, message) => {
+      if (!(await controls.receive(ctx, from, message))) {
+        await inbound.receive(ctx, from, message);
+      }
+    },
     peerLeft: (id) => {
       wait.peerDisconnected(id);
       journal.peerLeft(id);
@@ -46,6 +51,7 @@ export default function piIntercomExtension(pi: ExtensionAPI): void {
       }
     },
   });
+  const controls = new NativeControls(lifecycle, connection);
   const delivery = new InboundDeliveryOwner(pi, lifecycle, journal, {
     replies,
     syncStatus: () => connection.syncStatus(),

package/src/pi-intercom/native-control-auth.ts

@@ -0,0 +1,89 @@
+import { X509Certificate } from "node:crypto";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import type { TLSSocket } from "node:tls";
+import { loadControlPolicy } from "./bridge-config.ts";
+import { getPiAgentDir } from "./agent-dir.ts";
+import { fingerprint } from "./bridge-protocol.ts";
+
+export function authenticatedCertificateChain(socket: Readonly<TLSSocket>): string {
+  const blocks: string[] = [];
+  const seen = new Set<string>();
+  let cert = socket.getPeerCertificate(true);
+  for (let depth = 0; depth < 8; depth += 1) {
+    const parsed = new X509Certificate(cert.raw);
+    if (seen.has(parsed.fingerprint256)) {
+      break;
+    }
+    seen.add(parsed.fingerprint256);
+    blocks.push(parsed.toString());
+    cert = cert.issuerCertificate;
+  }
+  return blocks.join("\n");
+}
+function certificates(pem: string): X509Certificate[] {
+  const blocks = pem.match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g);
+  if (!blocks || blocks.length > 8) {
+    throw new Error("Invalid bounded certificate chain.");
+  }
+  return blocks.map((block) => new X509Certificate(block));
+}
+function validNow(cert: X509Certificate): boolean {
+  return Date.parse(cert.validFrom) <= Date.now() && Date.parse(cert.validTo) > Date.now();
+}
+function trustedChain(
+  chain: readonly X509Certificate[],
+  roots: readonly X509Certificate[],
+): boolean {
+  let current = chain.at(0);
+  if (current === undefined || current.ca || !validNow(current)) {
+    return false;
+  }
+  for (let depth = 0; depth < 8; depth += 1) {
+    const subject: X509Certificate = current;
+    const issuer: X509Certificate | undefined = [...roots, ...chain.slice(1)].find(
+      (candidate) =>
+        candidate.ca &&
+        validNow(candidate) &&
+        subject.checkIssued(candidate) &&
+        subject.verify(candidate.publicKey),
+    );
+    if (!issuer) {
+      return false;
+    }
+    if (roots.some((root) => root.fingerprint256 === issuer.fingerprint256)) {
+      return true;
+    }
+    current = issuer;
+  }
+  return false;
+}
+function controlPolicyPath(): string {
+  const configured = process.env.PI_INTERCOM_BRIDGE_CONFIG;
+  if (configured !== undefined) {
+    return configured;
+  }
+  const standard = join(getPiAgentDir(), "intercom", "bridge.json");
+  return existsSync(standard) ? standard : join(homedir(), ".pi", "intercom-bridge", "config.json");
+}
+/** Unix broker peers are same-user trusted. Names/payload claims grant no authority. */
+export function authorizedControlPeer(peerId: string, certificate: string): boolean {
+  try {
+    const configPath = controlPolicyPath();
+    const config = loadControlPolicy(configPath);
+    const chain = certificates(certificate);
+    const client = chain.at(0);
+    if (client === undefined) {
+      return false;
+    }
+    const fp = fingerprint(client.fingerprint256);
+    return (
+      peerId === `remote-${fp.toLowerCase()}` &&
+      config.clients.has(fp) &&
+      trustedChain(chain, certificates(config.ca.toString("utf8")))
+    );
+  } catch {
+    return false;
+  }
+}

package/src/pi-intercom/native-control-protocol.ts

@@ -0,0 +1,180 @@
+import { isRecord, isUnknownArray } from "../shared/unknown.ts";
+import type { TranscriptOptions, TranscriptPage } from "./transcript.ts";
+
+export const CONTROL_SCHEMA = "pi-intercom/control-v1";
+export const CONTROL_FALLBACK =
+  "Native Intercom metadata exchange (no conversation response needed).";
+export type NativeControlVerb = "capabilities" | "cancel" | "stop" | "transcript";
+export interface NativeControlOperation {
+  readonly to: string;
+  readonly verb: NativeControlVerb;
+  readonly options?: TranscriptOptions;
+  readonly timeoutMs: number;
+}
+export interface NativeControlRequest {
+  readonly schema: typeof CONTROL_SCHEMA;
+  readonly kind: "request";
+  readonly verb: NativeControlVerb;
+  /** Public TLS certificate, supplied by the bridge, never a caller-selected identity. */
+  readonly certificate: string;
+  readonly options?: TranscriptOptions;
+}
+export interface NativeControlResult {
+  readonly schema: typeof CONTROL_SCHEMA;
+  readonly kind: "result";
+  readonly verb: NativeControlVerb;
+  readonly status:
+    | "ok"
+    | "denied"
+    | "cancel_requested"
+    | "shutdown_requested"
+    | "unsupported"
+    | "failed";
+  readonly verbs?: readonly NativeControlVerb[];
+  readonly mode?: string;
+  readonly idle?: boolean;
+  readonly pendingInput?: boolean;
+  readonly queueCleared?: false;
+  readonly processExited?: false;
+  readonly stopSupport?: "native_shutdown" | "requires_activity" | "host_dependent";
+  readonly reason?: string;
+  readonly transcript?: TranscriptPage;
+}
+export type NativeControlEnvelope = NativeControlRequest | NativeControlResult;
+
+export function isControlVerb(value: unknown): value is NativeControlVerb {
+  return (
+    value === "capabilities" || value === "cancel" || value === "stop" || value === "transcript"
+  );
+}
+export function isControlRequest(value: unknown): value is NativeControlRequest {
+  return (
+    isRecord(value) &&
+    value.schema === CONTROL_SCHEMA &&
+    value.kind === "request" &&
+    isControlVerb(value.verb) &&
+    typeof value.certificate === "string" &&
+    value.certificate.length <= 16384 &&
+    Object.keys(value).every((key) =>
+      ["schema", "kind", "verb", "certificate", "options"].includes(key),
+    )
+  );
+}
+export function isControlResult(value: unknown): value is NativeControlResult {
+  if (
+    !isRecord(value) ||
+    value.schema !== CONTROL_SCHEMA ||
+    value.kind !== "result" ||
+    !isControlVerb(value.verb)
+  ) {
+    return false;
+  }
+  return (
+    validResultFields(value) &&
+    validResultPayload(value) &&
+    Buffer.byteLength(JSON.stringify(value)) <= 1024 * 1024
+  );
+}
+function optionalText(value: unknown, max: number): boolean {
+  return value === undefined || (typeof value === "string" && value.length <= max);
+}
+function validResultFields(value: Readonly<Record<string, unknown>>): boolean {
+  const fields = new Set([
+    "schema",
+    "kind",
+    "verb",
+    "status",
+    "mode",
+    "idle",
+    "pendingInput",
+    "queueCleared",
+    "processExited",
+    "stopSupport",
+    "reason",
+    "transcript",
+    "verbs",
+  ]);
+  return (
+    Object.keys(value).every((key) => fields.has(key)) &&
+    typeof value.status === "string" &&
+    ["ok", "denied", "cancel_requested", "shutdown_requested", "unsupported", "failed"].includes(
+      value.status,
+    ) &&
+    optionalText(value.reason, 2048) &&
+    optionalText(value.mode, 64) &&
+    [value.idle, value.pendingInput].every(
+      (flag) => flag === undefined || typeof flag === "boolean",
+    ) &&
+    [value.queueCleared, value.processExited].every((flag) => flag === undefined || flag === false)
+  );
+}
+function validResultPayload(value: Readonly<Record<string, unknown>>): boolean {
+  if (
+    value.stopSupport !== undefined &&
+    (typeof value.stopSupport !== "string" ||
+      !["native_shutdown", "requires_activity", "host_dependent"].includes(value.stopSupport))
+  ) {
+    return false;
+  }
+  if (
+    value.verbs !== undefined &&
+    (!isUnknownArray(value.verbs) || !value.verbs.every(isControlVerb))
+  ) {
+    return false;
+  }
+  return value.transcript === undefined || validTranscript(value.transcript);
+}
+function validTranscript(value: unknown): boolean {
+  if (!isRecord(value) || !isUnknownArray(value.records) || value.records.length > 100) {
+    return false;
+  }
+  const fields = new Set([
+    "sessionId",
+    "leafId",
+    "records",
+    "bytes",
+    "truncated",
+    "cursor",
+    "scanLimitReached",
+    "finalizedOnly",
+    "streaming",
+  ]);
+  return (
+    Object.keys(value).every((key) => fields.has(key)) &&
+    typeof value.sessionId === "string" &&
+    value.sessionId.length <= 512 &&
+    (value.leafId === null || typeof value.leafId === "string") &&
+    value.records.every(validTranscriptRecord) &&
+    validTranscriptMetadata(value)
+  );
+}
+function validTranscriptMetadata(value: Readonly<Record<string, unknown>>): boolean {
+  return (
+    typeof value.bytes === "number" &&
+    Number.isInteger(value.bytes) &&
+    value.bytes >= 0 &&
+    value.bytes <= 131072 &&
+    typeof value.truncated === "boolean" &&
+    optionalText(value.cursor, 512) &&
+    typeof value.scanLimitReached === "boolean" &&
+    value.finalizedOnly === true &&
+    value.streaming === "unavailable"
+  );
+}
+function validTranscriptRecord(value: unknown): boolean {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const fields = new Set(["id", "timestamp", "role", "text", "truncated"]);
+  return (
+    Object.keys(value).every((key) => fields.has(key)) &&
+    [value.id, value.timestamp].every(
+      (field) => typeof field === "string" && field.length <= 512,
+    ) &&
+    typeof value.role === "string" &&
+    ["user", "assistant", "toolResult", "custom"].includes(value.role) &&
+    typeof value.text === "string" &&
+    Buffer.byteLength(value.text) <= 131072 &&
+    typeof value.truncated === "boolean"
+  );
+}

package/src/pi-intercom/native-control.ts

@@ -0,0 +1,160 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { IntercomLifecycle } from "./lifecycle.ts";
+import type { IntercomConnection } from "./connection.ts";
+import type { Message, SessionInfo } from "./types.ts";
+import { authorizedControlPeer } from "./native-control-auth.ts";
+import {
+  CONTROL_FALLBACK,
+  CONTROL_SCHEMA,
+  isControlRequest,
+  type NativeControlRequest,
+  type NativeControlResult,
+} from "./native-control-protocol.ts";
+import { readLiveTranscript, transcriptOptions } from "./transcript.ts";
+
+export class NativeControls {
+  private readonly lifecycle: Readonly<Pick<IntercomLifecycle, "live" | "generation">>;
+  private readonly connection: Readonly<Pick<IntercomConnection, "active">>;
+  constructor(lifecycle: NativeControls["lifecycle"], connection: NativeControls["connection"]) {
+    this.lifecycle = lifecycle;
+    this.connection = connection;
+  }
+  private result(ctx: ExtensionContext, request: NativeControlRequest): NativeControlResult {
+    const base = {
+      schema: CONTROL_SCHEMA,
+      kind: "result",
+      verb: request.verb,
+      mode: ctx.mode,
+      idle: ctx.isIdle(),
+      pendingInput: ctx.hasPendingMessages(),
+      queueCleared: false,
+      processExited: false,
+    } satisfies Partial<NativeControlResult>;
+    if (request.verb !== "transcript" && request.options !== undefined) {
+      throw new Error("Only transcript accepts options.");
+    }
+    const stopSupport = stopCapability(ctx);
+    switch (request.verb) {
+      case "capabilities":
+        return {
+          ...base,
+          status: "ok",
+          stopSupport,
+          verbs: ["capabilities", "cancel", "stop", "transcript"],
+        };
+      case "transcript":
+        return {
+          ...base,
+          status: "ok",
+          transcript: readLiveTranscript(ctx.sessionManager, transcriptOptions(request.options)),
+        };
+      case "cancel":
+        return {
+          ...base,
+          status: "cancel_requested",
+          reason: "Native current-operation abort; accepted queued input is not cleared.",
+        };
+      case "stop":
+        return {
+          ...base,
+          status:
+            ctx.mode === "print" || ctx.mode === "json" ? "unsupported" : "shutdown_requested",
+          stopSupport,
+          reason:
+            "Native shutdown/current-operation abort requested, not process exit. Idle RPC is deferred until a native command/settlement; print/JSON/SDK have no guaranteed shutdown binding.",
+        };
+    }
+  }
+  async receive(ctx: ExtensionContext, from: SessionInfo, message: Message): Promise<boolean> {
+    if (!Object.hasOwn(message, "control")) {
+      return false;
+    }
+    // Even malformed/response envelopes never enter conversation journaling or inference.
+    const request = message.control;
+    if (
+      !isControlRequest(request) ||
+      message.replyTo !== undefined ||
+      message.delivery !== "passive" ||
+      message.expectsReply === true
+    ) {
+      return true;
+    }
+    const generation = this.lifecycle.generation;
+    const active = this.connection.active;
+    if (!active || !this.lifecycle.live(ctx, generation)) {
+      return true;
+    }
+    const result = this.admit(ctx, from.id, request);
+    // Receipt is acknowledged before shutdown can retire this socket/context.
+    await active.send(from.id, {
+      text: CONTROL_FALLBACK,
+      delivery: "passive",
+      replyTo: message.id,
+      control: result,
+    });
+    this.apply(ctx, generation, { active, peer: from.id, request, result });
+    return true;
+  }
+  private apply(
+    ctx: ExtensionContext,
+    generation: number,
+    state: {
+      readonly active: NonNullable<IntercomConnection["active"]>;
+      readonly peer: string;
+      readonly request: NativeControlRequest;
+      readonly result: NativeControlResult;
+    },
+  ): void {
+    const { active, peer, request, result } = state;
+    if (
+      !this.lifecycle.live(ctx, generation) ||
+      this.connection.active !== active ||
+      !authorizedControlPeer(peer, request.certificate)
+    ) {
+      return;
+    }
+    if (
+      result.status === "shutdown_requested" ||
+      (result.status === "unsupported" && request.verb === "stop")
+    ) {
+      ctx.shutdown();
+      if (this.lifecycle.live(ctx, generation)) {
+        ctx.abort();
+      }
+    } else if (result.status === "cancel_requested") {
+      ctx.abort();
+    }
+  }
+  private admit(
+    ctx: ExtensionContext,
+    peer: string,
+    request: NativeControlRequest,
+  ): NativeControlResult {
+    if (!authorizedControlPeer(peer, request.certificate)) {
+      return {
+        schema: CONTROL_SCHEMA,
+        kind: "result",
+        verb: request.verb,
+        status: "denied",
+        reason: "Sender certificate is not currently authorized by private bridge configuration.",
+      };
+    }
+    try {
+      return this.result(ctx, request);
+    } catch {
+      return {
+        schema: CONTROL_SCHEMA,
+        kind: "result",
+        verb: request.verb,
+        status: "failed",
+        reason: "Native control input/state is unavailable.",
+      };
+    }
+  }
+}
+function stopCapability(ctx: ExtensionContext): NativeControlResult["stopSupport"] {
+  if (ctx.mode === "tui") {
+    return "native_shutdown";
+  }
+  return ctx.mode === "rpc" ? "requires_activity" : "host_dependent";
+}

package/src/pi-intercom/saved-transcript.ts

@@ -0,0 +1,175 @@
+import { constants, openSync, closeSync, fstatSync } from "node:fs";
+import type * as NativeSession from "@earendil-works/pi-coding-agent";
+import { loadNativeSession } from "../shared/native-session-loader.ts";
+import { scanJournal, type Projection } from "../shared/journal-reader.ts";
+import { Fault } from "./bridge-protocol.ts";
+import { readLiveTranscript, type TranscriptOptions, type TranscriptPage } from "./transcript.ts";
+
+const FILE_BYTES = 64 * 1024 * 1024;
+const ENTRY_COUNT = 50000;
+const TEXT_LIMIT = 131072;
+const fields = new Set([
+  "type",
+  "id",
+  "parentId",
+  "timestamp",
+  "version",
+  "cwd",
+  "customType",
+  "display",
+  "content",
+]);
+/** Only branch structure and public textual content are hydrated, never image/provider/custom data. */
+const transcriptProjection: Projection = (path) => {
+  if (path.length === 0) {
+    return true;
+  }
+  if (path[0] === "message") {
+    return messageField(path.slice(1));
+  }
+  if (path[0] === "content") {
+    return contentField(path.slice(1));
+  }
+  return path.length === 1 && fields.has(String(path[0])) ? 4096 : false;
+};
+function messageField(path: readonly (string | number)[]): boolean | number {
+  if (path.length === 0) {
+    return true;
+  }
+  if (path[0] === "content") {
+    return contentField(path.slice(1));
+  }
+  return path.length === 1 && ["role", "output", "display", "truncated"].includes(String(path[0]))
+    ? TEXT_LIMIT
+    : false;
+}
+function contentField(path: readonly (string | number)[]): boolean | number {
+  return path.length < 2 || (path.length === 2 && ["type", "text"].includes(String(path[1])))
+    ? TEXT_LIMIT
+    : false;
+}
+function textField(path: readonly (string | number)[]): boolean {
+  if (path[0] === "message") {
+    return (
+      (path.length === 2 && ["content", "output"].includes(String(path[1]))) ||
+      (path.length === 4 && path[1] === "content" && path[3] === "text")
+    );
+  }
+  return path[0] === "content" && (path.length === 1 || (path.length === 3 && path[2] === "text"));
+}
+function savedLines(
+  fd: number,
+  size: number,
+): { readonly lines: readonly string[]; readonly cut: ReadonlySet<number> } {
+  const lines: string[] = [];
+  const cut = new Set<number>();
+  const lengths = new Map<string, number>();
+  scanJournal(
+    fd,
+    transcriptProjection,
+    ({ value }) => {
+      if (lines.length >= ENTRY_COUNT) {
+        throw new Fault(
+          413,
+          "transcript_too_large",
+          "Saved journal exceeds the 50000-entry budget.",
+        );
+      }
+      lines.push(JSON.stringify(value));
+      lengths.clear();
+    },
+    {
+      policy: "inspect",
+      requireNewline: true,
+      end: size,
+      limits: { depth: 64, nodes: 16384, arrayLength: 4096, keyLength: 512 },
+      malformed: (_start, _end, error) => {
+        if (error instanceof RangeError) {
+          throw new Fault(413, "transcript_too_large", "Saved record exceeds projection limits.");
+        }
+        lengths.clear();
+        cut.delete(lines.length);
+      },
+      stringChunk: (path, chunk) => {
+        if (textField(path)) {
+          const key = JSON.stringify(path);
+          const count = (lengths.get(key) ?? 0) + chunk.length;
+          lengths.set(key, count);
+          if (count > TEXT_LIMIT) {
+            cut.add(lines.length);
+          }
+        }
+      },
+    },
+  );
+  return { lines, cut };
+}
+/** Internal hook: caller MUST resolve a catalog-approved saved ID/name, never accept an HTTP filepath. */
+export async function readSavedTranscript(
+  packageRoot: string,
+  approvedFile: string,
+  options: TranscriptOptions = {},
+): Promise<TranscriptPage> {
+  const sdk = await loadNativeSession(packageRoot);
+  const fd = openSync(approvedFile, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = fstatSync(fd);
+    if (!before.isFile() || before.size > FILE_BYTES) {
+      throw new Fault(413, "transcript_too_large", "Saved journal exceeds the 64 MiB read budget.");
+    }
+    const { lines, cut } = savedLines(fd, before.size);
+    const after = fstatSync(fd);
+    if (
+      after.size !== before.size ||
+      after.mtimeMs !== before.mtimeMs ||
+      after.ctimeMs !== before.ctimeMs
+    ) {
+      throw new Fault(
+        409,
+        "session_changed",
+        "Saved journal changed during reading; refresh the catalog.",
+      );
+    }
+    const entries = sdk.parseSessionEntries(lines.join("\n"));
+    return savedPage(entries, cut, options, sdk);
+  } finally {
+    closeSync(fd);
+  }
+}
+function savedPage(
+  entries: ReturnType<typeof NativeSession.parseSessionEntries>,
+  cut: ReadonlySet<number>,
+  options: TranscriptOptions,
+  sdk: typeof NativeSession,
+): TranscriptPage {
+  const header = entries.find((entry) => entry.type === "session");
+  if (header === undefined) {
+    throw new Fault(409, "invalid_session", "Saved journal has no native session header.");
+  }
+  const legacy = (header.version ?? 1) < 2;
+  if (legacy && options.cursor !== undefined) {
+    throw new Fault(
+      409,
+      "cursor_unavailable",
+      "Legacy journals have no stable entry IDs; request a fresh bounded recent transcript.",
+    );
+  }
+  // Native inMemory reconstructs branch state/migrations without ever opening or writing the file.
+  const manager = sdk.SessionManager.inMemory(header.cwd, undefined, entries);
+  const page = readLiveTranscript(manager, options);
+  const cutIds = new Set(
+    entries.flatMap((entry, index) =>
+      entry.type !== "session" && cut.has(index) ? [entry.id] : [],
+    ),
+  );
+  const records = page.records.map((entry) =>
+    cutIds.has(entry.id) ? { ...entry, truncated: true } : entry,
+  );
+  return {
+    ...page,
+    // ponytail: v1 has no persisted entry IDs; use catalog snapshot cursors if legacy pagination is needed.
+    cursor: legacy ? undefined : page.cursor,
+    records,
+    truncated: page.truncated || records.some((entry) => entry.truncated),
+  };
+}

package/src/pi-intercom/session-targets.ts

@@ -14,6 +14,10 @@ export interface ProjectSessionIdentity extends TargetIdentity {
 
 export const MIN_SESSION_TARGET_PREFIX_LENGTH = 8;
 
+export function nativePeerId(sessionId: string): string {
+  return `pi-${createHash("sha256").update(sessionId).digest("hex").slice(0, 32)}`;
+}
+
 export interface TargetResolution<T extends TargetIdentity> {
   readonly status: "none" | "found" | "ambiguous" | "prefix_too_short";
   readonly target?: T;