@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/agent/runner.ts

@@ -0,0 +1,417 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import type {
+  AgentSession,
+  CreateAgentSessionRuntimeFactory,
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import {
+  attachmentSchema,
+  commandSchema,
+  type Command,
+  type Launch,
+  type Result,
+} from "./contracts.ts";
+import { launchAt, read, runDirectory, write } from "./storage.ts";
+import { alive, ownIdentity, shellCommand } from "./process.ts";
+import { errorText, loadSDK } from "./host.ts";
+import { childUsage } from "./usage.ts";
+import { initializeCwd, localCwdOwner } from "./cwd.ts";
+
+function completionStatus(
+  stopping: boolean,
+  message: AssistantMessage | undefined,
+  error: string | undefined,
+): Result["status"] {
+  if (stopping || message?.stopReason === "aborted") {
+    return "stopped";
+  }
+  if (error !== undefined || !message || message.stopReason === "error") {
+    return "failed";
+  }
+  return "completed";
+}
+function guard(pi: ExtensionAPI, directory: string, token: string): void {
+  pi.on("tool_call", (event) => {
+    if (event.toolName === "delegate" || event.toolName === "agent_runs") {
+      return { block: true, reason: "Only a main session may delegate or control children." };
+    }
+    const owner = pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo;
+    if (
+      event.toolName === "bash" &&
+      typeof event.input.command === "string" &&
+      owner &&
+      (owner.source === "builtin" || localCwdOwner(owner))
+    ) {
+      // Preserve the selected local owner's cwd/env and leave remote/custom tools alone.
+      const input = event.input;
+      input.command = shellCommand(event.input.command, directory, token);
+    }
+    return;
+  });
+}
+class Actor {
+  private active?: Promise<void>;
+  private stopping = false;
+  private current?: Launch;
+  private readonly errors: string[] = [];
+  private readonly started = new Set<string>();
+  private session?: AgentSession;
+  private context?: { pi: ExtensionAPI; ctx: ExtensionContext };
+  private readonly base: string;
+  private readonly initial: Launch;
+  private readonly token: string;
+  constructor(base: string, initial: Launch, token: string) {
+    this.base = base;
+    this.initial = initial;
+    this.token = token;
+  }
+  private get dir(): string {
+    return runDirectory(this.base, this.initial.rootId);
+  }
+  private response(baseline: ReadonlySet<string>) {
+    const session = this.session;
+    if (!session) {
+      throw new Error("Native child session is not ready.");
+    }
+    const terminal = session.sessionManager
+      .getBranch()
+      .findLast(
+        (entry) =>
+          !baseline.has(entry.id) && entry.type === "message" && entry.message.role === "assistant",
+      );
+    if (terminal?.type !== "message" || terminal.message.role !== "assistant") {
+      return;
+    }
+    return { id: terminal.id, message: terminal.message };
+  }
+  private saveResult(launch: Launch, baseline: ReadonlySet<string>, error?: string): void {
+    const terminal = this.response(baseline);
+    const message = terminal?.message;
+    const accounting = this.usage(launch, baseline, terminal?.id);
+    const output = this.output(message);
+    const result: Result = {
+      id: launch.id,
+      owner: launch.owner,
+      status: completionStatus(this.stopping, message, error),
+      endedAt: Date.now(),
+      terminalEntryId: accounting.accountingError === undefined ? terminal?.id : undefined,
+      ...accounting,
+      error:
+        error ??
+        message?.errorMessage ??
+        (message ? undefined : "Native run produced no terminal assistant message."),
+    };
+    fs.writeFileSync(path.join(runDirectory(this.base, launch.id), "output.txt"), output, {
+      mode: 0o600,
+    });
+    write(path.join(runDirectory(this.base, launch.id), "result.json"), result);
+  }
+  private usage(
+    launch: Launch,
+    baseline: ReadonlySet<string>,
+    terminal?: string,
+  ): Pick<Result, "contributions" | "accountingError" | "accountingPending"> {
+    try {
+      return { contributions: childUsage(launch, baseline, terminal) };
+    } catch (error) {
+      return {
+        accountingError: errorText(error),
+        ...(terminal !== undefined
+          ? { accountingPending: { terminalCandidate: terminal, baseline: [...baseline] } }
+          : {}),
+      };
+    }
+  }
+  private output(message: AssistantMessage | undefined): string {
+    return (
+      message?.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n") ?? ""
+    );
+  }
+  private createRuntime(
+    sdk: Awaited<ReturnType<typeof loadSDK>>,
+  ): CreateAgentSessionRuntimeFactory {
+    return async ({ sessionManager }) => {
+      const launch = this.initial;
+      if (!fs.existsSync(launch.sessionFile)) {
+        throw new Error("Missing saved native session; refusing to create another.");
+      }
+      const settingsManager = sdk.SettingsManager.create(launch.cwd, launch.agentDir, {
+        projectTrusted: launch.trusted,
+      });
+      const services = await sdk.createAgentSessionServices({
+        cwd: launch.cwd,
+        agentDir: launch.agentDir,
+        settingsManager,
+        resourceLoaderOptions: {
+          additionalExtensionPaths: [launch.entry],
+          extensionFactories: [
+            {
+              name: "codemode",
+              builtin: true,
+              factory: sdk.createCodemodeExtension({ mode: "on" }),
+            },
+            { name: "tool_search", builtin: true, factory: sdk.createToolSearchExtension() },
+            { name: "mcp", builtin: true, factory: sdk.createMcpExtension() },
+            (pi) => {
+              guard(pi, this.dir, this.token);
+              pi.on("session_start", (_event, ctx) => {
+                this.context = { pi, ctx };
+              });
+            },
+          ],
+        },
+      });
+      const diagnostics = services.resourceLoader.getExtensions().errors;
+      if (diagnostics.length > 0) {
+        throw new Error(`Child extension load failed: ${JSON.stringify(diagnostics)}`);
+      }
+      const model = services.modelRuntime.getModel(launch.provider, launch.model);
+      if (!model) {
+        throw new Error(
+          `Saved model ${launch.provider}/${launch.model} is unavailable; no fallback was used.`,
+        );
+      }
+      return {
+        ...(await sdk.createAgentSessionFromServices({
+          services,
+          sessionManager,
+          model,
+          thinkingLevel: launch.thinking,
+        })),
+        services,
+        diagnostics: services.diagnostics,
+      };
+    };
+  }
+  private readonly stop = (): void => {
+    write(path.join(this.dir, "stop-acknowledged.json"), { at: Date.now(), id: this.current?.id });
+    this.stopping = true;
+    this.session?.abort().catch((error: unknown) => {
+      this.errors.push(errorText(error));
+    });
+  };
+  private run(launch: Launch): void {
+    const session = this.session;
+    if (!session) {
+      throw new Error("Native child session is not ready.");
+    }
+    this.current = launch;
+    const baseline = new Set(session.sessionManager.getEntries().map((entry) => entry.id));
+    this.active = (async () => {
+      try {
+        if (
+          launch.provider !== this.initial.provider ||
+          launch.model !== this.initial.model ||
+          launch.thinking !== this.initial.thinking
+        ) {
+          throw new Error("Continuation model snapshot changed unexpectedly.");
+        }
+        await session.prompt(launch.prompt, { expandPromptTemplates: false });
+        await session.waitForIdle();
+        this.saveResult(launch, baseline);
+      } catch (error) {
+        this.saveResult(launch, baseline, errorText(error));
+      } finally {
+        this.active = undefined;
+        this.current = undefined;
+      }
+    })();
+  }
+  private commandLaunch(command: Command): Launch | undefined {
+    const receipt = path.join(this.dir, "admissions", `${command.id}.json`);
+    if (fs.existsSync(receipt) || this.started.has(command.id)) {
+      return undefined;
+    }
+    if (
+      command.action === "run" &&
+      fs.existsSync(path.join(runDirectory(this.base, command.runId), "successor.json"))
+    ) {
+      // A durable handoff supersedes even an unadmitted predecessor; never replay it.
+      return undefined;
+    }
+    const launch = launchAt(this.base, command.runId, this.initial.owner);
+    if (launch.rootId !== this.initial.rootId || launch.sessionFile !== this.initial.sessionFile) {
+      throw new Error("Foreign conversation command.");
+    }
+    return launch;
+  }
+  private accept(command: Command): void {
+    const session = this.session;
+    if (!session) {
+      throw new Error("Native child session is not ready.");
+    }
+    const receipt = path.join(this.dir, "admissions", `${command.id}.json`);
+    const launch = this.commandLaunch(command);
+    if (!launch) {
+      return;
+    }
+    if (
+      command.action === "run" &&
+      (this.stopping || this.active !== undefined || !session.isIdle)
+    ) {
+      return;
+    }
+    this.started.add(command.id);
+    const stale = this.staleCommand(command, launch, session);
+    // This is queue admission, never a claim of native journal publication.
+    write(
+      receipt,
+      {
+        id: command.id,
+        runId: launch.id,
+        action: command.action,
+        state: stale ? "stale" : "accepted",
+        at: Date.now(),
+      },
+      true,
+    );
+    if (stale) {
+      return;
+    }
+    this.applyCommand(command, launch, session);
+  }
+  private staleCommand(command: Command, launch: Launch, session: AgentSession): boolean {
+    // Unbound legacy Stops cannot safely target this generation either.
+    if (command.action === "stop") {
+      return command.actorToken !== this.token;
+    }
+    return (
+      command.action === "steer" &&
+      (this.active === undefined || session.isIdle || this.current?.id !== launch.id)
+    );
+  }
+  private applyCommand(command: Command, launch: Launch, session: AgentSession): void {
+    if (command.action === "stop") {
+      this.stop();
+      return;
+    }
+    if (command.action === "run") {
+      this.run(launch);
+      return;
+    }
+    if (command.prompt === undefined) {
+      throw new Error("Missing guidance.");
+    }
+    // Synchronous native queue admission cannot turn into an idle prompt after an await.
+    session.agent.steer({
+      role: "user",
+      content: [{ type: "text", text: command.prompt }],
+      timestamp: Date.now(),
+    });
+  }
+  private pending(): Command[] {
+    const dir = path.join(this.dir, "commands");
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return fs
+      .readdirSync(dir)
+      .filter((file) => file.endsWith(".json"))
+      .flatMap((file) => {
+        const command = read(path.join(dir, file), commandSchema);
+        return command ? [command] : [];
+      })
+      .sort((a, b) => a.createdAt - b.createdAt);
+  }
+  private shouldExit(): boolean {
+    if (this.active !== undefined) {
+      return false;
+    }
+    if (this.stopping) {
+      return true;
+    }
+    if (this.session && (!this.session.isIdle || this.session.pendingMessageCount > 0)) {
+      return false;
+    }
+    const attachment = read(path.join(this.base, "attachment.json"), attachmentSchema);
+    return attachment === undefined || !attachment.attached || !alive(attachment);
+  }
+  private failure(error: unknown): void {
+    const launch = this.current ?? this.initial;
+    const result: Result = {
+      id: launch.id,
+      owner: launch.owner,
+      status: this.stopping ? "stopped" : "failed",
+      endedAt: Date.now(),
+      error: errorText(error),
+    };
+    const directory = runDirectory(this.base, launch.id);
+    if (!fs.existsSync(path.join(directory, "result.json"))) {
+      fs.writeFileSync(path.join(directory, "output.txt"), "", { mode: 0o600 });
+      write(path.join(directory, "result.json"), result);
+    }
+    process.exitCode = 1;
+  }
+  async serve(): Promise<void> {
+    const sdk = await loadSDK(this.initial.sdk);
+    let runtime: Awaited<ReturnType<typeof sdk.createAgentSessionRuntime>> | undefined;
+    try {
+      runtime = await sdk.createAgentSessionRuntime(this.createRuntime(sdk), {
+        cwd: this.initial.cwd,
+        agentDir: this.initial.agentDir,
+        sessionManager: sdk.SessionManager.open(
+          this.initial.sessionFile,
+          undefined,
+          this.initial.cwd,
+        ),
+      });
+      this.session = runtime.session;
+      await this.session.bindExtensions({
+        mode: "print",
+        onError: (error) => {
+          this.errors.push(error.error);
+        },
+      });
+      if (!this.context) {
+        throw new Error("Child extension context is unavailable.");
+      }
+      initializeCwd(this.context.pi, this.context.ctx, this.initial.cwd, this.dir);
+      if (this.initial.name !== undefined) {
+        this.session.sessionManager.appendSessionInfo(this.initial.name);
+      }
+      write(path.join(this.dir, "actor.lock", "process.json"), {
+        ...ownIdentity(),
+        token: this.token,
+      });
+      write(path.join(this.dir, "ready.json"), {
+        pid: process.pid,
+        token: this.token,
+        sessionId: this.session.sessionManager.getSessionId(),
+        at: Date.now(),
+      });
+      process.on("SIGTERM", this.stop);
+      process.on("SIGINT", this.stop);
+      do {
+        this.pending().forEach((command) => this.accept(command));
+        // Durable command readiness, not elapsed time, defines admission.
+        // oxlint-disable-next-line no-await-in-loop
+        await delay(100);
+      } while (!this.shouldExit());
+      await this.active;
+    } catch (error) {
+      this.failure(error);
+    } finally {
+      process.off("SIGTERM", this.stop);
+      process.off("SIGINT", this.stop);
+      await runtime?.dispose();
+      write(path.join(this.dir, `shutdown-${this.token}.json`), {
+        at: Date.now(),
+        errors: this.errors,
+      });
+      // Keep the process claim until a launcher proves this exact actor is gone.
+    }
+  }
+}
+const base = process.argv.at(2);
+const rootId = process.argv.at(3);
+const token = process.argv.at(4);
+const firstId = process.argv.at(5);
+if (base === undefined || rootId === undefined || token === undefined || firstId === undefined) {
+  throw new Error("Expected saved conversation and actor claim.");
+}
+await new Actor(base, launchAt(base, firstId, path.basename(base)), token).serve();

package/src/agent/saved.ts

@@ -0,0 +1,220 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Static } from "typebox";
+import { NativeJournal } from "../shared/native-journal.ts";
+import { isRecord } from "../shared/unknown.ts";
+import { Assert, Type } from "./typebox.ts";
+import { thinkingSchema, successorSchema, type Launch } from "./contracts.ts";
+import { packageRoot, runtimeEntry } from "./host.ts";
+import { launchAt, read, runDirectory, safeId, write } from "./storage.ts";
+
+const configuration = Type.Object({
+  model: Type.Optional(Type.String()),
+  thinking: Type.Optional(thinkingSchema),
+});
+const contractSchema = Type.Object({
+  sessionFile: Type.String({ minLength: 1 }),
+  nativeSessionId: Type.Optional(Type.String()),
+  pid: Type.Optional(Type.Integer({ minimum: 1 })),
+  effectiveConfiguration: Type.Optional(configuration),
+  launch: Type.Object({
+    model: Type.Optional(Type.String()),
+    thinking: Type.Optional(thinkingSchema),
+    cwd: Type.String({ minLength: 1 }),
+    context: Type.Union([Type.Literal("fresh"), Type.Literal("fork")]),
+    projectTrusted: Type.Optional(Type.Boolean()),
+  }),
+});
+const ownerSchema = Type.Object({ sessionId: Type.String() });
+const singleSchema = Type.Object({
+  ownerSessionId: Type.String(),
+  mode: Type.Literal("single"),
+  pid: Type.Optional(Type.Integer({ minimum: 1 })),
+  children: Type.Tuple([
+    Type.Object({
+      index: Type.Literal(0),
+      sessionFile: Type.Optional(Type.String()),
+    }),
+  ]),
+});
+type Contract = Static<typeof contractSchema>;
+
+function ownedRun(context: ExtensionContext, id: string) {
+  const file = context.sessionManager.getSessionFile();
+  if (file === undefined) {
+    throw new Error("Legacy continuation requires a published native owner.");
+  }
+  const journal = new NativeJournal(file, "live");
+  if (journal.records[0].value.id !== context.sessionManager.getSessionId()) {
+    throw new Error("Native owner journal identity changed; nothing was launched.");
+  }
+  let owned;
+  for (const record of journal.records) {
+    if (record.value.type === "custom" && record.value.customType === "subagent-run") {
+      const { data } = journal.body(record);
+      if (isRecord(data) && data.runId === id) {
+        owned = data;
+      }
+    }
+  }
+  if (owned?.ownerSessionId !== context.sessionManager.getSessionId()) {
+    throw new Error("Missing saved native owner or foreign legacy run; nothing was launched.");
+  }
+  Assert(singleSchema, owned);
+  return owned;
+}
+function requireExited(pid: unknown): void {
+  if (pid === undefined) {
+    return;
+  }
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid < 1) {
+    throw new Error("Legacy process ownership is ambiguous; nothing was launched.");
+  }
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+      return;
+    }
+    throw error;
+  }
+  throw new Error("Legacy producer may still be live; refusing a second owner.");
+}
+function frozenModel(contract: Contract, context: ExtensionContext) {
+  const model = contract.effectiveConfiguration?.model ?? contract.launch.model;
+  const thinking = contract.effectiveConfiguration?.thinking ?? contract.launch.thinking;
+  if (model === undefined || thinking === undefined || model.startsWith("claude-code/")) {
+    throw new Error(
+      "Missing native model/thinking snapshot or retired backend; nothing was launched.",
+    );
+  }
+  const slash = model.indexOf("/");
+  if (slash < 1 || !context.modelRegistry.find(model.slice(0, slash), model.slice(slash + 1))) {
+    throw new Error("Saved native model is unavailable; no fallback was used.");
+  }
+  return { provider: model.slice(0, slash), model: model.slice(slash + 1), thinking };
+}
+function nativeSession(contract: Contract) {
+  if (!path.isAbsolute(contract.sessionFile) || path.extname(contract.sessionFile) !== ".jsonl") {
+    throw new Error("Legacy continuation requires the exact saved native journal.");
+  }
+  const journal = new NativeJournal(contract.sessionFile, "live");
+  const sessionId = journal.body(journal.records[0]).id;
+  if (
+    typeof sessionId !== "string" ||
+    sessionId.length === 0 ||
+    (contract.nativeSessionId !== undefined && contract.nativeSessionId !== sessionId)
+  ) {
+    throw new Error("Saved native session identity does not match its contract.");
+  }
+  return { sessionFile: contract.sessionFile, sessionId };
+}
+function frozenSnapshot(
+  source: string,
+  context: ExtensionContext,
+  owned: Static<typeof singleSchema>,
+) {
+  const contract = read(path.join(source, "contracts", "0.json"), contractSchema);
+  if (!contract) {
+    throw new Error("Missing frozen legacy launch; nothing was launched.");
+  }
+  const childFile = owned.children[0].sessionFile;
+  if (
+    fs
+      .readdirSync(path.join(source, "contracts"))
+      .some((file) => file.endsWith(".json") && file !== "0.json") ||
+    (childFile !== undefined && childFile !== contract.sessionFile)
+  ) {
+    throw new Error("Ambiguous legacy child journal or multistep contract; nothing was launched.");
+  }
+  const cwd = contract.launch.cwd;
+  if (!path.isAbsolute(cwd) || !fs.statSync(cwd).isDirectory()) {
+    throw new Error("Missing frozen legacy cwd; nothing was launched.");
+  }
+  requireExited(owned.pid);
+  requireExited(contract.pid);
+  return {
+    ...frozenModel(contract, context),
+    ...nativeSession(contract),
+    cwd,
+    context: contract.launch.context,
+    trusted: contract.launch.projectTrusted === true,
+  };
+}
+
+/** The committed adoption claim authorizes only its original owned journal. */
+export function adoptedJournal(base: string, launch: Launch): boolean {
+  const root = launchAt(base, launch.rootId, launch.owner);
+  if (
+    root.id !== root.rootId ||
+    root.predecessor === undefined ||
+    !path.isAbsolute(root.sessionFile) ||
+    path.extname(root.sessionFile) !== ".jsonl" ||
+    root.sessionFile !== launch.sessionFile ||
+    root.sessionId !== launch.sessionId
+  ) {
+    return false;
+  }
+  return (
+    read(path.join(base, `legacy-${safeId(root.predecessor)}.json`), successorSchema)?.id ===
+    root.id
+  );
+}
+
+/** Only frozen single-native-child snapshots cross the retired runtime boundary. */
+export function savedContinuation(options: {
+  id: string;
+  prompt: string;
+  context: ExtensionContext;
+  base: string;
+  agentDir: string;
+}): { launch: Launch; created: boolean } {
+  const { id, prompt, context, base, agentDir } = options;
+  safeId(id);
+  const owner = context.sessionManager.getSessionId();
+  const owned = ownedRun(context, id);
+  const source = path.join(agentDir, "sessions", "subagent-runs", id);
+  if (read(path.join(source, "question-owner.json"), ownerSchema)?.sessionId !== owner) {
+    throw new Error("Missing or foreign legacy owner; nothing was launched.");
+  }
+  const mapping = path.join(base, `legacy-${id}.json`);
+  const adopted = read(mapping, successorSchema);
+  if (adopted) {
+    return { launch: launchAt(base, adopted.id, owner), created: false };
+  }
+  const snapshot = frozenSnapshot(source, context, owned);
+  const nextId = randomUUID();
+  const launch: Launch = {
+    version: 1,
+    id: nextId,
+    rootId: nextId,
+    predecessor: id,
+    owner,
+    agentDir,
+    sdk: packageRoot(),
+    entry: runtimeEntry(),
+    prompt,
+    ...snapshot,
+    createdAt: Date.now(),
+  };
+  fs.mkdirSync(runDirectory(base, nextId), { mode: 0o700 });
+  write(path.join(runDirectory(base, nextId), "launch.json"), launch, true);
+  try {
+    write(mapping, { id: nextId }, true);
+  } catch (error) {
+    fs.rmSync(runDirectory(base, nextId), { recursive: true });
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+      throw error;
+    }
+    const winner = read(mapping, successorSchema);
+    if (!winner) {
+      throw new Error("Legacy continuation claim disappeared; refusing to replay.", {
+        cause: error,
+      });
+    }
+    return { launch: launchAt(base, winner.id, owner), created: false };
+  }
+  return { launch, created: true };
+}

