totemlayer 0.1.68 → 0.1.74

package/bin/setup-receipts.mjs

@@ -0,0 +1,181 @@
+import { randomBytes, createHash } from "node:crypto";
+import { join } from "node:path";
+import { privateRead, privateWrite } from "./runtime-installation.mjs";
+import { readAgentCredential } from "./agent-profile.mjs";
+
+const path = (directory, name) => join(directory, "strict-setup", `${name}.json`);
+const read = async (directory, name) =>
+  privateRead(path(directory, name)).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+const uuid = (value) =>
+  typeof value === "string" && /^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(value);
+const matches = (request, identity, sessionId) =>
+  request?.version === 1 &&
+  request.agentId === identity.id &&
+  request.environment === identity.environment &&
+  request.sessionId === sessionId &&
+  /^[a-f0-9]{64}$/.test(request.binding ?? "") &&
+  /^[a-f0-9]{32}$/.test(request.nonce ?? "");
+const credentialFingerprint = async (profile) =>
+  createHash("sha256")
+    .update(await readAgentCredential(profile))
+    .digest("hex");
+
+export async function prepareSetupTests(profile, context) {
+  const previous = await read(profile.stateDirectory, "request");
+  const fingerprint = await credentialFingerprint(profile);
+  if (context.connectionFingerprint !== fingerprint)
+    throw Object.assign(new Error("Credential generation changed."), {
+      code: "SETUP_BINDING_CHANGED",
+    });
+  if (
+    previous &&
+    (previous.binding !== context.binding ||
+      previous.agentId !== profile.agentId ||
+      previous.sessionId !== context.host.sessionId)
+  )
+    throw Object.assign(new Error("Saved verification belongs to another host binding."), {
+      code: "SETUP_BINDING_CHANGED",
+    });
+  const request = previous ?? {
+    version: 1,
+    binding: context.binding,
+    agentId: profile.agentId,
+    environment: profile.environment,
+    sessionId: context.host.sessionId,
+    model: context.host.model,
+    nonce: randomBytes(16).toString("hex"),
+    issuedAt: Date.now(),
+    credentialFingerprint: fingerprint,
+  };
+  if (!previous) await privateWrite(path(profile.stateDirectory, "request"), request);
+  return { marker: `Totem setup test ${request.nonce}`, issuedAt: request.issuedAt };
+}
+
+/** Only the existing native queue adapter records dispatch; no public proof-submission tool exists. */
+export async function observeSetupDispatch({ directory, identity, sessionId, kind, id, text }) {
+  if (typeof directory !== "string" || !["peer", "ownerChat"].includes(kind)) return;
+  const request = await read(directory, "request");
+  if (
+    !matches(request, identity, sessionId) ||
+    !uuid(id) ||
+    typeof text !== "string" ||
+    !text.includes(`Totem setup test ${request.nonce}`)
+  )
+    return;
+  const previous = await read(directory, `${kind}-dispatch`);
+  if (previous && previous.id !== id) return;
+  await privateWrite(path(directory, `${kind}-dispatch`), {
+    version: 1,
+    binding: request.binding,
+    id,
+    sessionId,
+    dispatchedAt: Date.now(),
+  });
+}
+
+export async function recordSetupPeerReply({
+  profile,
+  identity,
+  message,
+  reply,
+  client,
+  sessionId,
+}) {
+  const request = await read(profile.stateDirectory, "request");
+  if (!request || request.credentialFingerprint !== (await credentialFingerprint(profile))) return;
+  if (
+    !matches(request, identity, sessionId) ||
+    message.to !== identity.address ||
+    message.from === identity.address ||
+    !uuid(reply?.id) ||
+    reply.inReplyToId !== message.id ||
+    reply.conversationId !== message.conversationId ||
+    reply.to !== message.from ||
+    reply.from !== identity.address ||
+    !message.content?.text?.includes(`Totem setup test ${request.nonce}`)
+  )
+    return;
+  const dispatch = await read(profile.stateDirectory, "peer-dispatch");
+  if (dispatch?.id !== message.id || dispatch.binding !== request.binding) return;
+  const receivedAt = Date.parse(message.createdAt);
+  if (!Number.isFinite(receivedAt) || receivedAt < request.issuedAt) return;
+  const replies = [];
+  let cursor;
+  for (let page = 0; page < 50; page++) {
+    const result = await client.conversations.messages(message.conversationId, {
+      limit: 100,
+      ...(cursor ? { cursor } : {}),
+    });
+    replies.push(...result.data.filter((item) => item.inReplyToId === message.id));
+    if (!result.nextCursor) {
+      cursor = undefined;
+      break;
+    }
+    cursor = result.nextCursor;
+  }
+  if (cursor || replies.length !== 1 || replies[0].id !== reply.id) return;
+  const acknowledged = await client.messages.get(message.id);
+  if (acknowledged.state !== "acknowledged") return;
+  await privateWrite(path(profile.stateDirectory, "peer"), {
+    binding: request.binding,
+    nativeSessionId: sessionId,
+    messageId: message.id,
+    replyId: reply.id,
+    receivedAt,
+    repliedAt: Date.now(),
+    correlated: true,
+    exactlyOneReply: true,
+    acknowledgedAfterReply: true,
+    authorized: true,
+    newMessageTriggeredWake: true,
+    appearedInNativeChat: true,
+  });
+}
+
+export async function recordSetupOwnerChat({
+  profile,
+  identity,
+  commandId,
+  saved,
+  result,
+  text,
+  sessionId,
+  leaseRenewed,
+}) {
+  const request = await read(profile.stateDirectory, "request");
+  if (!request || request.credentialFingerprint !== (await credentialFingerprint(profile))) return;
+  if (
+    !matches(request, identity, sessionId) ||
+    !text?.includes(`Totem setup test ${request.nonce}`) ||
+    !uuid(commandId) ||
+    !uuid(saved.chatId) ||
+    !uuid(result?.event?.id) ||
+    result.run?.state !== "completed" ||
+    result.event.chatId !== saved.chatId ||
+    leaseRenewed !== true
+  )
+    return;
+  const dispatch = await read(profile.stateDirectory, "ownerChat-dispatch");
+  if (dispatch?.id !== commandId || dispatch.binding !== request.binding) return;
+  await privateWrite(path(profile.stateDirectory, "ownerChat"), {
+    binding: request.binding,
+    commandId,
+    chatId: saved.chatId,
+    eventId: result.event.id,
+    queuedAt: dispatch.dispatchedAt,
+    completedAt: Date.now(),
+    claimed: true,
+    leaseRenewed: true,
+    completedInOriginalChat: true,
+    authorized: true,
+  });
+}
+
+export async function readSetupTests(profile) {
+  return {
+    peer: await read(profile.stateDirectory, "peer"),
+    ownerChat: await read(profile.stateDirectory, "ownerChat"),
+  };
+}

package/bin/strict-codex-adapter.mjs

@@ -0,0 +1,456 @@
+import { createHash } from "node:crypto";
+import { opendir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { setTimeout as sleep } from "node:timers/promises";
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+import { pluginConnectionOptions, createPluginConnector } from "./plugin-connect.mjs";
+import { installTotemMcp } from "./mcp-install.mjs";
+import { connectCodexHarness, ensureInteractiveHarness } from "./harness-bootstrap.mjs";
+import { bindInteractiveProfile, readAgentProfile, readAgentCredential } from "./agent-profile.mjs";
+import { readAgentRuntimeStatus } from "./agent-runner.mjs";
+import { automaticEnabled } from "./automatic-runtime.mjs";
+import { runtimeRoot, privateRead, privateWrite } from "./runtime-installation.mjs";
+import { readReleaseSetupGuide } from "./setup-guide.mjs";
+import { prepareSetupTests, readSetupTests } from "./setup-receipts.mjs";
+import { defaultCodexQueue } from "./codex-chat-bridge.mjs";
+
+const execute = promisify(execFile);
+const fail = (code) => {
+  throw Object.assign(new Error(code), { code });
+};
+function mcpIdentity(result) {
+  if (result.isError) fail("MCP_IDENTITY_UNVERIFIED");
+  const payload =
+    result.structuredContent ??
+    JSON.parse(result.content.find((item) => item.type === "text").text);
+  return payload.data ?? payload;
+}
+const sha = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const missing = async (promise) =>
+  promise.catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+
+async function stateSnapshot(directory, prefix = "", result = {}) {
+  const entries = await missing(opendir(join(directory, prefix)));
+  if (!entries) return result;
+  for await (const entry of entries) {
+    if (Object.keys(result).length > 10000) fail("RECOVERY_STATE_TOO_LARGE");
+    const relative = join(prefix, entry.name);
+    if (entry.isDirectory() && /^[a-f0-9]{64}$/.test(entry.name))
+      await stateSnapshot(directory, relative, result);
+    else if (entry.isFile() && /^[a-f0-9]{64}\.json$/.test(entry.name)) {
+      const contents = await readFile(join(directory, relative));
+      if (contents.length > 1048576) fail("RECOVERY_STATE_TOO_LARGE");
+      result[relative] = createHash("sha256").update(contents).digest("hex");
+    }
+  }
+  return result;
+}
+
+/** Uses installed native metadata and Totem's existing bound MCP connector; never chooses a model. */
+export function createStrictCodexAdapter(flags, options = {}) {
+  const inherited = options.env ?? process.env;
+  const write = options.write ?? ((value) => process.stdout.write(JSON.stringify(value) + "\n"));
+  const baseUrl = flags.baseUrl;
+  let selection = pluginConnectionOptions(
+    [
+      "--provider",
+      "codex",
+      "--base-url",
+      baseUrl,
+      ...(flags.deviceLogin ? ["--device-login"] : []),
+      ...(flags.noBrowser ? ["--no-browser"] : []),
+      ...(flags.agentId ? ["--agent-id", flags.agentId] : []),
+      ...(flags.environment ? ["--environment", flags.environment] : []),
+    ],
+    inherited,
+  );
+  let env = { ...inherited, TOTEM_CONFIG_DIR: selection.configDirectory };
+  let rpc,
+    host,
+    connector,
+    client,
+    profile,
+    existing,
+    identity,
+    activation,
+    requested = false,
+    existingEntry;
+  const pause = options.sleep ?? sleep;
+  async function snapshot() {
+    const threadId = flags.sessionId ?? inherited.CODEX_THREAD_ID;
+    if (!/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(threadId ?? ""))
+      fail("EXACT_NATIVE_SESSION_REQUIRED");
+    if (!rpc) {
+      rpc = (options.connectHarness ?? connectCodexHarness)(inherited);
+      await rpc.initialize();
+    }
+    // Resuming with no overrides reads the persisted model and policy. No turn starts.
+    const current = await rpc.request("thread/resume", { threadId });
+    if (
+      current?.thread?.id !== threadId ||
+      current.thread.ephemeral !== false ||
+      current.thread.archived
+    )
+      fail("EXACT_NATIVE_SESSION_REQUIRED");
+    if (!current.model || (flags.model && current.model !== flags.model))
+      fail("CURRENT_MODEL_UNVERIFIED");
+    return {
+      name: "codex",
+      model: current.model,
+      sessionId: threadId,
+      modelVerified: true,
+      policyDigest: sha([
+        current.modelProvider,
+        current.approvalPolicy,
+        current.sandbox,
+        current.permissionProfile,
+        current.reasoningEffort,
+        current.serviceTier,
+      ]),
+    };
+  }
+  async function attach() {
+    connector ??= (options.createConnector ?? createPluginConnector)(selection, {
+      env: { ...inherited, TOTEM_MODEL: host.model },
+      // Authentication prepares tools only. The controller verifies MCP identity before receiving starts.
+      activate: async () => ({ state: "needs_attention", ready: false, persistent: false }),
+      ensureHarness: async (saved, environment) => {
+        const verified = await client.callTool({ name: "totem_get_identity", arguments: {} });
+        const own = mcpIdentity(verified);
+        if (
+          own.id !== saved.agentId ||
+          own.address !== saved.address ||
+          own.environment !== saved.environment ||
+          !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(own.organization?.id ?? "")
+        )
+          fail("AGENT_IDENTITY_MISMATCH");
+        const checked = await snapshot();
+        if (JSON.stringify(checked) !== JSON.stringify(host)) fail("CURRENT_MODEL_CHANGED");
+        if (saved.codexThreadId && saved.codexThreadId !== host.sessionId)
+          fail("EXISTING_RECEIVER_SESSION_CONFLICT");
+        if (saved.model !== "default" && saved.model !== host.model) fail("CURRENT_MODEL_CHANGED");
+        profile = saved.codexThreadId ? saved : await bindInteractiveProfile(saved, host.sessionId);
+        profile = await (options.ensureHarness ?? ensureInteractiveHarness)(profile, environment);
+        return profile;
+      },
+    });
+    if (!client) {
+      const [local, server] = InMemoryTransport.createLinkedPair();
+      client = new Client({ name: "totem_strict_installer", version: "1" });
+      await connector.server.connect(server);
+      await client.connect(local);
+    }
+    const pending = connector.start();
+    let done = false;
+    void pending.then(
+      () => {
+        done = true;
+      },
+      () => {
+        done = true;
+      },
+    );
+    while (!done) {
+      const status = await connector.status();
+      if (status.state === "sign_in_required" && !requested) {
+        requested = true;
+        await write({
+          stage: "sign_in_required",
+          url: status.signInUrl,
+          ...(status.approvalCode ? { approvalCode: status.approvalCode } : {}),
+          message: "Sign in and approve this exact agent connection in Totem.",
+        });
+      }
+      await pause(500);
+    }
+    await pending;
+    const status = await connector.status();
+    if (!status.toolsConnected) fail(status.code ?? "CONNECTION_APPROVAL_REQUIRED");
+    const result = await client.callTool({ name: "totem_get_identity", arguments: {} });
+    identity = mcpIdentity(result);
+    if (!profile?.codexThreadId || profile.codexThreadId !== host.sessionId)
+      fail("EXACT_RECEIVER_UNVERIFIED");
+    if (!profile && status.agentId)
+      profile = await readAgentProfile(status.agentId, { environment: env });
+    return {
+      identity,
+      mcpIdentityVerified: true,
+      transport: "mcp",
+      origin: baseUrl,
+      fingerprint: createHash("sha256")
+        .update(await readAgentCredential(profile))
+        .digest("hex"),
+    };
+  }
+  return {
+    readGuide: options.readGuide ?? readReleaseSetupGuide,
+    async inspect(readOnly = false) {
+      host = await snapshot();
+      const result = await (options.execute ?? execute)("codex", ["mcp", "list", "--json"], {
+        env: inherited,
+        encoding: "utf8",
+        timeout: 5000,
+        maxBuffer: 65536,
+      }).catch((error) => {
+        if (
+          /no mcp server|not found|does not exist/i.test(
+            `${error.stdout ?? ""}\n${error.stderr ?? ""}`,
+          )
+        )
+          return null;
+        fail("MCP_SETTINGS_UNVERIFIED");
+      });
+      if (result) {
+        const entries = JSON.parse(result.stdout);
+        if (!Array.isArray(entries)) fail("MCP_SETTINGS_UNVERIFIED");
+        let candidates = entries.filter((entry) => {
+          const t = entry.transport;
+          if (t?.type === "streamable_http") {
+            try {
+              return new URL(t.url).origin === baseUrl && new URL(t.url).pathname === "/mcp";
+            } catch {
+              return false;
+            }
+          }
+          return (
+            t?.type === "stdio" &&
+            Array.isArray(t.args) &&
+            /totem/i.test(`${t.command} ${t.args.join(" ")}`) &&
+            (t.args.includes("connect") || t.args.includes("mcp"))
+          );
+        });
+        // Prefer a fully scoped match while retaining unknown OAuth/legacy entries
+        // as conflicts. Known other identities are not this agent's connection.
+        if (flags.agentId) {
+          const scoped = new Map();
+          for (const entry of candidates) {
+            const args = entry.transport?.args;
+            if (entry.transport?.type !== "stdio" || !args?.includes("connect")) continue;
+            try {
+              scoped.set(
+                entry,
+                pluginConnectionOptions(args.slice(args.indexOf("connect") + 1), inherited),
+              );
+            } catch {
+              /* An unknown existing binding must remain preserved. */
+            }
+          }
+          const matches = (saved) =>
+            saved?.agentId === flags.agentId &&
+            saved.baseUrl === baseUrl &&
+            (!flags.environment || saved.environment === flags.environment);
+          if ([...scoped.values()].some(matches))
+            candidates = candidates.filter(
+              (entry) => !scoped.has(entry) || matches(scoped.get(entry)),
+            );
+        }
+        if (candidates.length > 1) fail("MULTIPLE_MCP_CONNECTIONS_REQUIRE_SELECTION");
+        const entry = candidates[0];
+        if (entry) {
+          if (entry.enabled === false) fail("RECEIVER_INTENTIONALLY_PAUSED");
+          // A native OAuth connection must be reused through that host, never duplicated by this installer.
+          if (
+            entry.transport?.type !== "stdio" ||
+            !entry.transport.args?.includes("connect") ||
+            !entry.transport.args?.includes("codex")
+          )
+            fail("EXISTING_MCP_REQUIRES_NATIVE_RECEIVER_ADAPTER");
+          const args = entry.transport.args.slice(entry.transport.args.indexOf("connect") + 1);
+          const chosen = pluginConnectionOptions(args, inherited);
+          if (
+            chosen.baseUrl !== baseUrl ||
+            (flags.agentId && chosen.agentId !== flags.agentId) ||
+            (flags.environment && chosen.environment !== flags.environment)
+          )
+            fail("AGENT_IDENTITY_MISMATCH");
+          if (entry.transport.env?.TOTEM_AUTO_START === "0") fail("RECEIVER_INTENTIONALLY_PAUSED");
+          if (entry.transport.env?.TOTEM_CONFIG_DIR)
+            fail("EXISTING_MCP_REQUIRES_NATIVE_RECEIVER_ADAPTER");
+          selection = chosen;
+          env = { ...inherited, TOTEM_CONFIG_DIR: selection.configDirectory };
+          existingEntry = entry;
+        }
+      }
+      const binding = await missing(
+        privateRead(join(selection.configDirectory, "plugin-binding.json")),
+      );
+      let paused = false;
+      if (binding) {
+        profile = await readAgentProfile(binding.profile, { environment: env });
+        if (
+          profile.provider !== "codex" ||
+          profile.baseUrl !== baseUrl ||
+          (flags.agentId && profile.agentId !== flags.agentId)
+        )
+          fail("AGENT_IDENTITY_MISMATCH");
+        paused = !(await automaticEnabled(profile));
+        // A pause is an entirely read-only path, including native harness preparation.
+        if (paused) {
+          const { readAgentCredential } = await import("./agent-profile.mjs");
+          const { createTotemMcpServer } = await import("./mcp.mjs");
+          const server = createTotemMcpServer({
+            apiKey: await readAgentCredential(profile),
+            baseUrl,
+            expectedAgentId: profile.agentId,
+            expectedEnvironment: profile.environment,
+          });
+          const [a, b] = InMemoryTransport.createLinkedPair();
+          const reader = new Client({ name: "totem_paused_identity_check", version: "1" });
+          try {
+            await server.connect(b);
+            await reader.connect(a);
+            const result = await reader.callTool({ name: "totem_get_identity", arguments: {} });
+            identity = mcpIdentity(result);
+          } finally {
+            await reader.close();
+            await server.close();
+          }
+          existing = {
+            identity,
+            mcpIdentityVerified: true,
+            transport: "mcp",
+            origin: baseUrl,
+            fingerprint: createHash("sha256")
+              .update(await readAgentCredential(profile))
+              .digest("hex"),
+          };
+        } else if (!readOnly) existing = await attach();
+      }
+      return { host, customMcp: true, paused, ...(existing ? { connection: existing } : {}) };
+    },
+    async connect(transport) {
+      if (transport !== "mcp") fail("MCP_REQUIRED");
+      // Pin the exact current chat before exposing the self-starting entry to the native host.
+      const connected = await attach();
+      if (!existingEntry)
+        await (options.installMcp ?? installTotemMcp)(
+          [
+            "codex",
+            "--base-url",
+            baseUrl,
+            ...(flags.deviceLogin ? ["--device-login"] : []),
+            ...(flags.noBrowser ? ["--no-browser"] : []),
+            ...(flags.agentId ? ["--agent-id", flags.agentId] : []),
+            ...(flags.environment ? ["--environment", flags.environment] : []),
+          ],
+          inherited,
+        );
+      return connected;
+    },
+    async identity(connection) {
+      return connection.identity;
+    },
+    async configureReceiver() {
+      if (!profile) fail("EXACT_RECEIVER_UNVERIFIED");
+      if (!(await automaticEnabled(profile))) fail("RECEIVER_INTENTIONALLY_PAUSED");
+      const { activateConnection } = await import("./installation.mjs");
+      activation = await (options.activateConnection ?? activateConnection)(profile, {
+        ...env,
+        TOTEM_HOST_LOCK_ROOT: runtimeRoot(inherited),
+      });
+    },
+    async readReceiver(context) {
+      let current;
+      for (let attempt = 0; attempt < 16; attempt++) {
+        current = await readAgentRuntimeStatus(profile);
+        if (Number.isFinite(current.measuredCheckSeconds) || !current.running) break;
+        await pause(1000);
+      }
+      return {
+        binding: context.binding,
+        count: current.running ? 1 : 0,
+        sameConnection: true,
+        running: current.listenerReady,
+        intervalSeconds: current.receiverIntervalSeconds,
+        measuredCheckSeconds: current.measuredCheckSeconds,
+        independentOfModel: true,
+        silentWhenIdle: true,
+        bothQueues: true,
+        privateState: true,
+        startupEnabled: activation?.persistent === true,
+        restartOnFailure: activation?.persistent === true,
+        persistent: activation?.persistent === true,
+        paused: !(await automaticEnabled(profile)),
+      };
+    },
+    readHost: snapshot,
+    async verifyRecovery(context) {
+      const current = await readAgentRuntimeStatus(profile);
+      const file = join(profile.stateDirectory, "strict-setup", "recovery.json");
+      const previous = await missing(privateRead(file));
+      if (
+        previous?.binding === context.binding &&
+        previous.guideSha256 === context.guideSha256 &&
+        previous.newRunVerified &&
+        previous.savedStatePreserved &&
+        current.ready &&
+        current.listenerReady
+      )
+        return previous;
+      if (current.phase !== "waiting" || !current.ready) fail("RECOVERY_WAITING_FOR_IDLE");
+      const before = await stateSnapshot(profile.stateDirectory);
+      // Request a normal exit of this exact run. The supervisor remains enabled and owns restart.
+      await privateWrite(join(profile.stateDirectory, "runner", `${current.runId}.stop`), {
+        runId: current.runId,
+      });
+      for (let attempt = 0; attempt < 120; attempt++) {
+        if (!(await automaticEnabled(profile))) fail("RECEIVER_INTENTIONALLY_PAUSED");
+        const after = await readAgentRuntimeStatus(profile);
+        if (after.runId !== current.runId && after.ready && after.listenerReady) {
+          const saved = await stateSnapshot(profile.stateDirectory);
+          const receipt = {
+            binding: context.binding,
+            guideSha256: context.guideSha256,
+            newRunVerified: true,
+            savedStatePreserved: Object.entries(before).every(
+              ([name, hash]) => saved[name] === hash,
+            ),
+            ownerPausePreserved: true,
+            noDuplicateReceiver: true,
+          };
+          await privateWrite(file, receipt);
+          return receipt;
+        }
+        await pause(1000);
+      }
+      return { binding: context.binding, newRunVerified: false };
+    },
+    async requestTests(context) {
+      const test = await prepareSetupTests(profile, context);
+      await write({
+        stage: "tests_requested",
+        marker: test.marker,
+        message:
+          "Send one permitted peer message containing this marker, and separately send an owner message containing it in this agent's Totem website chat. Use only an already approved peer. Receiving stays active; no further native prompt is needed.",
+      });
+      const noticePath = join(profile.stateDirectory, "strict-setup", "test-notice.json");
+      if (!(await missing(privateRead(noticePath)))) {
+        await defaultCodexQueue({
+          threadId: host.sessionId,
+          environment: inherited,
+          prompt: `Totem's strict installer is waiting for its required incoming tests. Ask this owner to send one permitted incoming peer message containing ${test.marker}, and separately send an owner website-chat message containing that marker in this identity's original Totem chat. Do not send unsolicited traffic or change permissions. The installed receiver and verifier remain active; no further native prompt is needed. Report the tests as pending until their independent receipts exist.`,
+        });
+        await privateWrite(noticePath, { markerIssuedAt: test.issuedAt });
+      }
+    },
+    async readTests() {
+      const deadline = Date.now() + flags.waitSeconds * 1000;
+      do {
+        const tests = await readSetupTests(profile);
+        if (tests.peer && tests.ownerChat) return tests;
+        if (!(await automaticEnabled(profile))) fail("RECEIVER_INTENTIONALLY_PAUSED");
+        if (Date.now() >= deadline) return tests;
+        await pause(1000);
+      } while (true);
+    },
+    async close() {
+      await client?.close();
+      await connector?.close();
+      await rpc?.close();
+    },
+  };
+}