package/src/agent/shell.ts

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import * as path from "node:path";
+import * as fs from "node:fs";
+import { readChildProcessIdentity } from "../shared/post-exit-stdio-guard.ts";
+import { read, write } from "./storage.ts";
+import { processSchema } from "./contracts.ts";
+import { verifyProcess } from "./process.ts";
+
+// Called by the actual native shell before executing any user command.
+const directory = process.argv.at(2),
+  token = process.argv.at(3),
+  rawPid = process.argv.at(4);
+const pid = Number(rawPid);
+if (
+  directory === undefined ||
+  token === undefined ||
+  !Number.isSafeInteger(pid) ||
+  pid < 1 ||
+  process.ppid !== pid
+) {
+  throw new Error("Native shell registration requires its actual parent shell.");
+}
+const group = Number(
+  execFileSync("ps", ["-p", String(pid), "-o", "pgid="], {
+    encoding: "utf8",
+    timeout: 1000,
+    stdio: ["ignore", "pipe", "ignore"],
+  }).trim(),
+);
+const identity = readChildProcessIdentity(pid);
+if (group !== pid || identity === undefined) {
+  throw new Error("Cannot verify the native shell's process-group birth.");
+}
+function verifyOwner(dir: string, claim: string): void {
+  const owner = read(path.join(dir, "actor.lock/process.json"), processSchema);
+  if (
+    !owner ||
+    owner.token !== claim ||
+    !verifyProcess(owner) ||
+    fs.existsSync(path.join(dir, `stopping-${claim}.json`))
+  ) {
+    throw new Error("Native shell owner is absent, replaced or stopping.");
+  }
+}
+verifyOwner(directory, token);
+write(
+  path.join(directory, "shells", token, `${randomUUID()}.json`),
+  {
+    pid,
+    identity,
+    token,
+  },
+  true,
+);
+verifyOwner(directory, token);