@topolo/cli 0.13.19 → 0.13.22

package/dist/{claude-pack-backend-YEVPAOID.js → chunk-UY5LEU5C.js}

@@ -1,4 +1,75 @@
 #!/usr/bin/env node
+import {
+  acknowledgeClaudeDesktopProfile,
+  readClaudeDesktopProfile,
+  verifyClaudeDesktopProfileNative
+} from "./chunk-NYDIAYVY.js";
+
+// src/lib/claude-frontdoor-state.ts
+async function observeClaudeFrontdoors(manager, members, check, warm = false, checkpoint = () => {
+}) {
+  if (!Array.isArray(members) || members.length !== 3 || new Set(members.map((m) => m.sessionId)).size !== 3) throw Error("Exact three front doors required.");
+  const result = [];
+  for (const m of members) {
+    check();
+    let raw = await manager.getSessionWhenLoaded(m.sessionId, "topolo-launch-frontdoors", { warnOnMiss: false });
+    let dto = await manager.getSession(m.sessionId);
+    check();
+    if (!raw || !dto || raw.sessionId !== m.sessionId || dto.sessionId !== m.sessionId || raw.cwd !== m.cwd || dto.cwd !== m.cwd || dto.title !== m.title || raw.isArchived || dto.isArchived || raw.isRunning || raw.starting || raw.pendingCycle || raw.pendingToolPermissions?.length || manager.hasLosableWork(m.sessionId) || !raw.cliSessionId || m.cliSessionId && m.cliSessionId !== raw.cliSessionId || dto.isStarred !== true || ["model", "effort", "permissionMode"].some((k) => dto[k] !== m[k])) throw Error("Installed coordinator identity, settings or custody differ.");
+    if (warm && !raw.query) {
+      if (typeof manager.warmSession !== "function") throw Error("Native connect-only warm capability unavailable.");
+      checkpoint({ kind: "frontdoor-connect-only-attempt", sessionId: m.sessionId, cliSessionId: raw.cliSessionId });
+      await manager.warmSession(m.sessionId, { connectOnly: true });
+      check();
+      raw = await manager.getSessionWhenLoaded(m.sessionId, "topolo-launch-frontdoors", { warnOnMiss: false });
+      dto = await manager.getSession(m.sessionId);
+      check();
+    }
+    if (!raw?.query || raw.bypassAvailableAtSpawn !== true || raw.isRunning || raw.pendingCycle || raw.pendingToolPermissions?.length || manager.hasLosableWork(m.sessionId) || raw.cliSessionId !== (m.cliSessionId ?? raw.cliSessionId) || ["model", "effort", "permissionMode"].some((k) => dto[k] !== m[k])) throw Error("Coordinator effective startup permission is unverified.");
+    result.push({ key: m.key, sessionId: m.sessionId, cliSessionId: raw.cliSessionId, cwd: m.cwd, title: m.title, model: dto.model, effort: dto.effort, permissionMode: dto.permissionMode, pinned: true });
+  }
+  return { state: "installed-frontdoors-verified", members: result, nativeInputsSent: false };
+}
+
+// src/lib/claude-readiness-restart.ts
+async function adoptClaudeReadinessHistory(manager, members, created, operationId, contextDigest, previousPid, currentPid, check, checkpoint, crypto, kill) {
+  if (!Number.isSafeInteger(previousPid) || previousPid < 1 || previousPid === currentPid) throw Error("Distinct original Desktop process required.");
+  try {
+    kill(previousPid, 0);
+    throw Error("Original Desktop process is still alive.");
+  } catch (error) {
+    if (error.code !== "ESRCH") throw Error("Original Desktop process is not independently proven dead.");
+  }
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.coordinator-bootstrap.v1"), old = manager[key];
+  if (old !== void 0 && !(old instanceof Map)) throw Error("Unknown native bootstrap custody.");
+  if (old?.size) throw Error("Existing native reservations require ordinary same-process continuation.");
+  const starts = manager.inFlightStarts;
+  if (!starts || ["hasStartInFlight", "hasStartAbortController", "hasDeferredTeardown", "pendingStartModel"].some((k) => typeof starts[k] !== "function") || !(manager.pendingPopSpawnsInFlight instanceof Map) || !(manager.sideSessionStartsInFlight instanceof Map) || typeof manager.warmSession !== "function") throw Error("Native restart custody capabilities unavailable.");
+  const receipts = [];
+  for (const member of members) {
+    check();
+    const id = member.sessionId;
+    if (starts.hasStartInFlight(id) || starts.hasStartAbortController(id) || starts.hasDeferredTeardown(id) || starts.pendingStartModel(id) !== void 0 || manager.pendingPopSpawnsInFlight.has(id) || manager.sideSessionStartsInFlight.has(id) || manager.hasLosableWork(id)) throw Error("Readiness identity has pending native custody.");
+    const raw = await manager.getSessionWhenLoaded(id, "topolo-readiness-restart", { warnOnMiss: false }), dto = await manager.getSession(id), history = await manager.getTranscript(id);
+    check();
+    if (!created.includes(id)) {
+      if (raw || dto || !Array.isArray(history) || history.length) throw Error("Uncreated readiness identity has existing history.");
+      continue;
+    }
+    if (!raw || !dto || raw.sessionId !== id || dto.sessionId !== id || raw.cwd !== member.cwd || dto.cwd !== member.cwd || raw.title !== member.title || dto.title !== member.title || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.query || raw.spawnedFrom || raw.worktreePath || raw.worktreeLazy || raw.isArchived || dto.isArchived || raw.isRunning || dto.isRunning || raw.pendingCycle || raw.pendingToolPermissions?.length || raw.pendingFirstStart || raw.pendingSystemReminder || raw.interruptedAwaitingPerson || raw.queuedSideSessionNotes?.length || raw.pendingRewindTo || raw.stoppedUntilPersonSends || raw.armedWorkAtQuit || raw.interruptedByQuitAt || raw.remoteControlLiveAtUpdateQuit || raw.scheduledTaskId || raw.keptResent?.size || raw.heldAcrossLoss?.length || raw.queuedMessages?.length || raw.messageQueue?.length || raw.unreadInputUuids?.length || raw.heldQueuedSendUuids?.length || !Array.isArray(history) || ["model", "effort", "permissionMode"].some((k) => raw[k] !== member[k] || dto[k] !== member[k]) || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(raw.cliSessionId ?? "")) throw Error("Cold readiness identity, settings or native work differs.");
+    const users = history.filter((r) => r.type === "user"), assistants = history.filter((r) => r.type === "assistant"), workerId = id.replace(/^local_/, ""), content = users[0]?.message?.content;
+    const text = typeof content === "string" ? content : Array.isArray(content) && content.every((r) => r.type === "text") ? content.map((r) => r.text).join("") : null;
+    const answer = assistants[0]?.message;
+    if (users.length !== 1 || users[0].uuid !== workerId || text !== "Installation readiness probe only. Do not use tools, read task files, dispatch work or perform any task. Reply exactly TOPOLO_WORKER_READY:" + workerId || assistants.length !== 1 || answer?.model !== member.model || answer.stop_reason !== "end_turn" || !Array.isArray(answer.content) || answer.content.length !== 1 || answer.content[0].type !== "text" || answer.content[0].text !== "TOPOLO_WORKER_READY:" + workerId || !assistants[0].uuid || history.some((r) => r.type === "result" || r.type === "command_lifecycle" || r.type === "assistant" && r.message?.content?.some((c) => c.type === "tool_use"))) throw Error("Only one persisted fixed tool-free readiness exchange can be adopted.");
+    receipts.push({ kind: "coordinator-readiness-history-adopted", operationId, sessionId: id, cliSessionId: raw.cliSessionId, userUuid: workerId, assistantUuid: assistants[0].uuid, contextDigest, historyDigest: crypto.createHash("sha256").update(JSON.stringify(history)).digest("hex"), previousPid, currentPid, originalTerminalUnknown: true, nativeInputsReplayed: false });
+  }
+  check();
+  for (const receipt of receipts) checkpoint(receipt);
+  const records = /* @__PURE__ */ new Map();
+  for (const row of receipts) records.set(row.sessionId, { state: "restart-adopted", operationId, cliSessionId: row.cliSessionId, historyAdopted: true });
+  manager[key] = records;
+  return receipts;
+}
 
 // src/lib/claude-pack-backend.ts
 import { createHash as createHash2, randomBytes, randomUUID } from "crypto";
@@ -1154,7 +1225,857 @@ async function nativeClaudeLaneControl(net, fs, manager, descriptor, token, invo
   return { state: "private-native-lane-control-ready", ...descriptor };
 }
 
+// src/lib/claude-native-capabilities.ts
+function discoverClaudeNativeCapabilities(load, resourcesPath, bypassAllowed) {
+  const prefix = resourcesPath + "/app.asar/";
+  const candidates = Object.values(load.cache ?? {}).filter((entry) => typeof entry?.filename === "string" && entry.filename.startsWith(prefix) && entry.exports?.claudeCodeSessionManager);
+  const managers = [...new Set(candidates.map((entry) => entry.exports.claudeCodeSessionManager))];
+  if (managers.length !== 1) throw new Error("Native session-manager discovery is unavailable or ambiguous.");
+  const manager = managers[0];
+  const required = [
+    "getSession",
+    "getSessionWhenLoaded",
+    "getAvailableCodeModels",
+    "hasLosableWork",
+    "setModel",
+    "setEffort",
+    "setPermissionMode"
+  ];
+  for (const name of required) {
+    if (typeof manager[name] !== "function") throw new Error("Native settings capability missing: " + name);
+  }
+  const methods = Object.fromEntries(required.map((name) => [name, manager[name]]));
+  const assertCurrent = () => {
+    const current = Object.values(load.cache ?? {}).filter((entry) => typeof entry?.filename === "string" && entry.filename.startsWith(prefix) && entry.exports?.claudeCodeSessionManager);
+    if (!current.length || current.some((entry) => entry.exports.claudeCodeSessionManager !== manager) || required.some((name) => manager[name] !== methods[name]))
+      throw new Error("Native settings capabilities changed during the operation.");
+  };
+  return { manager, assertCurrent, bypassAllowed, evidence: {
+    contract: "topolo-claude-native-settings-v1",
+    modulePaths: candidates.map((entry) => entry.filename),
+    required
+  } };
+}
+function discoverClaudeSidebar(load, resourcesPath) {
+  const find = () => {
+    const functions = [...new Set(Object.values(load.cache ?? {}).filter((entry) => entry?.filename?.startsWith(resourcesPath + "/app.asar/")).flatMap((entry) => Object.values(entry.exports ?? {}).filter((value) => typeof value === "function")))];
+    const send = functions.filter((fn) => fn.length === 2 && String(fn).length < 2e3 && String(fn).includes(".dispatchSidebarCommand("));
+    const acknowledge = functions.filter((fn) => {
+      const source = String(fn);
+      return source.length < 2e3 && source.includes(".randomUUID)()") && source.includes("new Promise") && source.includes("setTimeout") && source.includes(".set(") && source.includes("{ok:!1,error:");
+    });
+    if (send.length !== 1 || acknowledge.length !== 1)
+      throw new Error("Native acknowledged sidebar capability is unavailable or ambiguous.");
+    return { send: send[0], acknowledge: acknowledge[0] };
+  };
+  const { send: sendCommand, acknowledge: awaitAcknowledgement } = find();
+  return async (command) => {
+    const current = find();
+    if (current.send !== sendCommand || current.acknowledge !== awaitAcknowledgement)
+      throw new Error("Native sidebar capabilities changed during the operation.");
+    const result = await awaitAcknowledgement(command, sendCommand, 1e4);
+    if (result?.ok !== true) throw new Error(result?.error || "Native sidebar pin acknowledgement refused.");
+    return result;
+  };
+}
+async function applyClaudeNativeSettings(capabilities, members, operationId, deadline, checkpoint, verifyContext, apply, sidebar) {
+  const { manager, assertCurrent } = capabilities;
+  const pinAcknowledgements = /* @__PURE__ */ new Map();
+  const fence = /* @__PURE__ */ Symbol.for("topolo.agent-pack.native-operation.v1");
+  if (!operationId || !Number.isFinite(deadline) || !members.length || members.length > 100 || new Set(members.map((m) => m.sessionId)).size !== members.length || new Set(members.map((m) => m.key)).size !== members.length)
+    throw new Error("Unique owned settings roster and operation identity required.");
+  if (manager[fence]) throw new Error("Unresolved native operation; reconcile before mutation.");
+  const check = () => {
+    assertCurrent();
+    if (Date.now() >= deadline) throw new Error("Native settings deadline expired.");
+    verifyContext();
+    if (members.some((m) => m.permissionMode === "bypassPermissions") && capabilities.bypassAllowed?.() !== true)
+      throw new Error("Native app-level bypass permission is disabled or unverified; enable the account opt-in in Claude Settings.");
+  };
+  const read = async (member) => {
+    check();
+    const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-agent-pack", { warnOnMiss: false });
+    const dto = await manager.getSession(member.sessionId);
+    check();
+    for (const row of [raw, dto]) {
+      if (!row || row.sessionId !== member.sessionId || row.cwd !== member.cwd || row.title !== member.title || row.isArchived || row.importedUnconfirmed === true)
+        throw new Error("Owned native session identity changed: " + member.key);
+      if (row.isRunning || row.starting || row.pendingToolPermissions?.length)
+        throw new Error("Native session has active work: " + member.key);
+    }
+    if (manager.hasLosableWork(member.sessionId) || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom)
+      throw new Error("Native session is not an idle owned local coordinator: " + member.key);
+    if (raw.query != null && dto.permissionMode === "bypassPermissions" && raw.bypassAvailableAtSpawn !== true)
+      throw new Error("Bypass permissions were not available when this native process started: " + member.key);
+    return {
+      key: member.key,
+      sessionId: member.sessionId,
+      model: dto.model ?? null,
+      effort: dto.effort ?? null,
+      permissionMode: dto.permissionMode ?? null,
+      ...pinAcknowledgements.has(member.sessionId) ? { pinned: pinAcknowledgements.get(member.sessionId) } : {},
+      processAttached: raw.query != null,
+      startupPermissionVerified: raw.query != null && (dto.permissionMode !== "bypassPermissions" || raw.bypassAvailableAtSpawn === true)
+    };
+  };
+  for (const member of members) {
+    if (member.pinned !== void 0 && (typeof member.pinned !== "boolean" || !sidebar))
+      throw new Error("Requested startup pinning requires the acknowledged native sidebar capability.");
+    if (!/^local_[0-9a-f-]{36}$/.test(member.sessionId) || !member.key || !member.cwd.startsWith("/") || !member.title || !["low", "medium", "high"].includes(member.effort) || !["default", "acceptEdits", "bypassPermissions"].includes(member.permissionMode) || member.permissionMode === "bypassPermissions" && (!member.permissionConsent?.contextKey.startsWith("org:") || !member.permissionConsent.intakeKey))
+      throw new Error("Unqualified native settings request.");
+    check();
+    if (!manager.getAvailableCodeModels().includes(member.model))
+      throw new Error("Requested model absent from the native account catalog: " + member.model);
+  }
+  const before = [];
+  for (const member of members) before.push(await read(member));
+  checkpoint({ kind: "settings-baseline", operationId, before, evidence: capabilities.evidence, at: Date.now() });
+  if (!apply) return { state: "settings-preflight", before, applied: false };
+  if (manager[fence]) throw new Error("A concurrent native operation acquired the session manager.");
+  manager[fence] = { operationId, running: true, effectAttempted: false };
+  try {
+    for (const member of members) {
+      if (member.pinned !== void 0) {
+        await read(member);
+        checkpoint({ kind: "settings-pin-attempt", operationId, sessionId: member.sessionId, pinned: member.pinned, at: Date.now() });
+        manager[fence].effectAttempted = true;
+        const result = await sidebar({ kind: "set_pinned", sessionId: member.sessionId, pinned: member.pinned });
+        if (result?.ok !== true) throw new Error("Native sidebar pin acknowledgement refused: " + member.key);
+        pinAcknowledgements.set(member.sessionId, member.pinned);
+        check();
+        checkpoint({ kind: "settings-pin-acknowledged", operationId, sessionId: member.sessionId, pinned: member.pinned, at: Date.now() });
+      }
+      for (const field of ["model", "effort", "permissionMode"]) {
+        const actual = await read(member);
+        if (actual[field] === member[field]) continue;
+        if (!manager.getAvailableCodeModels().includes(member.model)) throw new Error("Native model catalog changed.");
+        checkpoint({ kind: "settings-attempt", operationId, sessionId: member.sessionId, field, value: member[field], at: Date.now() });
+        manager[fence].effectAttempted = true;
+        if (field === "model") await manager.setModel(member.sessionId, member.model);
+        else if (field === "effort") await manager.setEffort(member.sessionId, member.effort);
+        else if (!await manager.setPermissionMode(member.sessionId, member.permissionMode, "picker"))
+          throw new Error("Native permission change refused: " + member.key);
+        const after2 = await read(member);
+        if (after2[field] !== member[field]) throw new Error("Native settings read-back mismatch: " + member.key + " / " + field);
+        checkpoint({ kind: "settings-verified-field", operationId, after: after2, field, at: Date.now() });
+      }
+    }
+    const after = [];
+    for (const member of members) {
+      const row = await read(member);
+      if (row.model !== member.model || row.effort !== member.effort || row.permissionMode !== member.permissionMode)
+        throw new Error("Final native settings read-back mismatch: " + member.key);
+      after.push(row);
+    }
+    checkpoint({ kind: "settings-verified", operationId, after, at: Date.now() });
+    delete manager[fence];
+    return {
+      state: "native-settings-verified",
+      before,
+      after,
+      applied: true,
+      allStartupPermissionsVerified: after.every((row) => row.startupPermissionVerified),
+      pinsVerified: members.some((member) => member.pinned !== void 0) && members.every((member) => member.pinned === void 0 || pinAcknowledgements.get(member.sessionId) === member.pinned),
+      dispatchVerified: false,
+      sidebarVerified: false
+    };
+  } catch (error) {
+    manager[fence].running = false;
+    checkpoint({ kind: "settings-unresolved", operationId, error: String(error), at: Date.now() });
+    throw error;
+  }
+}
+
+// src/lib/claude-desktop-control.ts
+async function installClaudeDesktopControl(manager, descriptor, token, modules, actions, authorize, qualify, checkpoint, options = {}) {
+  const { net, fs, crypto, path } = modules;
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.desktop-task-control.v1");
+  qualify();
+  if (manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.desktop-coordinator-transfer.v1")]) throw new Error("Unresolved coordinator transfer; preserve custody.");
+  if (descriptor.pid !== process.pid || !/^[a-f0-9]{64}$/.test(token) || !/^[a-f0-9]{64}$/.test(descriptor.identity) || !path.isAbsolute(descriptor.runtime)) throw new Error("Native task control ownership is unavailable.");
+  const fence = /* @__PURE__ */ Symbol.for("topolo.agent-pack.desktop-task-control-replacement.v1");
+  if (manager[fence]) throw new Error("Unresolved native task-control replacement; reconcile without replay.");
+  const previous = manager[key];
+  if (previous) {
+    const existing = options.existing;
+    if (!/^[a-f0-9]{64}$/.test(options.codeIdentity ?? "") || !options.existing || Object.keys(existing).sort().join() !== Object.keys(previous.descriptor ?? {}).sort().join() || Object.keys(existing).some((name) => existing[name] !== previous.descriptor[name]) || existing.pid !== process.pid || !/^[a-f0-9]{64}$/.test(options.existingToken ?? token) || previous.server?.address() !== existing.socket || previous.failed || previous.active !== 0 || descriptor.socket !== existing.socket && fs.existsSync(descriptor.socket))
+      throw new Error("Existing native task control is not the exact owned idle connection.");
+    if (!Array.isArray(options.coordinators) || !options.coordinators.length || options.coordinators.length > 6 || new Set(options.coordinators.map((row) => row.sessionId)).size !== options.coordinators.length)
+      throw new Error("Exact idle coordinator roster required before native control replacement.");
+    for (const member of options.coordinators) {
+      const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-control-upgrade", { warnOnMiss: false });
+      const dto = await manager.getSession(member.sessionId);
+      for (const row of [raw, dto]) if (!row || row.sessionId !== member.sessionId || row.cwd !== member.cwd || row.isRunning || row.starting || row.isArchived || row.pendingToolPermissions?.length)
+        throw new Error("Coordinator has active or changed native custody.");
+      if (manager.hasLosableWork(member.sessionId)) throw new Error("Coordinator has losable native work.");
+    }
+    let probeSocket;
+    let connectionCount = 0;
+    const observeConnection = (socket) => {
+      connectionCount++;
+      probeSocket ??= socket;
+    };
+    previous.server.on("connection", observeConnection);
+    try {
+      await new Promise((done, fail) => previous.server.getConnections((error, count) => error || count !== 0 || previous.active !== 0 || connectionCount !== 0 ? fail(error ?? new Error("Native task connection is active.")) : done()));
+      const observed = await new Promise((done, fail) => {
+        const client = net.createConnection(existing.socket);
+        let bytes = "";
+        let ended = false;
+        const finish = (error, result) => {
+          if (ended) return;
+          ended = true;
+          client.once("close", () => error ? fail(error) : done(result));
+          client.destroy();
+        };
+        client.setEncoding("utf8");
+        client.setTimeout(5e3, () => finish(new Error("Owned native status timed out.")));
+        client.on("error", (error) => finish(error));
+        client.on("connect", () => client.write(JSON.stringify({ pid: existing.pid, identity: existing.identity, token: options.existingToken ?? token, operation: { kind: "status" } }) + "\n"));
+        client.on("data", (chunk) => {
+          bytes += chunk;
+          if (Buffer.byteLength(bytes) > 1048576) return finish(new Error("Owned native status exceeded bounds."));
+          if (bytes.includes("\n")) {
+            try {
+              const value = JSON.parse(bytes);
+              finish(value.error ? new Error(value.error) : null, value.result);
+            } catch (error) {
+              finish(error);
+            }
+          }
+        });
+      });
+      if (observed.harness !== "claude-desktop" || observed.pid !== existing.pid || observed.identity !== existing.identity || observed.workers !== 0)
+        throw new Error("Existing native workers retain their connection; replacement refused.");
+      await new Promise((done, fail) => {
+        if (connectionCount !== 1 || !probeSocket) return fail(new Error("Native task connection changed during status."));
+        if (probeSocket.closed) return done();
+        const timer = setTimeout(() => {
+          probeSocket.removeListener("close", closed);
+          fail(new Error("Native status socket retirement timed out."));
+        }, 5e3);
+        const closed = () => {
+          clearTimeout(timer);
+          done();
+        };
+        probeSocket.once("close", closed);
+      });
+      if (connectionCount !== 1 || previous.active !== 0) throw new Error("Native task connection changed during status.");
+      qualify();
+      if (previous.codeIdentity === options.codeIdentity && Object.keys(descriptor).every((name) => descriptor[name] === existing[name])) {
+        if (observed.qualified === false) throw new Error("Existing native guard qualification changed.");
+        checkpoint({ kind: "native-desktop-task-control-reused", ...descriptor, codeIdentity: options.codeIdentity });
+        return { state: "native-desktop-task-control-reused", ...descriptor, codeIdentity: options.codeIdentity };
+      }
+      await new Promise((done, fail) => previous.server.getConnections((error, count) => {
+        if (error || count !== 0 || previous.active !== 0 || connectionCount !== 1) return fail(error ?? new Error("Native task connection is active."));
+        manager[fence] = { descriptor, previous: existing, codeIdentity: options.codeIdentity };
+        try {
+          checkpoint({ kind: "native-desktop-task-control-retiring", ...descriptor, codeIdentity: options.codeIdentity });
+        } catch (error2) {
+          delete manager[fence];
+          return fail(error2);
+        }
+        previous.server.close((error2) => error2 ? fail(error2) : done());
+      }));
+      if (manager[key] !== previous || previous.active !== 0) throw new Error("Native control changed during retirement.");
+      checkpoint({ kind: "native-desktop-task-control-retired", ...descriptor });
+      delete manager[key];
+    } finally {
+      previous.server.removeListener("connection", observeConnection);
+    }
+  }
+  if (fs.existsSync(descriptor.socket)) throw new Error("Native task control socket remains occupied.");
+  const workers = /* @__PURE__ */ new Map();
+  const control = { active: 0, server: null, descriptor, codeIdentity: options.codeIdentity ?? null };
+  const invoke = async (op) => {
+    if (control.failed) throw new Error("Native task control failed; preserve worker custody.");
+    if (!op || typeof op.kind !== "string") throw new Error("Exact native worker operation required.");
+    if (op.kind === "status" && Object.keys(op).join() === "kind") {
+      let qualified = true;
+      try {
+        qualify();
+      } catch {
+        qualified = false;
+      }
+      return {
+        harness: "claude-desktop",
+        pid: descriptor.pid,
+        identity: descriptor.identity,
+        models: manager.getAvailableCodeModels(),
+        workers: workers.size,
+        codeIdentity: control.codeIdentity,
+        qualified
+      };
+    }
+    qualify();
+    if (op.kind === "frontdoors" && Object.keys(op).join() === "kind") {
+      if (typeof actions.frontdoors !== "function" || !options.frontdoors) throw Error("Installed front-door proof unavailable.");
+      return actions.frontdoors(manager, options.frontdoors, qualify, true, checkpoint);
+    }
+    const fields = op.kind === "create" ? ["kind", "plan", "files"] : op.kind === "send" ? ["kind", "workerId", "assignment"] : ["kind", "workerId", "messageId"];
+    if (!["create", "read", "send", "archive"].includes(op.kind) || Object.keys(op).sort().join() !== fields.sort().join()) throw new Error("Unsupported native worker operation.");
+    if (op.kind === "create") {
+      const p2 = op.plan;
+      if (!p2 || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(p2.workerId) || workers.has(p2.workerId) || p2.cwd !== path.join(descriptor.runtime, "task-workspaces", p2.workerId) || fs.realpathSync(p2.cwd) !== p2.cwd || !op.files || !Object.keys(op.files).length) throw new Error("Exact owned fresh worker context required.");
+      const files = op.files;
+      let outputsMayExist = false;
+      const initial = /* @__PURE__ */ new Map();
+      const identity = (file, directory) => {
+        const st = fs.lstatSync(file);
+        if (st.isSymbolicLink() || (directory ? !st.isDirectory() : !st.isFile()) || fs.realpathSync(file) !== file || st.uid !== process.getuid?.() || st.mode & 18 || !directory && st.nlink !== 1)
+          throw new Error("Selected native worker context ownership or real path changed.");
+        return { dev: st.dev, ino: st.ino, uid: st.uid, gid: st.gid, mode: st.mode, directory };
+      };
+      const remember = (file, directory) => {
+        const now = identity(file, directory), before = initial.get(file);
+        if (before && ["dev", "ino", "uid", "gid", "mode", "directory"].some((k) => now[k] !== before[k]))
+          throw new Error("Selected native worker context ownership or identity changed.");
+        if (!before) initial.set(file, now);
+      };
+      const verify = () => {
+        qualify();
+        remember(p2.cwd, true);
+        if (!outputsMayExist) {
+          const actual = [];
+          const walk = (directory) => {
+            for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+              const item = path.join(directory, entry.name);
+              if (directory === p2.cwd && entry.name === ".topolo-worker") continue;
+              if (entry.isSymbolicLink()) throw new Error("Selected native worker context changed.");
+              if (entry.isDirectory()) walk(item);
+              else actual.push(item);
+            }
+          };
+          walk(p2.cwd);
+          if (actual.sort().join("\n") !== Object.keys(files).sort().join("\n"))
+            throw new Error("Selected native worker context inventory changed.");
+        }
+        for (const [file, hash] of Object.entries(files)) {
+          if (!file.startsWith(p2.cwd + path.sep) || path.normalize(file) !== file || !/^[a-f0-9]{64}$/.test(String(hash)))
+            throw new Error("Selected native worker context changed.");
+          let directory = path.dirname(file);
+          while (directory !== p2.cwd) {
+            remember(directory, true);
+            directory = path.dirname(directory);
+          }
+          remember(file, false);
+          if (crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") !== hash)
+            throw new Error("Selected native worker context changed.");
+        }
+      };
+      verify();
+      workers.set(p2.workerId, { plan: p2, verify, assignment: null, allowOutputs: () => {
+        outputsMayExist = true;
+      } });
+      try {
+        if (await authorize(op) !== true) throw new Error("Cloud worker creation reservation was not verified.");
+      } catch (error) {
+        workers.delete(p2.workerId);
+        throw error;
+      }
+      return actions.create(manager, p2, verify, checkpoint);
+    }
+    const worker = workers.get(op.workerId);
+    if (!worker) throw new Error("This connection does not own the native worker.");
+    const p = worker.plan;
+    if (op.kind === "send") {
+      if (worker.assignment !== null) throw new Error("Task input already reserved; reconcile without resend.");
+      worker.assignment = op.assignment?.messageId;
+      return actions.send(manager, p, op.assignment, () => authorize({ ...op, plan: p }), worker.verify, (row) => {
+        checkpoint(row);
+        if (row.kind === "worker-task-send-attempt") {
+          if (row.workerId !== p.workerId || row.messageId !== worker.assignment || row.nativeId !== p.nativeId)
+            throw new Error("Exact native send boundary checkpoint differs.");
+          worker.allowOutputs();
+        }
+      });
+    }
+    const message = worker.assignment ?? p.workerId;
+    if (op.messageId !== message) throw new Error("Exact currently owned input identity required.");
+    if (op.kind === "archive") {
+      const result2 = await actions.archive(
+        manager,
+        p,
+        message,
+        (result3) => authorize({ ...op, plan: p, terminal: result3 }),
+        worker.verify,
+        checkpoint
+      );
+      workers.delete(p.workerId);
+      return result2;
+    }
+    const result = await actions.read(manager, p, message, worker.verify);
+    const history = await manager.getTranscript(p.nativeId);
+    const at = history.findIndex((r) => r.type === "user" && r.uuid === message);
+    if (at < 0) return { ...result, messages: [], toolItems: 0 };
+    const own = history.slice(at + 1).filter((r) => r.type === "assistant");
+    const messages = own.flatMap((r) => (r.message?.content ?? []).filter((c) => c.type === "text").map((c) => ({ id: r.uuid, text: c.text })));
+    const toolItems = own.reduce((count, r) => count + (r.message?.content ?? []).filter((c) => c.type === "tool_use").length, 0);
+    return { ...result, messages, toolItems };
+  };
+  const server = net.createServer((connection) => {
+    let buffer = "";
+    let dispatched = false;
+    connection.setEncoding("utf8");
+    connection.setTimeout(5e3, () => connection.destroy());
+    connection.on("error", () => connection.destroy());
+    connection.on("data", async (chunk) => {
+      if (dispatched) return;
+      buffer += chunk;
+      if (Buffer.byteLength(buffer) > 262144) {
+        dispatched = true;
+        connection.destroy();
+        return;
+      }
+      if (!buffer.includes("\n")) return;
+      dispatched = true;
+      control.active++;
+      try {
+        const request = JSON.parse(buffer);
+        if (Object.keys(request).sort().join() !== "identity,operation,pid,token" || request.token !== token || request.pid !== descriptor.pid || request.identity !== descriptor.identity)
+          throw new Error("Native task connection authentication differs.");
+        connection.setTimeout(6e4, () => connection.destroy());
+        const result = await invoke(request.operation);
+        const reply = JSON.stringify({ result }) + "\n";
+        if (Buffer.byteLength(reply) > 1048576) throw new Error("Selected native result exceeds bounded transport.");
+        connection.end(reply);
+      } catch (error) {
+        connection.end(JSON.stringify({ error: error instanceof Error ? error.message : "Native task refused." }) + "\n");
+      } finally {
+        control.active--;
+      }
+    });
+  });
+  control.server = server;
+  await new Promise((done, fail) => {
+    server.once("error", fail);
+    server.listen(descriptor.socket, done);
+  });
+  try {
+    fs.chmodSync(descriptor.socket, 384);
+    checkpoint({ kind: "native-desktop-task-control-installed", ...descriptor });
+  } catch (error) {
+    await new Promise((done) => server.close(() => done()));
+    throw error;
+  }
+  manager[key] = control;
+  delete manager[fence];
+  server.on("error", () => {
+    control.failed = true;
+  });
+  return { state: "native-desktop-task-control-installed", ...descriptor, codeIdentity: control.codeIdentity };
+}
+
+// src/lib/claude-desktop-worker.ts
+async function createClaudeTaskSession(manager, plan, check, checkpoint) {
+  check();
+  const uuid = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/;
+  if (!uuid.test(plan.taskId) || !uuid.test(plan.workerId) || plan.nativeId !== "local_" + plan.workerId || !plan.cwd.startsWith("/") || !plan.title || !/^[a-f0-9]{64}$/.test(plan.contextDigest) || !["low", "medium", "high"].includes(plan.effort) || plan.permissionMode !== "bypassPermissions")
+    throw new Error("Exact preallocated task/session identity and context required.");
+  for (const name of ["startSession", "getSession", "getSessionWhenLoaded", "getAvailableCodeModels", "getTranscript"])
+    if (typeof manager[name] !== "function") throw new Error("Native worker capability missing: " + name);
+  if (!manager.getAvailableCodeModels().includes(plan.model)) throw new Error("Requested worker model unavailable.");
+  if (await manager.getSession(plan.nativeId)) throw new Error("Native task identity already exists; reconcile without creation replay.");
+  const trust = manager.workspaceTrustChecks;
+  if (typeof manager.checkWorkspaceTrust !== "function" || typeof manager.saveWorkspaceTrust !== "function" || typeof trust?.invalidateWorkspaceTrust !== "function" || typeof trust?.saveWorkspaceTrust !== "function" || !String(trust.saveWorkspaceTrust).includes("literalKeyOnly") || !String(trust.saveWorkspaceTrust).includes("onlyIf"))
+    throw new Error("Native exact-directory workspace trust capability unavailable.");
+  const methods = [manager.checkWorkspaceTrust, manager.saveWorkspaceTrust, trust.invalidateWorkspaceTrust, trust.saveWorkspaceTrust];
+  const verifyTrust = () => {
+    check();
+    if (manager.workspaceTrustChecks !== trust || methods.some((method, i) => method !== [manager.checkWorkspaceTrust, manager.saveWorkspaceTrust, trust.invalidateWorkspaceTrust, trust.saveWorkspaceTrust][i]))
+      throw new Error("Native workspace trust capability changed.");
+  };
+  verifyTrust();
+  trust.invalidateWorkspaceTrust(plan.cwd);
+  const beforeTrust = await manager.checkWorkspaceTrust(plan.cwd);
+  verifyTrust();
+  if (beforeTrust?.trusted !== true) {
+    checkpoint({
+      kind: "worker-workspace-trust-attempt",
+      nativeId: plan.nativeId,
+      cwd: plan.cwd,
+      contextDigest: plan.contextDigest,
+      literalKeyOnly: true,
+      at: Date.now()
+    });
+    await manager.saveWorkspaceTrust(plan.cwd, {
+      literalKeyOnly: true,
+      keepCliImportScan: true,
+      onlyIf: () => {
+        verifyTrust();
+        return true;
+      }
+    });
+    verifyTrust();
+    trust.invalidateWorkspaceTrust(plan.cwd);
+    if ((await manager.checkWorkspaceTrust(plan.cwd))?.trusted !== true)
+      throw new Error("Native exact-directory workspace trust was not acknowledged.");
+    verifyTrust();
+    checkpoint({
+      kind: "worker-workspace-trust-verified",
+      nativeId: plan.nativeId,
+      cwd: plan.cwd,
+      contextDigest: plan.contextDigest,
+      literalKeyOnly: true,
+      at: Date.now()
+    });
+  }
+  check();
+  checkpoint({ kind: "worker-create-attempt", ...plan, at: Date.now() });
+  const nativeId = await manager.startSession(
+    {
+      sessionId: plan.nativeId,
+      cwd: plan.cwd,
+      title: plan.title,
+      model: plan.model,
+      effort: plan.effort,
+      permissionMode: plan.permissionMode,
+      useWorktree: false,
+      messageUuid: plan.workerId,
+      message: "Installation readiness probe only. Do not use tools, read task files, dispatch work or perform any task. Reply exactly TOPOLO_WORKER_READY:" + plan.workerId
+    },
+    { initiator: "agent" }
+  );
+  if (nativeId !== plan.nativeId) throw new Error("Native worker returned another identity; preserve creation uncertainty.");
+  check();
+  const raw = await manager.getSessionWhenLoaded(nativeId, "topolo-task-startup", { warnOnMiss: false });
+  const dto = await manager.getSession(nativeId);
+  const transcript = await manager.getTranscript(nativeId);
+  check();
+  if (!raw || !dto || raw.sessionId !== nativeId || dto.sessionId !== nativeId || raw.cwd !== plan.cwd || dto.cwd !== plan.cwd || raw.title !== plan.title || dto.title !== plan.title || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.spawnedFrom || raw.worktreePath || raw.worktreeLazy || raw.isArchived || dto.isArchived || raw.pendingToolPermissions?.length || !Array.isArray(transcript) || transcript.some((entry) => entry.type === "user" && entry.uuid !== plan.workerId))
+    throw new Error("Fresh native worker identity, placement or readiness history differs.");
+  if (!raw.query || raw.bypassAvailableAtSpawn !== true || dto.permissionMode !== plan.permissionMode || dto.model !== plan.model || dto.effort !== plan.effort)
+    throw new Error("Actual native worker startup settings were not acknowledged.");
+  const result = {
+    state: "native-worker-readiness-pending",
+    nativeId,
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    model: dto.model,
+    effort: dto.effort,
+    permissionMode: dto.permissionMode,
+    contextDigest: plan.contextDigest,
+    nativeHistoryEntries: transcript.length,
+    readinessProbeSent: true,
+    taskPromptSent: false
+  };
+  checkpoint({ kind: "worker-create-verified", ...result, at: Date.now() });
+  return result;
+}
+async function readClaudeTaskResult(manager, plan, messageId, check) {
+  check();
+  const raw = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-task-result", { warnOnMiss: false });
+  const dto = await manager.getSession(plan.nativeId);
+  const transcript = await manager.getTranscript(plan.nativeId);
+  check();
+  if (!raw || !dto || raw.sessionId !== plan.nativeId || dto.sessionId !== plan.nativeId || raw.cwd !== plan.cwd || dto.cwd !== plan.cwd || dto.title !== plan.title || raw.isArchived || dto.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.spawnedFrom || dto.model !== plan.model || dto.effort !== plan.effort || dto.permissionMode !== plan.permissionMode || raw.bypassAvailableAtSpawn !== true || !Array.isArray(transcript))
+    throw new Error("Native task result identity or startup settings differ.");
+  if (raw.isRunning || raw.pendingCycle || raw.pendingToolPermissions?.length || manager.hasLosableWork(plan.nativeId))
+    return { state: "native-task-pending" };
+  const results = transcript.filter((r) => r.type === "result" && r.user_message_uuid === messageId);
+  if (!raw.cliSessionId) {
+    if (results.length) throw new Error("Native terminal SDK identity is missing; preserve result uncertainty.");
+    if (!raw.query || !transcript.length || transcript.some((r) => r.type === "user" && r.uuid !== messageId))
+      throw new Error("Native SDK startup is not an acknowledged pending input.");
+    return { state: "native-task-pending" };
+  }
+  const completed = transcript.filter((r) => r.type === "command_lifecycle" && r.command_uuid === messageId && r.state === "completed");
+  const users = transcript.filter((r) => r.type === "user" && r.uuid === messageId);
+  const inputs = transcript.filter((r) => r.type === "user" && !(Array.isArray(r.message?.content) && r.message.content.length > 0 && r.message.content.every((c) => c.type === "tool_result" && typeof c.tool_use_id === "string")));
+  if (inputs.length && inputs.at(-1)?.uuid !== messageId)
+    throw new Error("Another input superseded this task receipt; preserve native custody.");
+  if (results.length === 0) {
+    if (!inputs.length && !transcript.some((r) => r.type === "command_lifecycle" && r.command_uuid === messageId && ["queued", "started"].includes(r.state)))
+      throw new Error("Native startup input is not acknowledged.");
+    return { state: "native-task-pending" };
+  }
+  if (inputs.at(-1)?.uuid !== messageId) throw new Error("Native terminal input is missing.");
+  if (results.length !== 1 || completed.length !== 1 || users.length !== 1)
+    throw new Error("Native task terminal evidence is missing or ambiguous.");
+  const terminal = results[0];
+  if (terminal.session_id !== raw.cliSessionId || completed[0].session_id !== raw.cliSessionId || terminal.user_message_uuids?.length !== 1 || terminal.user_message_uuids[0] !== messageId || terminal.terminal_reason !== "completed" || terminal.subtype !== "success" || terminal.is_error !== false || terminal.stop_reason !== "end_turn" || typeof terminal.result !== "string" || !terminal.uuid || terminal.permission_denials?.length || terminal.queued_turn_count !== 0 || terminal.heldQueuedSendUuids?.length || terminal.unreadInputUuids?.length || !terminal.modelUsage || Object.keys(terminal.modelUsage).length !== 1 || terminal.modelUsage[plan.model]?.canonicalModel !== plan.model)
+    throw new Error("Native task terminal receipt does not prove the selected successful turn.");
+  return {
+    state: "native-task-completed",
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId,
+    cliSessionId: raw.cliSessionId,
+    result: terminal.result,
+    resultUuid: terminal.uuid,
+    lifecycleUuid: completed[0].uuid,
+    model: plan.model,
+    effort: plan.effort,
+    contextDigest: plan.contextDigest
+  };
+}
+async function sendClaudeTaskAssignment(manager, plan, assignment, claimDelivery, check, checkpoint) {
+  check();
+  if (!/^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/.test(assignment.messageId) || assignment.messageId === plan.workerId || !assignment.prompt.trim() || assignment.prompt.length > 1e5 || typeof manager.sendMessage !== "function")
+    throw new Error("One bounded task assignment with a distinct exact input identity is required.");
+  const ready = await readClaudeTaskResult(manager, plan, plan.workerId, check);
+  if (ready.state !== "native-task-completed" || ready.result.trim() !== "TOPOLO_WORKER_READY:" + plan.workerId)
+    throw new Error("The exact native readiness probe must complete before task delivery.");
+  const transcript = await manager.getTranscript(plan.nativeId);
+  if (transcript.some((entry) => entry.type === "assistant" && Array.isArray(entry.message?.content) && entry.message.content.some((item) => item.type === "tool_use")))
+    throw new Error("Readiness used tools; preserve this worker for reconciliation.");
+  check();
+  const record = {
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId: assignment.messageId,
+    contextDigest: plan.contextDigest,
+    model: plan.model,
+    effort: plan.effort,
+    prompt: assignment.prompt
+  };
+  if (await claimDelivery(record) !== true)
+    throw new Error("Cloud delivery reservation was not acknowledged; no task was sent.");
+  check();
+  checkpoint({
+    kind: "worker-task-send-attempt",
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId: assignment.messageId,
+    contextDigest: plan.contextDigest,
+    at: Date.now()
+  });
+  await manager.sendMessage(
+    plan.nativeId,
+    assignment.prompt,
+    void 0,
+    { messageUuid: assignment.messageId, initiator: "agent", origin: { kind: "task-notification" } }
+  );
+  check();
+  const events = await manager.getTranscript(plan.nativeId);
+  const inputs = events.filter((entry) => entry.type === "user" && entry.uuid === assignment.messageId);
+  if (inputs.length !== 1)
+    throw new Error("Native delivery is uncertain; reconcile the reserved input without replay.");
+  checkpoint({
+    kind: "worker-task-send-acknowledged",
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId: assignment.messageId,
+    at: Date.now()
+  });
+  return {
+    state: "native-task-input-acknowledged",
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId: assignment.messageId,
+    completionVerified: false
+  };
+}
+async function archiveClaudeTaskSession(manager, plan, messageId, verifyCloudCheckpoint, check, checkpoint) {
+  for (const key of ["archiveSession", "archiveCascadeClosureOf", "ensureArchivedSessionsLoaded"])
+    if (typeof manager[key] !== "function") throw new Error("Native archive capability missing: " + key);
+  const result = await readClaudeTaskResult(manager, plan, messageId, check);
+  if (result.state !== "native-task-completed" || await verifyCloudCheckpoint(result) !== true)
+    throw new Error("A verified cloud checkpoint is required before worker archival.");
+  check();
+  const raw = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-worker-archive", { warnOnMiss: false });
+  if (!raw || raw.isStarred || raw.isRunning || raw.pendingCycle || raw.pendingToolPermissions?.length || manager.hasLosableWork(plan.nativeId) || manager.archiveCascadeClosureOf(raw).length !== 0)
+    throw new Error("Worker archival would affect pinned, active or child work.");
+  checkpoint({ kind: "worker-archive-attempt", ...result, at: Date.now() });
+  check();
+  await manager.archiveSession(plan.nativeId, { isAutomatic: true });
+  await manager.ensureArchivedSessionsLoaded("topolo-worker-archive");
+  const archived = await manager.getSession(plan.nativeId);
+  check();
+  if (!archived || archived.sessionId !== plan.nativeId || archived.cwd !== plan.cwd || archived.title !== plan.title || archived.isArchived !== true)
+    throw new Error("Native worker archival read-back failed; reconcile without replay.");
+  const receipt = {
+    state: "native-worker-archived",
+    taskId: plan.taskId,
+    workerId: plan.workerId,
+    nativeId: plan.nativeId,
+    messageId,
+    resultUuid: result.resultUuid,
+    contextDigest: plan.contextDigest
+  };
+  checkpoint({ kind: "worker-archive-verified", ...receipt, at: Date.now() });
+  return receipt;
+}
+
 // src/lib/claude-pack-backend.ts
+function snapshotClaudeWorkerSource(root, fs, crypto, path, strict = false) {
+  const files = {};
+  const walk = (directory) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      const file = path.join(directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error("Bundled worker source must not follow symlinks.");
+      if (entry.isDirectory()) walk(file);
+      else if (entry.isFile() && entry.name.endsWith(".py")) files[file] = crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+      else if (strict) throw new Error("Immutable worker guards may contain only verified Python source.");
+    }
+  };
+  walk(path.join(root, "topolo_agent_pack"));
+  return files;
+}
+function materializeClaudeWorkerGuard(root, source) {
+  const inventory = snapshotClaudeWorkerSource(source, filesystem, cryptography, paths);
+  if (!Object.keys(inventory).length) throw new Error("Bundled worker guard inventory is empty.");
+  const relative2 = Object.fromEntries(Object.entries(inventory).map(([file, hash]) => [paths.relative(source, file), hash]));
+  const generation = createHash2("sha256").update(JSON.stringify(relative2)).digest("hex");
+  const destination = resolve(root, "claude/guard-runtimes", generation);
+  for (const directory of [resolve(root, "claude"), resolve(root, "claude/guard-runtimes"), destination]) {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    if (lstatSync(directory).isSymbolicLink() || realpathSync(directory) !== directory) throw new Error("Owned immutable guard directory required.");
+  }
+  for (const [file, hash] of Object.entries(relative2)) {
+    const target = resolve(destination, file);
+    mkdirSync(dirname(target), { recursive: true, mode: 448 });
+    if (realpathSync(dirname(target)) !== dirname(target)) throw new Error("Guard namespace must not follow aliases.");
+    if (existsSync(target)) {
+      if (lstatSync(target).isSymbolicLink() || !lstatSync(target).isFile() || createHash2("sha256").update(readFileSync(target)).digest("hex") !== hash) throw new Error("Existing immutable worker guard changed.");
+    } else {
+      const fd = openSync(target, "wx", 384);
+      try {
+        writeFileSync(fd, readFileSync(resolve(source, file)));
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+    }
+  }
+  const expected = Object.fromEntries(Object.entries(relative2).map(([file, hash]) => [resolve(destination, file), hash]));
+  if (JSON.stringify(snapshotClaudeWorkerSource(destination, filesystem, cryptography, paths, true)) !== JSON.stringify(expected)) throw new Error("Immutable worker guard inventory differs.");
+  syncDirectory(destination);
+  return destination;
+}
+function qualifyClaudePython(run = spawnSync) {
+  const result = run("python3", ["-I", "-B", "-c", 'import sys,json;print(json.dumps({"executable":sys.executable,"version":list(sys.version_info[:3])}))'], { encoding: "utf8", timeout: 5e3 });
+  if (result.error || result.status !== 0) throw new Error("Qualified Python interpreter unavailable.");
+  const value = JSON.parse(String(result.stdout));
+  if (!Array.isArray(value.version) || value.version.length !== 3 || value.version.some((v) => !Number.isInteger(v) || v < 0) || value.version[0] !== 3 || value.version[1] < 11 || typeof value.executable !== "string" || !paths.isAbsolute(value.executable))
+    throw new Error("Python 3.11 or later interpreter capability required.");
+  const executable = realpathSync(value.executable), stat = lstatSync(executable);
+  if (!stat.isFile() || stat.isSymbolicLink() || ![0, process.getuid?.()].includes(stat.uid) || stat.mode & 18 || !(stat.mode & 73))
+    throw new Error("Approved owned regular Python executable required.");
+  return { executable, version: value.version, uid: stat.uid, sha256: createHash2("sha256").update(readFileSync(executable)).digest("hex") };
+}
+function nativeClaudeDesktopControlExpression(pid, root, descriptor, secretPath, journal, lifecycle = {}) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const bundled = [resolve(here, "../../agent-packs/src"), resolve(here, "../agent-packs/src")].find(existsSync);
+  if (!bundled) throw new Error("Bundled native cloud authority helper unavailable.");
+  const python = qualifyClaudePython();
+  const source = materializeClaudeWorkerGuard(root, bundled);
+  const inventory = snapshotClaudeWorkerSource(source, filesystem, cryptography, paths, true);
+  const codeIdentity = createHash2("sha256").update(JSON.stringify({
+    inventory,
+    source,
+    root,
+    python,
+    native: [installClaudeDesktopControl, observeClaudeFrontdoors, createClaudeTaskSession, readClaudeTaskResult, sendClaudeTaskAssignment, archiveClaudeTaskSession, discoverClaudeNativeCapabilities, snapshotClaudeWorkerSource].map((fn) => fn.toString())
+  })).digest("hex");
+  return `(async()=>{
+    if(process.pid!==${pid})throw new Error('Desktop process changed.');
+    const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');
+    const fs=load('node:fs'),crypto=load('node:crypto'),path=load('node:path');
+    const caps=(${discoverClaudeNativeCapabilities.toString()})(load,process.resourcesPath);
+    const python=${JSON.stringify(python)};
+    const qualify=()=>{caps.assertCurrent();const current=(${snapshotClaudeWorkerSource.toString()})(${JSON.stringify(source)},fs,crypto,path,true);
+      const interpreter=fs.lstatSync(python.executable);
+      if(!interpreter.isFile()||interpreter.isSymbolicLink()||interpreter.uid!==python.uid||(interpreter.mode&18)||fs.realpathSync(python.executable)!==python.executable||crypto.createHash('sha256').update(fs.readFileSync(python.executable)).digest('hex')!==python.sha256)throw new Error('Qualified Python executable changed.');
+      if(JSON.stringify(current)!==${JSON.stringify(JSON.stringify(inventory))})throw new Error('Bundled worker guard source changed; native upgrade qualification required.');};
+    const stat=fs.lstatSync(${JSON.stringify(secretPath)});
+    if(!stat.isFile()||stat.isSymbolicLink()||stat.uid!==process.getuid()||(stat.mode&63))throw new Error('Unowned native control secret.');
+    const token=JSON.parse(fs.readFileSync(${JSON.stringify(secretPath)},'utf8')).token;
+    const lifecycle=${JSON.stringify({ ...lifecycle, codeIdentity })};
+    if(lifecycle.existing){const previous=fs.lstatSync(lifecycle.existing.secretPath);
+      if(!previous.isFile()||previous.isSymbolicLink()||previous.uid!==process.getuid()||(previous.mode&63))throw new Error('Previous native connection secret changed.');
+      lifecycle.existingToken=JSON.parse(fs.readFileSync(lifecycle.existing.secretPath,'utf8')).token;}
+    const authorize=operation=>new Promise((done,fail)=>{
+      qualify();
+      const script='import sys;assert list(sys.version_info[:3])=='+JSON.stringify(python.version)+';sys.path.insert(0,sys.argv[1]);from topolo_agent_pack.claude_desktop import main;sys.argv=[sys.argv[0],sys.argv[2]];sys.exit(main())';
+      const child=load('node:child_process').spawn(python.executable,['-I','-B','-c',script,${JSON.stringify(source)},${JSON.stringify(root)}],
+        {env:{...process.env,PYTHONDONTWRITEBYTECODE:'1',TOPOLO_AGENT_PACK_PUBLIC_CLI:'1'},stdio:['pipe','pipe','pipe']});
+      let output='',ended=false;
+      const finish=(error,value)=>{if(ended)return;ended=true;clearTimeout(timer);error?fail(error):done(value);};
+      const timer=setTimeout(()=>{child.kill();finish(new Error('Native cloud reservation read timed out; no replay.'));},50000);
+      child.on('error',error=>finish(error));
+      child.stdin.on('error',error=>finish(error));
+      child.stdout.on('data',chunk=>{output+=String(chunk);if(output.length>16384){child.kill();finish(new Error('Native authority response exceeded boundary.'));}});
+      child.stderr.resume();
+      child.on('close',code=>{try{finish(code===0?undefined:new Error('Cloud reservation was not verified.'),code===0&&JSON.parse(output).authorized===true);}catch(error){finish(error);}});
+      child.stdin.end(JSON.stringify(operation));
+    });
+    const checkpoint=row=>{const fd=fs.openSync(${JSON.stringify(journal)},'a',384);try{fs.writeSync(fd,JSON.stringify(row)+'\\n');fs.fsyncSync(fd);}finally{fs.closeSync(fd);}};
+    const readClaudeTaskResult=(${readClaudeTaskResult.toString()});
+    qualify();checkpoint({kind:'native-python-capability-qualified',...python});
+    return (${installClaudeDesktopControl.toString()})(caps.manager,${JSON.stringify(descriptor)},token,
+      {net:load('node:net'),fs,crypto,path},
+      {frontdoors:(${observeClaudeFrontdoors.toString()}),create:(${createClaudeTaskSession.toString()}),read:readClaudeTaskResult,
+       send:(${sendClaudeTaskAssignment.toString()}),archive:(${archiveClaudeTaskSession.toString()})},
+      authorize,qualify,checkpoint,lifecycle);
+  })()`;
+}
+function nativeClaudeSettingsExpression(pid, plan, journal, apply) {
+  if (!Number.isSafeInteger(pid) || pid < 1) throw new Error("Explicit Claude main-process PID required.");
+  const startupPlan = { ...plan, members: plan.members.map((member) => ({
+    ...member,
+    .../\/(intakes|coordinators)\//.test(member.key) ? { pinned: true } : {}
+  })) };
+  return `(async () => {
+    if (process.pid !== ${pid} || typeof process.getBuiltinModule !== 'function') throw new Error('Claude process identity changed.');
+    const load = process.getBuiltinModule('module').createRequire(process.resourcesPath + '/app.asar/package.json');
+    const app = load('electron').app;
+    if (app.getName() !== 'Claude') throw new Error('The supplied process is not Claude Desktop.');
+    const fs = load('node:fs'), crypto = load('node:crypto'), path = load('node:path');
+    // Locate the loaded native eligibility predicate by its preference contract,
+    // not by a generated bundle filename, export alias, version or hash.
+    const gates = [...new Set(Object.values(load.cache ?? {}).filter(entry =>
+      entry.filename?.startsWith(process.resourcesPath + '/app.asar/')).flatMap(entry =>
+      Object.keys(entry.exports ?? {}).flatMap(key => {
+        let value; try {value = entry.exports[key];} catch {return [];}
+        return typeof value === 'function' && value.length === 0 &&
+          String(value).includes('bypassPermissionsGateByAccount') ? [value] : [];
+      })))];
+    const bypassAllowed = () => {
+      if (gates.length !== 1) throw new Error('Native app-level bypass eligibility capability is unavailable or ambiguous.');
+      return gates[0]() === true;
+    };
+    const caps = (${discoverClaudeNativeCapabilities.toString()})(load, process.resourcesPath, bypassAllowed);
+    if (${JSON.stringify(plan.desktopProfile ?? null)}) (${verifyClaudeDesktopProfileNative.toString()})(${JSON.stringify(plan.desktopProfile ?? null)},process.pid,app,caps.manager,process.env);
+    caps.evidence.appVersion = app.getVersion();
+    caps.evidence.methodHashes = Object.fromEntries(caps.evidence.required.map(name =>
+      [name, crypto.createHash('sha256').update(String(caps.manager[name])).digest('hex')]));
+    const plan = ${JSON.stringify(startupPlan)};
+    const sidebar = plan.members.some(member => member.pinned !== undefined) ?
+      (${discoverClaudeSidebar.toString()})(load, process.resourcesPath) : undefined;
+    const snapshotMarkdown = (${snapshotClaudeMarkdown.toString()});
+    const verify = () => {if(plan.desktopProfile){(${verifyClaudeDesktopProfileNative.toString()})(plan.desktopProfile,process.pid,app,caps.manager,process.env);if(!plan.desktopProfileReceipt||crypto.createHash('sha256').update(fs.readFileSync(plan.desktopProfileReceipt.file)).digest('hex')!==plan.desktopProfileReceipt.digest)throw Error('Managed profile receipt changed.');}(${verifyClaudePlanContext.toString()})(plan, plan.members, fs, crypto, path, snapshotMarkdown);};
+    const checkpoint = value => {
+      const fd = fs.openSync(${JSON.stringify(journal)}, 'a', 384);
+      try {fs.writeSync(fd, JSON.stringify(value) + '\\n'); fs.fsyncSync(fd);} finally {fs.closeSync(fd);}
+    };
+    if (${apply} && plan.previousCoordinators?.length)await (${verifyClaudePreviousCoordinatorCustody.toString()})(caps.manager,plan.previousCoordinators,()=>{caps.assertCurrent();verify();});
+    if (${apply} && plan.restartReadiness && !caps.manager[Symbol.for('topolo.agent-pack.coordinator-bootstrap.v1')])await (${adoptClaudeReadinessHistory.toString()})(caps.manager,plan.members,plan.readinessContinuation,plan.operationId,crypto.createHash('sha256').update(JSON.stringify(plan.context)).digest('hex'),plan.restartReadiness.previousPid,process.pid,()=>{caps.assertCurrent();verify();},checkpoint,crypto,(pid,signal)=>process.kill(pid,signal));
+    if (${apply} && plan.readinessContinuation)await (${verifyClaudeReadinessContinuation.toString()})(caps.manager,plan.members,plan.readinessContinuation,plan.operationId,()=>{caps.assertCurrent();verify();});
+    if (${apply})await (${ensureClaudeCoordinators.toString()})(caps.manager,plan.members,plan.operationId,
+      crypto.createHash('sha256').update(JSON.stringify(plan.context)).digest('hex'),
+      {create:(${createClaudeTaskSession.toString()}),read:(${readClaudeTaskResult.toString()})},
+      ()=>{caps.assertCurrent();verify();if(plan.members.some(m=>m.permissionMode==='bypassPermissions')&&!bypassAllowed())throw new Error('Native bypass eligibility changed.');},checkpoint,Date.now()+45000,plan.readinessContinuation,plan.readinessAcknowledged);
+    const result = await (${applyClaudeNativeSettings.toString()})(caps, plan.members, plan.operationId,
+      Date.now() + 45000, checkpoint, verify, ${apply}, sidebar);
+    if (${apply} && result.state === 'native-settings-verified') {
+      result.frontdoorSessions = [];
+      for (const member of plan.members) {
+        const raw = await caps.manager.getSessionWhenLoaded(member.sessionId, 'topolo-frontdoor-hook-binding', {warnOnMiss:false});
+        if (!raw?.query || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(raw.cliSessionId ?? '') || raw.cwd !== member.cwd)
+          throw new Error('Actual coordinator SDK session binding is unavailable; preserve startup custody.');
+        result.frontdoorSessions.push({key:member.key,sessionId:raw.cliSessionId,cwd:raw.cwd});
+      }
+    }
+    return result;
+  })()`;
+}
 var CLAUDE_NATIVE_QUALIFIER = {
   version: "2.37337.1",
   manager: "index.chunk-BolytlRP.js",
@@ -1190,7 +2111,7 @@ function snapshotClaudeMarkdown(root, fs, crypto, path) {
   visit(root);
   return inventory;
 }
-function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
+function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure", nativeAdoption = false) {
   if (!/^[a-z0-9][a-z0-9-]*$/.test(pack)) throw new Error("Invalid pack name.");
   const root = realpathSync(store);
   const state = JSON.parse(readFileSync(resolve(root, "claude/state.json"), "utf8"));
@@ -1209,7 +2130,7 @@ function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
   };
   for (const record of records) {
     const matches = policy.agents.filter((a) => a.key === record.key && a.title === record.title);
-    if (matches.length !== 1 || record.sourceRevision !== policy.sourceRevision || record.importState !== "desktop-adopted")
+    if (matches.length !== 1 || record.sourceRevision !== policy.sourceRevision || record.importState !== "desktop-adopted" && !(nativeAdoption && record.importState === "prepared"))
       throw new Error("Reviewed policy does not match adopted role: " + record.key);
     const role = matches[0];
     const settings = role.harnesses.claude.nativeSettings;
@@ -1217,10 +2138,13 @@ function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
     if (!cwd.startsWith(resolve(root, "claude/workspaces", pack) + sep)) throw new Error("Role workspace is outside the owned pack.");
     captureMarkdown(cwd);
     const charter = resolve(cwd, "CLAUDE.md");
-    const transcript = realpathSync(record.transcript);
     context[charter] = createHash2("sha256").update(readFileSync(charter)).digest("hex");
-    context[transcript] = createHash2("sha256").update(readFileSync(transcript)).digest("hex");
-    roleContextFiles[record.desktopSessionId] = [charter, transcript];
+    roleContextFiles[record.desktopSessionId] = [charter];
+    if (!nativeAdoption || record.importState !== "prepared") {
+      const transcript = realpathSync(record.transcript);
+      context[transcript] = createHash2("sha256").update(readFileSync(transcript)).digest("hex");
+      roleContextFiles[record.desktopSessionId].push(transcript);
+    }
     members.push({
       key: record.key,
       sessionId: record.desktopSessionId,
@@ -1461,9 +2385,10 @@ function evaluateClaudeMain(endpoint, expression, socketFactory = (url) => new W
     socket.addEventListener("close", () => finish(new Error("Claude backend disconnected; reconcile the journal.")));
   });
 }
-async function lockClaudeLibrary(root) {
+async function lockClaudeLibrary(root, stoppedClaudeService = false) {
   const script = 'import os,sys,fcntl\nf=os.open(sys.argv[1],os.O_RDWR|os.O_CREAT|os.O_NOFOLLOW,0o600)\nfcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB)\nprint("locked",flush=True)\nsys.stdin.buffer.read()\nos.close(f)';
-  const child = spawn("python3", ["-c", script, resolve(root, ".lock")], { stdio: ["pipe", "pipe", "pipe"] });
+  const serviceScript = 'import os,sys,fcntl\nfiles=[]\nfor name in sys.argv[1:]:\n f=os.open(name,os.O_RDWR|os.O_CREAT|os.O_NOFOLLOW,0o600)\n fcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB)\n files.append(f)\nprint("locked",flush=True)\nsys.stdin.buffer.read()\nfor f in files: os.close(f)';
+  const child = spawn("python3", ["-c", stoppedClaudeService ? serviceScript : script, resolve(root, ".lock"), ...stoppedClaudeService ? [resolve(root, "work/claude-service-start.lock"), resolve(root, "work/claude-service-owner.lock")] : []], { stdio: ["pipe", "pipe", "pipe"] });
   await new Promise((done, fail) => {
     let ready = false;
     const timer = setTimeout(() => {
@@ -1535,11 +2460,15 @@ function verifyClaudeOrganizationPolicy(root, pack, consent, run = spawnSync, lo
   return proof;
 }
 async function configureClaudePack(options, evaluate = evaluateClaudeMain, qualify = verifyClaudeOrganizationPolicy) {
+  if (!options.legacy && (!options.mode || options.mode === "configure"))
+    return configureClaudeStartup(options, evaluate, qualify);
   validateInspectorEndpoint(options.endpoint);
   const root = realpathSync(options.store);
   if (lstatSync(resolve(root, "claude")).isSymbolicLink()) throw new Error("Claude library must not be a symlink.");
   const release = await lockClaudeLibrary(root);
   try {
+    if (existsSync(resolve(root, "claude/startup-operation.json")))
+      throw new Error("Unresolved native startup operation requires its own readback reconciliation.");
     const markerPath = resolve(root, "claude/native-operation.json");
     const recovering = options.mode === "recover";
     if (recovering && options.apply) throw new Error("Recovery is read-only; --apply is not permitted.");
@@ -1738,6 +2667,692 @@ async function configureClaudePack(options, evaluate = evaluateClaudeMain, quali
     await release();
   }
 }
+function materializeClaudeHookAdapter(root, adapter) {
+  const source = resolve(dirname(adapter), "src"), inventory = snapshotClaudeWorkerSource(source, filesystem, cryptography, paths);
+  const bytes = { "topolo-agent-pack": readFileSync(adapter) };
+  for (const file of Object.keys(inventory)) bytes["src/" + paths.relative(source, file)] = readFileSync(file);
+  const hashes = Object.fromEntries(Object.entries(bytes).map(([name, data]) => [name, createHash2("sha256").update(data).digest("hex")]));
+  const digest = createHash2("sha256").update(JSON.stringify(hashes)).digest("hex"), destination = resolve(root, "claude/hook-runtimes", digest);
+  for (const directory of [resolve(root, "claude"), resolve(root, "claude/hook-runtimes"), destination]) {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    const st = lstatSync(directory);
+    if (st.isSymbolicLink() || !st.isDirectory() || st.uid !== process.getuid?.() || st.mode & 63 || realpathSync(directory) !== directory) throw Error("Private owned hook runtime required.");
+  }
+  const expected = {};
+  for (const [name, data] of Object.entries(bytes)) {
+    const target = resolve(destination, name);
+    mkdirSync(dirname(target), { recursive: true, mode: 448 });
+    if (realpathSync(dirname(target)) !== dirname(target)) throw Error("Hook runtime namespace follows an alias.");
+    if (existsSync(target)) {
+      const st = lstatSync(target);
+      if (!st.isFile() || st.isSymbolicLink() || st.uid !== process.getuid?.() || st.mode & 18 || createHash2("sha256").update(readFileSync(target)).digest("hex") !== hashes[name]) throw Error("Immutable hook adapter changed.");
+    } else {
+      const fd = openSync(target, "wx", 384);
+      try {
+        writeFileSync(fd, data);
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+    }
+    expected[target] = hashes[name];
+  }
+  syncDirectory(destination);
+  return { adapter: resolve(destination, "topolo-agent-pack"), source: resolve(destination, "src"), files: expected, digest };
+}
+function bindClaudeFrontdoorHooks(root, pid, roles, input, launch = spawnSync, nativeConnection, reuseInput = false) {
+  if (!Array.isArray(roles) || roles.length !== 3) throw new Error("The native three-coordinator SDK bindings are unavailable.");
+  const here = dirname(fileURLToPath(import.meta.url));
+  const adapter = [resolve(here, "../agent-packs/topolo-agent-pack"), resolve(here, "../../agent-packs/topolo-agent-pack")].find(existsSync);
+  if (!adapter) throw new Error("Installed bundled pack adapter unavailable.");
+  if (!nativeConnection) throw new Error("The signed-in Desktop task control must be installed before front-door hooks.");
+  const payload = { desktopPid: pid, roles, nativeConnection };
+  if (reuseInput) {
+    const info = lstatSync(input);
+    if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.() || info.mode & 63 || JSON.stringify(JSON.parse(readFileSync(input, "utf8"))) !== JSON.stringify(payload)) throw Error("Original front-door attempt differs; preserve late startup custody.");
+  } else durableRecord(input, payload, "wx");
+  const frozen = materializeClaudeHookAdapter(root, adapter), python = qualifyClaudePython(), owned = lstatSync(root);
+  const before = { dev: owned.dev, ino: owned.ino, uid: owned.uid }, inputDigest = createHash2("sha256").update(readFileSync(input)).digest("hex");
+  const script = `import sys,json,pathlib,hashlib,os,stat
+p=json.loads(sys.stdin.read(1048577))
+def verify():
+ assert sys.version_info[:3]==tuple(p['python']['version']), 'Qualified hook interpreter changed'
+ assert hashlib.sha256(pathlib.Path(sys.executable).read_bytes()).hexdigest()==p['python']['sha256'], 'Hook interpreter bytes changed'
+ root=pathlib.Path(p['root']);s=root.stat()
+ assert root.resolve()==root and {'dev':s.st_dev,'ino':s.st_ino,'uid':s.st_uid}==p['rootIdentity'], 'Hook installation root changed'
+ for name,digest in p['files'].items():
+  file=pathlib.Path(name);st=file.lstat()
+  assert stat.S_ISREG(st.st_mode) and file.resolve()==file and st.st_uid==os.getuid() and not st.st_mode&0o022 and hashlib.sha256(file.read_bytes()).hexdigest()==digest, 'Frozen hook source changed'
+ file=pathlib.Path(p['input']);st=file.lstat()
+ assert stat.S_ISREG(st.st_mode) and file.resolve()==file and st.st_uid==os.getuid() and not st.st_mode&0o077 and hashlib.sha256(file.read_bytes()).hexdigest()==p['inputDigest'], 'Original hook input changed'
+try:
+ verify();sys.path.insert(0,p['source'])
+ from topolo_agent_pack.claude_service import install
+ result=install(p['root'],json.loads(pathlib.Path(p['input']).read_text()))
+ verify();print(json.dumps(result))
+except Exception as error:
+ print('topolo-agent-pack: '+str(error),file=sys.stderr);raise SystemExit(2)
+`;
+  const bound = launch(
+    python.executable,
+    ["-I", "-B", "-c", script],
+    { encoding: "utf8", input: JSON.stringify({ root, input, inputDigest, source: frozen.source, files: frozen.files, rootIdentity: before, python }), env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1" }, timeout: 6e5, maxBuffer: 1048576 }
+  );
+  const current = lstatSync(root);
+  if (current.dev !== before.dev || current.ino !== before.ino || current.uid !== before.uid || realpathSync(root) !== root) throw Error("Hook installation root identity changed.");
+  for (const [file, hash] of Object.entries(frozen.files)) if (createHash2("sha256").update(readFileSync(file)).digest("hex") !== hash) throw Error("Frozen hook source changed during installation.");
+  if (bound.error || bound.status !== 0) {
+    const diagnostic = input + ".failure-" + randomUUID() + ".json", errorCode = bound.error?.code ?? null;
+    const publicError = String(bound.stderr ?? "").split("\n").find((line) => /^topolo-agent-pack: [^\r\n]{1,1000}$/.test(line));
+    durableRecord(diagnostic, { kind: "frontdoor-hook-installation-refused", status: bound.status, signal: bound.signal, errorCode, stderrSHA256: createHash2("sha256").update(String(bound.stderr ?? "")).digest("hex"), ...publicError ? { publicError: publicError.replace(/(?:Bearer\s+|sk-|pk_|token[=:])[A-Za-z0-9._-]+/gi, "[redacted]") } : {} }, "wx");
+    throw new Error("Claude front-door hook installation failed (" + (errorCode ?? bound.status) + "); preserve startup custody. Diagnostic: " + diagnostic);
+  }
+  const binding = JSON.parse(String(bound.stdout));
+  if (binding.state !== "claude-frontdoors-prepared" || binding.coordinators !== 3 || binding.cloudDispatchVerified !== false)
+    throw new Error("Claude front-door preparation readback differs.");
+  return binding;
+}
+function readClaudeTaskConnection(file, pid, allowDead = false) {
+  const target = realpathSync(file), parent = dirname(target), stat = lstatSync(file);
+  if (target !== resolve(file) || paths.basename(parent) !== "claude" || !["desktop-task-connection.json", "desktop-task-connection-prepared.json"].includes(paths.basename(file)) || !stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 63) throw new Error("Owned native connection descriptor required.");
+  const root = dirname(parent), value = JSON.parse(readFileSync(file, "utf8"));
+  if (Object.keys(value).sort().join() !== "identity,pid,runtime,secretPath,socket" || !Number.isSafeInteger(value.pid) || value.pid < 2 || value.runtime !== resolve(root, "claude/task-runtime") || !/^[a-f0-9]{64}$/.test(value.identity) || !paths.isAbsolute(value.socket) || !value.secretPath.startsWith(resolve(root, "claude/journals") + sep))
+    throw new Error("Previous native connection identity differs.");
+  if (value.pid !== pid) {
+    if (!allowDead) throw new Error("Previous native connection identity differs.");
+    try {
+      process.kill(value.pid, 0);
+      throw new Error("Previous native Desktop is alive; preserve its connection.");
+    } catch (error) {
+      if (error.code !== "ESRCH") throw new Error("Previous native Desktop absence is unverified.");
+    }
+  }
+  const secret = lstatSync(value.secretPath);
+  if (!secret.isFile() || secret.isSymbolicLink() || realpathSync(value.secretPath) !== value.secretPath || secret.uid !== process.getuid?.() || secret.mode & 63 || !/^[a-f0-9]{64}$/.test(JSON.parse(readFileSync(value.secretPath, "utf8")).token)) throw new Error("Owned native connection secret required.");
+  return value;
+}
+function claudeTaskConnectionCoordinators(connection) {
+  const root = dirname(dirname(connection.runtime)), bindingPath = resolve(root, "work/claude-frontdoors.json");
+  const read = (file) => {
+    const st = lstatSync(file);
+    if (!st.isFile() || st.isSymbolicLink() || st.uid !== process.getuid?.() || st.mode & 63 || realpathSync(file) !== file) throw new Error("Owned previous coordinator metadata required.");
+    return JSON.parse(readFileSync(file, "utf8"));
+  };
+  if (!existsSync(bindingPath)) return [];
+  const binding = read(bindingPath);
+  if (Object.keys(connection).some((key) => binding.nativeConnection?.[key] !== connection[key]) || !Array.isArray(binding.roles) || binding.roles.length !== 3)
+    throw new Error("Previous coordinator connection binding differs.");
+  const state = read(resolve(root, "claude/state.json"));
+  if (state.harness !== "claude" || !Array.isArray(state.agents)) throw new Error("Previous native coordinator identities are unavailable.");
+  return binding.roles.map((role) => {
+    const records = state.agents.filter((row) => row.cliSessionId === role.sessionId && row.workspace === role.cwd);
+    if (records.length !== 1 || typeof records[0].desktopSessionId !== "string") throw new Error("Previous coordinator has no exact native identity.");
+    return { sessionId: records[0].desktopSessionId, cwd: role.cwd };
+  });
+}
+function readClaudePreviousCoordinatorLibrary(library, currentRoot) {
+  const root = realpathSync(library);
+  if (root !== resolve(library) || root === currentRoot || paths.basename(root) !== "library") throw new Error("Distinct exact previous Claude library required.");
+  const statePath = resolve(root, "claude/state.json"), proofPath = resolve(root, "../coordinator-adoption.json");
+  const context = {};
+  const read = (file) => {
+    const st = lstatSync(file);
+    if (!st.isFile() || st.isSymbolicLink() || st.uid !== process.getuid?.() || st.mode & 63 || st.size > 1048576 || realpathSync(file) !== file) throw new Error("Private bounded previous coordinator proof required.");
+    const bytes = readFileSync(file);
+    context[file] = createHash2("sha256").update(bytes).digest("hex");
+    return JSON.parse(bytes.toString());
+  };
+  const state = read(statePath), adoption = read(proofPath);
+  if (state.harness !== "claude" || !Array.isArray(state.agents) || state.agents.length !== 3 || !Array.isArray(adoption.proof) || adoption.proof.length !== 3)
+    throw new Error("Exactly three original coordinator adoption records required.");
+  const expected = ["engineering", "operator-01", "cicd"];
+  const members = state.agents.map((row) => {
+    const role = row.key?.match(/\/(?:intakes|coordinators)\/(engineering|operator-01|cicd)$/)?.[1];
+    const proof = adoption.proof.filter((p) => p.key === row.key && p.desktopSessionId === row.desktopSessionId && p.verified === true);
+    if (!expected.includes(role) || proof.length !== 1 || !/^local_[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(row.desktopSessionId ?? "") || row.cliSessionId !== row.desktopSessionId.slice(6) || !row.workspace?.startsWith(resolve(root, "claude/workspaces") + sep) || realpathSync(row.workspace) !== row.workspace)
+      throw new Error("Previous coordinator adoption identity or placement differs.");
+    return { sessionId: row.desktopSessionId, cwd: row.workspace, role };
+  });
+  if (new Set(members.map((m) => m.sessionId)).size !== 3 || new Set(members.map((m) => m.role)).size !== 3)
+    throw new Error("Previous coordinator roster is not unique.");
+  return { members: members.map(({ sessionId, cwd }) => ({ sessionId, cwd })), context };
+}
+async function verifyClaudePreviousCoordinatorCustody(manager, members, check) {
+  if (members.length !== 3 || typeof manager.archiveCascadeClosureOf !== "function") throw new Error("Exact previous coordinator custody capability required.");
+  for (const member of members) {
+    check();
+    const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-previous-coordinator-preflight", { warnOnMiss: false });
+    check();
+    const dto = await manager.getSession(member.sessionId);
+    check();
+    if (!raw || !dto || [raw, dto].some((row) => row.sessionId !== member.sessionId || row.cwd !== member.cwd || row.isArchived || row.isRunning || row.starting || row.pendingCycle || row.pendingToolPermissions?.length) || manager.hasLosableWork(member.sessionId) || manager.archiveCascadeClosureOf(raw).length !== 0)
+      throw new Error("Previous coordinator retains active, changed or child custody.");
+  }
+}
+async function retireClaudeCoordinators(manager, sidebar, previous, successors, descriptor, checkpoint, check) {
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.desktop-task-control.v1"), fence = /* @__PURE__ */ Symbol.for("topolo.agent-pack.desktop-coordinator-transfer.v1");
+  if (manager[fence]) throw new Error("Unresolved coordinator transfer; reconcile without replay.");
+  const control = manager[key];
+  const verify = () => {
+    check();
+    if (manager[key] !== control || control.active !== 0 || control.failed) throw new Error("Successor control ownership changed during retirement.");
+  };
+  if (!control || Object.keys(descriptor).some((key2) => control.descriptor?.[key2] !== descriptor[key2]) || control.active !== 0 || control.failed)
+    throw new Error("Successor native control is not the acknowledged idle owner.");
+  for (const name of ["archiveSession", "archiveCascadeClosureOf", "ensureArchivedSessionsLoaded"])
+    if (typeof manager[name] !== "function") throw new Error("Native coordinator retirement capability unavailable.");
+  if (previous.length !== 3 || successors.length !== 3 || new Set([...previous, ...successors].map((row) => row.sessionId)).size !== 6)
+    throw new Error("Exact disjoint previous and successor coordinator rosters required.");
+  const idle = async (member, successor = false) => {
+    verify();
+    const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-coordinator-transfer", { warnOnMiss: false });
+    const dto = await manager.getSession(member.sessionId);
+    for (const row of [raw, dto]) if (!row || row.sessionId !== member.sessionId || row.cwd !== member.cwd || row.isArchived || row.isRunning || row.starting || row.pendingCycle || row.pendingToolPermissions?.length)
+      throw new Error("Coordinator custody changed or has active work.");
+    if (manager.hasLosableWork(member.sessionId) || manager.archiveCascadeClosureOf(raw).length !== 0)
+      throw new Error("Coordinator retirement could affect losable or child work.");
+    if (successor && (dto.model !== member.model || dto.effort !== member.effort || dto.permissionMode !== member.permissionMode || dto.permissionMode === "bypassPermissions" && raw.bypassAvailableAtSpawn !== true))
+      throw new Error("Successor effective settings changed before retirement.");
+    return raw;
+  };
+  for (const row of successors) await idle(row, true);
+  for (const row of previous) await idle(row);
+  manager[fence] = { descriptor, previous, successors };
+  const retired = [];
+  for (const row of previous) {
+    for (const member of successors) await idle(member, true);
+    await idle(row);
+    checkpoint({ kind: "coordinator-unpin-attempt", sessionId: row.sessionId });
+    const result = await sidebar({ kind: "set_pinned", sessionId: row.sessionId, pinned: false });
+    if (result?.ok !== true) throw new Error("Previous coordinator native unpin was not acknowledged.");
+    checkpoint({ kind: "coordinator-unpin-acknowledged", sessionId: row.sessionId });
+    await idle(row);
+    checkpoint({ kind: "coordinator-archive-attempt", sessionId: row.sessionId });
+    verify();
+    await manager.archiveSession(row.sessionId, { isAutomatic: true });
+    await manager.ensureArchivedSessionsLoaded("topolo-coordinator-transfer");
+    const actual = await manager.getSession(row.sessionId);
+    verify();
+    if (!actual || actual.sessionId !== row.sessionId || actual.cwd !== row.cwd || actual.isArchived !== true)
+      throw new Error("Previous coordinator archive readback failed; reconcile without replay.");
+    checkpoint({ kind: "coordinator-archive-verified", sessionId: row.sessionId });
+    retired.push(row.sessionId);
+  }
+  delete manager[fence];
+  return { state: "previous-coordinators-retired", retired };
+}
+function nativeClaudeCoordinatorRetirementExpression(pid, previous, successors, descriptor, journal) {
+  return `(async()=>{if(process.pid!==${pid})throw new Error('Desktop process changed.');
+ const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');
+ const fs=load('node:fs'),caps=(${discoverClaudeNativeCapabilities.toString()})(load,process.resourcesPath);
+ const sidebar=(${discoverClaudeSidebar.toString()})(load,process.resourcesPath);
+ const checkpoint=row=>{const fd=fs.openSync(${JSON.stringify(journal)},'a',384);try{fs.writeSync(fd,JSON.stringify(row)+'\\n');fs.fsyncSync(fd);}finally{fs.closeSync(fd);}};
+ return (${retireClaudeCoordinators.toString()})(caps.manager,sidebar,${JSON.stringify(previous)},${JSON.stringify(successors)},${JSON.stringify(descriptor)},checkpoint,caps.assertCurrent);})()`;
+}
+async function ensureClaudeCoordinators(manager, members, operationId, contextDigest, actions, check, checkpoint, deadline, continuation, acknowledged) {
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.coordinator-bootstrap.v1");
+  const records = manager[key] ?? (manager[key] = /* @__PURE__ */ new Map());
+  for (const member of members) {
+    check();
+    const resume = continuation?.includes(member.sessionId) === true, record = records.get(member.sessionId);
+    if (record?.state === "attempted" && !resume) throw new Error("Unresolved coordinator creation; reconcile without replay.");
+    const existing = await manager.getSession(member.sessionId);
+    if (existing && !resume) continue;
+    if (resume && (!existing || record?.operationId !== operationId || !["attempted", "verified", "restart-adopted"].includes(record.state))) throw new Error("Readiness continuation no longer owns the existing probe.");
+    if (member.permissionMode !== "bypassPermissions" || !member.permissionConsent) throw new Error("Fresh coordinator bootstrap requires approved full access.");
+    const workerId = member.sessionId.replace(/^local_/, "");
+    const plan = {
+      taskId: operationId,
+      workerId,
+      nativeId: member.sessionId,
+      cwd: member.cwd,
+      title: member.title,
+      model: member.model,
+      effort: member.effort,
+      permissionMode: member.permissionMode,
+      contextDigest
+    };
+    if (Date.now() >= deadline) throw new Error("Coordinator bootstrap deadline expired before creation.");
+    if (!resume) {
+      records.set(member.sessionId, { state: "attempted", operationId });
+      await actions.create(manager, plan, check, checkpoint);
+    }
+    if (resume && (record?.state === "restart-adopted" || record?.historyAdopted === true)) {
+      check();
+      let raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-readiness-restart-warm", { warnOnMiss: false });
+      if (!raw?.query) {
+        checkpoint({ kind: "coordinator-readiness-warm-attempt", sessionId: member.sessionId, operationId, originalTerminalUnknown: true });
+        await manager.warmSession(member.sessionId, { connectOnly: true });
+      }
+      check();
+      raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-readiness-restart-warm", { warnOnMiss: false });
+      const dto = await manager.getSession(member.sessionId);
+      const history = await manager.getTranscript(member.sessionId);
+      check();
+      if (!raw?.query || raw.cliSessionId !== record.cliSessionId || raw.bypassAvailableAtSpawn !== true || raw.isRunning || raw.pendingCycle || manager.hasLosableWork(member.sessionId) || !dto || ["model", "effort", "permissionMode"].some((k) => dto[k] !== member[k]) || history.filter((r) => r.type === "user").length !== 1 || history.some((r) => r.type === "assistant" && r.message?.content?.some((c) => c.type === "tool_use"))) throw Error("Restarted readiness query was not acknowledged without new work.");
+      if (!acknowledged?.includes(member.sessionId)) checkpoint({ kind: "coordinator-bootstrap-history-ready", sessionId: member.sessionId, operationId, originalTerminalUnknown: true, nativeInputsReplayed: false });
+      records.set(member.sessionId, { ...record, state: "verified" });
+      continue;
+    }
+    for (; ; ) {
+      check();
+      const result = await actions.read(manager, plan, workerId, check);
+      if (result.state === "native-task-completed") {
+        if (result.result.trim() !== "TOPOLO_WORKER_READY:" + workerId) throw new Error("Coordinator readiness did not match its native input.");
+        const history = await manager.getTranscript(member.sessionId);
+        if (resume) {
+          const users = history.filter((row) => row.type === "user"), content = users[0]?.message?.content;
+          const text = typeof content === "string" ? content : Array.isArray(content) && content.every((item) => item.type === "text") ? content.map((item) => item.text).join("") : null;
+          if (users.length !== 1 || users[0].uuid !== workerId || text !== "Installation readiness probe only. Do not use tools, read task files, dispatch work or perform any task. Reply exactly TOPOLO_WORKER_READY:" + workerId)
+            throw new Error("Original native readiness input differs; no continuation.");
+        }
+        if (history.some((row) => row.type === "assistant" && row.message?.content?.some((item) => item.type === "tool_use")))
+          throw new Error("Coordinator bootstrap used tools; preserve creation uncertainty.");
+        if (!acknowledged?.includes(member.sessionId)) checkpoint({ kind: "coordinator-bootstrap-verified", sessionId: member.sessionId });
+        records.set(member.sessionId, { state: "verified", operationId });
+        break;
+      }
+      if (Date.now() >= deadline) throw new Error("Native coordinator readiness is pending; reconcile without replay.");
+      await new Promise((done) => setTimeout(done, 100));
+    }
+  }
+  return { state: "coordinators-native-ready" };
+}
+function prepareClaudeStartup(root, pack, policy, run = spawnSync) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const source = [resolve(here, "../../agent-packs/src"), resolve(here, "../agent-packs/src")].find(existsSync);
+  if (!source) throw new Error("Bundled startup preparation adapter unavailable.");
+  const script = `import sys,json,io,contextlib
+sys.path.insert(0,sys.argv[4])
+from topolo_agent_pack import cli,permissions,topolo
+from topolo_agent_pack.storage import Library,PackError,read_json
+from topolo_agent_pack.role_context import materialize
+from pathlib import Path
+root,pack,output=sys.argv[1:4]
+lib=Library(root);manifest,revision=lib.load(pack)
+consent=permissions.load(lib,pack,manifest['agents'])
+if not consent or consent.get('sourceRevision')!=revision:raise PackError('Current approved installation consent source revision required')
+remote,proof=topolo.organization_execution_policy(topolo.Client(consent['environment'],consent['contextKey']),consent,manifest['agents'],consent.get('agentWorkspaceId'))
+permissions.authorize_native_scope(proof)
+with contextlib.redirect_stdout(io.StringIO()):
+ if cli.main(['--store',root,'add',pack,'--harness','claude','--group','intakes','--no-open'])!=0:raise PackError('Coordinator preparation refused')
+ records=[row for row in read_json(Path(root)/'claude/state.json')['agents'] if row['pack']==pack and row['set']=='intakes']
+ if len(records)!=3:raise PackError('Exactly three prepared coordinator records required')
+ for row in records:materialize(Path(root)/'work',row['key'],Path(row['workspace']),harness='claude')
+ if cli.main(['--store',root,'policy',pack,'--harness','claude','--set','intakes','--verify-organization','--output',output])!=0:raise PackError('Fresh startup policy refused')
+print(json.dumps({'state':'claude-startup-prepared','policy':output,'nativeEffects':False}))`;
+  const result = run("python3", ["-I", "-B", "-c", script, root, pack, policy, source], {
+    encoding: "utf8",
+    timeout: 18e4,
+    maxBuffer: 1048576,
+    env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1", TOPOLO_AGENT_PACK_PUBLIC_CLI: "1" }
+  });
+  if (result.error || result.status !== 0) throw new Error("Storage-only Claude startup preparation refused; inspect owned consent and preparation files. No native login/resume was used.");
+  let value;
+  try {
+    value = JSON.parse(String(result.stdout));
+  } catch {
+    throw new Error("Startup preparation acknowledgement is invalid.");
+  }
+  if (value.state !== "claude-startup-prepared" || value.policy !== policy || value.nativeEffects !== false) throw new Error("Startup preparation acknowledgement differs.");
+  return value;
+}
+async function reconcileClaudeStartupAbsence(manager, plan, attempt, check, checkpoint) {
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.coordinator-bootstrap.v1"), records = manager[key];
+  const starts = manager.inFlightStarts;
+  if (!(records instanceof Map) || !starts || ["hasStartInFlight", "hasStartAbortController", "hasDeferredTeardown", "pendingStartModel"].some((k) => typeof starts[k] !== "function") || !(manager.pendingPopSpawnsInFlight instanceof Map) || !(manager.sideSessionStartsInFlight instanceof Map))
+    throw new Error("Native startup absence capabilities unavailable.");
+  const tracked = ["hasStartInFlight", "hasStartAbortController", "hasDeferredTeardown", "pendingStartModel"];
+  const startMethods = tracked.map((name) => starts[name]), transcriptMethod = manager.getTranscript;
+  const pops = manager.pendingPopSpawnsInFlight, sides = manager.sideSessionStartsInFlight;
+  const pending = () => {
+    check();
+    if (manager[key] !== records || manager.inFlightStarts !== starts || manager.getTranscript !== transcriptMethod || tracked.some((name, i) => starts[name] !== startMethods[i]) || manager.pendingPopSpawnsInFlight !== pops || manager.sideSessionStartsInFlight !== sides || manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.native-operation.v1")]) throw new Error("Native startup custody changed.");
+    for (const member of plan.members) {
+      const row = records.get(member.sessionId);
+      if (member.sessionId === attempt.nativeId) {
+        if (!row || Object.keys(row).sort().join() !== "operationId,state" || row.operationId !== plan.operationId || !["attempted", "reconciled-absent"].includes(row.state)) throw new Error("Original coordinator creation reservation differs.");
+      } else if (row) throw new Error("Another coordinator creation was attempted.");
+      if (starts.hasStartInFlight(member.sessionId) || starts.hasStartAbortController(member.sessionId) || starts.hasDeferredTeardown(member.sessionId) || starts.pendingStartModel(member.sessionId) !== void 0 || manager.pendingPopSpawnsInFlight.has(member.sessionId) || manager.sideSessionStartsInFlight.has(member.sessionId) || manager.hasLosableWork(member.sessionId))
+        throw new Error("Native coordinator startup remains pending.");
+    }
+  };
+  pending();
+  for (const member of plan.members) {
+    const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-readiness-absence-reconciliation", { warnOnMiss: false });
+    pending();
+    const dto = await manager.getSession(member.sessionId);
+    pending();
+    const history = await manager.getTranscript(member.sessionId);
+    pending();
+    if (raw || dto || !Array.isArray(history) || history.length) throw new Error("Native coordinator exists or retains history; no creation replay.");
+  }
+  pending();
+  const receipt = {
+    kind: "startup-creation-absence-verified",
+    operationId: plan.operationId,
+    sessionIds: plan.members.map((m) => m.sessionId),
+    attemptedNativeId: attempt.nativeId,
+    nativeSessionsAbsent: true,
+    nativeInputsReplayed: false,
+    preservedUnknown: true
+  };
+  checkpoint(receipt);
+  records.set(attempt.nativeId, { state: "reconciled-absent", operationId: plan.operationId });
+  return receipt;
+}
+async function recoverClaudeStartup(options, evaluate = evaluateClaudeMain) {
+  validateInspectorEndpoint(options.endpoint);
+  const root = realpathSync(options.store), release = await lockClaudeLibrary(root);
+  try {
+    const markerPath = resolve(root, "claude/startup-operation.json"), directory = realpathSync(resolve(root, "claude/journals"));
+    for (const item of [resolve(root, "claude"), directory]) {
+      const stat = lstatSync(item);
+      if (stat.isSymbolicLink() || !stat.isDirectory() || stat.uid !== process.getuid?.() || stat.mode & 63 || realpathSync(item) !== item)
+        throw new Error("Private owned startup directories required.");
+    }
+    if (directory !== resolve(root, "claude/journals")) throw new Error("Startup journal directory changed.");
+    const privateFile = (file) => {
+      const stat = lstatSync(file);
+      if (stat.isSymbolicLink() || !stat.isFile() || stat.uid !== process.getuid?.() || stat.mode & 63 || stat.size > 1048576) throw new Error("Private bounded startup evidence required.");
+    };
+    privateFile(markerPath);
+    const marker = JSON.parse(readFileSync(markerPath, "utf8"));
+    if (Object.keys(marker).sort().join() !== "journal,operationId,state" || marker.state !== "may-have-effects" || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(marker.operationId) || marker.journal !== resolve(directory, marker.operationId + ".jsonl")) throw new Error("Exact original startup marker required.");
+    privateFile(marker.journal);
+    const original = readFileSync(marker.journal, "utf8");
+    const lines = original.trimEnd().split("\n").map((line) => JSON.parse(line)), plan = lines[0], attempt = lines[1];
+    if (!original.endsWith("\n") || ![2, 3].includes(lines.length) || plan?.kind !== "startup-plan" || plan.apply !== true || plan.libraryRoot !== root || plan.operationId !== marker.operationId || plan.mode !== "configure" || !Array.isArray(plan.members) || plan.members.length !== 3 || plan.members.map((m) => m.key).sort().join() !== ["engineering", "operator-01", "cicd"].map((role) => options.pack + "/intakes/" + role).sort().join() || new Set(plan.members.map((m) => m.sessionId)).size !== 3 || attempt?.kind !== "worker-create-attempt" || Object.keys(attempt).sort().join() !== ["kind", "taskId", "workerId", "nativeId", "cwd", "title", "model", "effort", "permissionMode", "contextDigest", "at"].sort().join() || attempt.taskId !== plan.operationId || attempt.nativeId !== plan.members[0].sessionId || attempt.workerId !== attempt.nativeId.replace(/^local_/, "") || attempt.contextDigest !== createHash2("sha256").update(JSON.stringify(plan.context)).digest("hex") || ["cwd", "title", "model", "effort", "permissionMode"].some((key) => attempt[key] !== plan.members[0][key]) || plan.members.some((m) => !/^local_[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(m.sessionId) || m.permissionMode !== "bypassPermissions" || !m.permissionConsent) || lines.length === 3 && lines[2].kind !== "startup-creation-absence-verified")
+      throw new Error("Only the exact interrupted three-coordinator readiness bootstrap can be reconciled.");
+    verifyPlanContext(plan);
+    const expected = {
+      kind: "startup-creation-absence-verified",
+      operationId: plan.operationId,
+      sessionIds: plan.members.map((m) => m.sessionId),
+      attemptedNativeId: attempt.nativeId,
+      nativeSessionsAbsent: true,
+      nativeInputsReplayed: false,
+      preservedUnknown: true
+    };
+    if (lines.length === 3 && JSON.stringify(lines[2]) !== JSON.stringify(expected)) throw new Error("Prior startup reconciliation receipt differs.");
+    const expression = `(async()=>{if(process.pid!==${options.pid})throw new Error('Desktop process changed.');
+   const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');
+   const fs=load('node:fs'),crypto=load('node:crypto'),path=load('node:path');
+   const caps=(${discoverClaudeNativeCapabilities.toString()})(load,process.resourcesPath),plan=${JSON.stringify(plan)};
+   const check=()=>{caps.assertCurrent();(${verifyClaudePlanContext.toString()})(plan,undefined,fs,crypto,path,(${snapshotClaudeMarkdown.toString()}));};
+   const checkpoint=row=>{check();const old=fs.readFileSync(${JSON.stringify(marker.journal)},'utf8');
+    if(old!==${JSON.stringify(original)})throw new Error('Original startup journal changed.');
+    ${lines.length === 2 ? `const fd=fs.openSync(${JSON.stringify(marker.journal)},'a',384);try{fs.writeSync(fd,JSON.stringify(row)+'\\n');fs.fsyncSync(fd);}finally{fs.closeSync(fd);}` : ""}};
+   return (${reconcileClaudeStartupAbsence.toString()})(caps.manager,plan,${JSON.stringify(attempt)},check,checkpoint);})()`;
+    const receipt = await evaluate(options.endpoint, expression);
+    verifyPlanContext(plan);
+    if (JSON.stringify(receipt) !== JSON.stringify(expected) || readFileSync(marker.journal, "utf8") !== (lines.length === 2 ? original + JSON.stringify(expected) + "\n" : original) || readFileSync(markerPath, "utf8") !== JSON.stringify(marker) + "\n")
+      throw new Error("Startup absence reconciliation audit was not acknowledged.");
+    const retained = resolve(directory, plan.operationId + ".reconciled-marker.json");
+    if (existsSync(retained)) throw new Error("Startup reconciliation marker already retained.");
+    renameSync(markerPath, retained);
+    syncDirectory(directory);
+    syncDirectory(resolve(root, "claude"));
+    return { ...receipt, journal: marker.journal, retainedMarker: retained, state: "startup-readiness-absence-reconciled", packActivated: false };
+  } finally {
+    release();
+  }
+}
+function readClaudeReadinessContinuation(root, pack, completion = false) {
+  const markerPath = resolve(root, "claude/startup-operation.json");
+  for (const directory2 of [resolve(root, "claude"), resolve(root, "claude/journals")]) {
+    const st = lstatSync(directory2);
+    if (!st.isDirectory() || st.isSymbolicLink() || st.uid !== process.getuid?.() || st.mode & 63 || realpathSync(directory2) !== directory2) throw new Error("Private owned readiness directories required.");
+  }
+  const exact = (row, fields) => row && Object.keys(row).sort().join() === fields.sort().join();
+  const read = (file) => {
+    const st = lstatSync(file);
+    if (st.isSymbolicLink() || !st.isFile() || st.uid !== process.getuid?.() || st.mode & 63 || st.size > 1048576 || realpathSync(file) !== file) throw new Error("Private bounded readiness continuation evidence required.");
+    return readFileSync(file, "utf8");
+  };
+  const markerText = read(markerPath), marker = JSON.parse(markerText), directory = resolve(root, "claude/journals");
+  if (Object.keys(marker).sort().join() !== "journal,operationId,state" || marker.state !== "may-have-effects" || !/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/.test(marker.operationId) || marker.journal !== resolve(directory, marker.operationId + ".jsonl")) throw new Error("Exact original readiness marker required.");
+  const bytes = read(marker.journal);
+  if (!bytes.endsWith("\n")) throw new Error("Readiness journal is incomplete.");
+  const rows = bytes.trimEnd().split("\n").map((line) => JSON.parse(line)), original = rows.shift();
+  if (original?.kind !== "startup-plan" || original.apply !== true || original.libraryRoot !== root || original.operationId !== marker.operationId || original.mode !== "configure" || !Array.isArray(original.members) || original.members.length !== 3 || original.members.some((m) => m.permissionMode !== "bypassPermissions" || !m.permissionConsent) || new Set(original.members.map((m) => m.sessionId)).size !== 3 || original.members.map((m) => m.key).sort().join() !== ["engineering", "operator-01", "cicd"].map((role) => pack + "/intakes/" + role).sort().join()) throw new Error("Exact three-coordinator readiness plan required.");
+  const digest = createHash2("sha256").update(JSON.stringify(original.context)).digest("hex"), created = [], acknowledged = [];
+  let index = 0;
+  for (const member of original.members) {
+    if (index === rows.length) break;
+    if (rows[index]?.kind === "worker-workspace-trust-attempt") {
+      for (const kind of ["worker-workspace-trust-attempt", "worker-workspace-trust-verified"]) {
+        const row = rows[index++];
+        if (!exact(row, ["kind", "nativeId", "cwd", "contextDigest", "literalKeyOnly", "at"]) || !Number.isFinite(row.at) || row.kind !== kind || row.nativeId !== member.sessionId || row.cwd !== member.cwd || row.contextDigest !== digest || row.literalKeyOnly !== true)
+          throw new Error("Readiness trust audit differs or is unresolved.");
+      }
+    }
+    const attempt = rows[index++], verified = rows[index++];
+    if (!exact(attempt, ["kind", "taskId", "workerId", "nativeId", "cwd", "title", "model", "effort", "permissionMode", "contextDigest", "at"]) || !Number.isFinite(attempt.at) || attempt.kind !== "worker-create-attempt" || attempt.taskId !== original.operationId || attempt.workerId !== member.sessionId.replace(/^local_/, "") || attempt.nativeId !== member.sessionId || attempt.contextDigest !== digest || ["cwd", "title", "model", "effort", "permissionMode"].some((k) => attempt[k] !== member[k]) || !exact(verified, ["kind", "state", "nativeId", "taskId", "workerId", "model", "effort", "permissionMode", "contextDigest", "nativeHistoryEntries", "readinessProbeSent", "taskPromptSent", "at"]) || !Number.isFinite(verified.at) || verified.kind !== "worker-create-verified" || verified.state !== "native-worker-readiness-pending" || verified.nativeId !== member.sessionId || verified.workerId !== attempt.workerId || verified.taskId !== original.operationId || verified.contextDigest !== digest || verified.readinessProbeSent !== true || verified.taskPromptSent !== false || !Number.isInteger(verified.nativeHistoryEntries) || verified.nativeHistoryEntries < 0 || ["model", "effort", "permissionMode"].some((k) => verified[k] !== member[k])) throw new Error("Only acknowledged readiness creation can continue; never replay an uncertain start.");
+    created.push(member.sessionId);
+    while (["coordinator-readiness-history-adopted", "coordinator-readiness-warm-attempt", "coordinator-bootstrap-history-ready"].includes(rows[index]?.kind)) {
+      const row = rows[index++];
+      if (row.sessionId !== member.sessionId || row.operationId !== original.operationId || row.originalTerminalUnknown !== true) throw Error("Readiness restart audit identity differs.");
+      if (row.kind === "coordinator-readiness-history-adopted") {
+        if (!exact(row, ["kind", "operationId", "sessionId", "cliSessionId", "userUuid", "assistantUuid", "contextDigest", "historyDigest", "previousPid", "currentPid", "originalTerminalUnknown", "nativeInputsReplayed"]) || row.userUuid !== attempt.workerId || row.contextDigest !== digest || !/^local_/.test(row.sessionId) || !/^[a-f0-9-]{36}$/.test(row.cliSessionId) || !/^[a-f0-9-]{36}$/.test(row.assistantUuid) || !/^[a-f0-9]{64}$/.test(row.historyDigest) || !Number.isSafeInteger(row.previousPid) || row.previousPid < 1 || !Number.isSafeInteger(row.currentPid) || row.currentPid < 1 || row.currentPid === row.previousPid || row.nativeInputsReplayed !== false) throw Error("Readiness restart history audit differs.");
+      } else if (row.kind === "coordinator-readiness-warm-attempt") {
+        if (!exact(row, ["kind", "sessionId", "operationId", "originalTerminalUnknown"])) throw Error("Readiness warm audit differs.");
+      } else {
+        if (!exact(row, ["kind", "sessionId", "operationId", "originalTerminalUnknown", "nativeInputsReplayed"]) || row.nativeInputsReplayed !== false) throw Error("Readiness history acknowledgement differs.");
+        if (!acknowledged.includes(member.sessionId)) acknowledged.push(member.sessionId);
+      }
+    }
+    if (rows[index]?.kind === "coordinator-bootstrap-verified") {
+      if (!exact(rows[index], ["kind", "sessionId"]) || rows[index++].sessionId !== member.sessionId) throw new Error("Readiness terminal acknowledgement differs.");
+      acknowledged.push(member.sessionId);
+    } else if (index !== rows.length && !acknowledged.includes(member.sessionId)) throw new Error("Readiness creation order is ambiguous.");
+  }
+  if (!created.length || index !== rows.length && !(completion && created.length === 3 && acknowledged.length === 3 && rows[index]?.kind === "settings-baseline")) throw new Error("Readiness journal contains later or unrelated effects.");
+  const { kind: _, apply: __, ...plan } = original;
+  verifyPlanContext(plan);
+  return { plan, created, acknowledged, journal: marker.journal, markerText, journalText: bytes, ...completion ? { completionRows: rows.slice(index) } : {} };
+}
+async function verifyClaudeReadinessContinuation(manager, members, created, operationId, check) {
+  const records = manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.coordinator-bootstrap.v1")], starts = manager.inFlightStarts;
+  if (!(records instanceof Map) || typeof starts?.hasStartInFlight !== "function" || typeof starts?.hasStartAbortController !== "function" || typeof starts?.hasDeferredTeardown !== "function" || typeof starts?.pendingStartModel !== "function" || !(manager.pendingPopSpawnsInFlight instanceof Map) || !(manager.sideSessionStartsInFlight instanceof Map)) throw new Error("Native readiness continuation capabilities unavailable.");
+  for (const member of members) {
+    check();
+    const record = records.get(member.sessionId);
+    if (created.includes(member.sessionId)) {
+      if (record?.operationId !== operationId || !["attempted", "verified", "restart-adopted"].includes(record.state)) throw new Error("Original native readiness reservation changed.");
+    } else {
+      if (record || starts.hasStartInFlight(member.sessionId) || starts.hasStartAbortController(member.sessionId) || starts.hasDeferredTeardown(member.sessionId) || starts.pendingStartModel(member.sessionId) !== void 0 || manager.pendingPopSpawnsInFlight.has(member.sessionId) || manager.sideSessionStartsInFlight.has(member.sessionId) || manager.hasLosableWork(member.sessionId)) throw new Error("Uncreated coordinator has unresolved native custody.");
+      const raw = await manager.getSessionWhenLoaded(member.sessionId, "topolo-readiness-continuation", { warnOnMiss: false });
+      check();
+      const dto = await manager.getSession(member.sessionId);
+      check();
+      const history = await manager.getTranscript(member.sessionId);
+      check();
+      if (raw || dto || !Array.isArray(history) || history.length) throw new Error("Uncreated coordinator identity already has native history.");
+    }
+  }
+}
+async function configureClaudeStartup(options, evaluate = evaluateClaudeMain, qualify = verifyClaudeOrganizationPolicy, bind = bindClaudeFrontdoorHooks, prepare = prepareClaudeStartup) {
+  validateInspectorEndpoint(options.endpoint);
+  const root = realpathSync(options.store);
+  if (["activation-operation.json", "launch-operation.json"].some((n) => existsSync(resolve(root, "claude", n)))) throw Error("Unresolved pack activation/launch retains custody.");
+  if (options.continueReadiness && (!options.apply || options.prepare || !options.policy)) throw new Error("Readiness continuation requires explicit original policy/apply and no preparation.");
+  if (!options.continueReadiness && existsSync(resolve(root, "claude/startup-operation.json")) || existsSync(resolve(root, "claude/native-operation.json"))) throw new Error("Unresolved native operation requires reconciliation before preparation.");
+  if (!options.prepare && !options.policy) throw new Error("Reviewed startup policy or explicit --prepare required.");
+  const policy = options.policy ?? resolve(root, "claude/journals", randomUUID() + ".startup-policy.json");
+  if (options.prepare) prepare(root, options.pack, policy);
+  const release = await lockClaudeLibrary(root);
+  try {
+    const marker = resolve(root, "claude/startup-operation.json");
+    if (!options.continueReadiness && existsSync(marker) || existsSync(resolve(root, "claude/native-operation.json")))
+      throw new Error("Unresolved native operation requires reconciliation before startup.");
+    const prior = options.previousLibrary ? readClaudePreviousCoordinatorLibrary(options.previousLibrary, root) : null;
+    let plan = {
+      ...prepareClaudeNativePlan(root, options.pack, policy, "configure", true),
+      operationId: randomUUID(),
+      ...prior ? { previousCoordinators: prior.members } : {}
+    };
+    if (prior) {
+      Object.assign(plan.context, prior.context);
+      plan.globalContextFiles.push(...Object.keys(prior.context));
+    }
+    const continuation = options.continueReadiness ? readClaudeReadinessContinuation(root, options.pack) : null;
+    if (continuation) {
+      for (const key of Object.keys(plan).filter((k) => k !== "operationId")) if (JSON.stringify(plan[key]) !== JSON.stringify(continuation.plan[key])) throw new Error("Original readiness policy, ownership or context changed.");
+      plan = { ...continuation.plan, readinessContinuation: continuation.created, readinessAcknowledged: continuation.acknowledged };
+    }
+    if (plan.members.some((m) => !/^.+\/intakes\/(engineering|operator-01|cicd)$/.test(m.key)))
+      throw new Error("Startup settings apply only to the three coordinator roles.");
+    verifyPlanContext(plan);
+    if (options.apply && plan.members.some((m) => m.permissionMode === "bypassPermissions"))
+      qualify(root, options.pack, plan.installationConsent);
+    const directory = resolve(root, "claude/journals");
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    const journal = resolve(directory, plan.operationId + ".jsonl");
+    if (continuation) {
+      if (readFileSync(marker, "utf8") !== continuation.markerText || readFileSync(journal, "utf8") !== continuation.journalText) throw new Error("Readiness continuation journal changed before native entry.");
+    } else {
+      durableRecord(journal, { kind: "startup-plan", ...plan, apply: options.apply }, "wx");
+      syncDirectory(directory);
+      if (options.apply) {
+        durableRecord(marker, { operationId: plan.operationId, journal, state: "may-have-effects" }, "wx");
+        syncDirectory(resolve(root, "claude"));
+      }
+    }
+    let profile = readClaudeDesktopProfile(root);
+    if (profile) {
+      if (profile.profile.pack !== options.pack || profile.profile.consentDigest !== createHash2("sha256").update(JSON.stringify(plan.installationConsent)).digest("hex")) throw Error("Managed profile consent differs from current startup.");
+      const proof = await evaluate(options.endpoint, `(async()=>{if(process.pid!==${options.pid})throw Error('Desktop PID changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');const managers=[...new Set(Object.values(load.cache).filter(r=>r.filename?.startsWith(process.resourcesPath+'/app.asar/')).map(r=>r.exports?.claudeCodeSessionManager).filter(Boolean))];if(managers.length!==1)throw Error('Native manager ambiguous');return (${verifyClaudeDesktopProfileNative.toString()})(${JSON.stringify(profile.profile)},process.pid,load('electron').app,managers[0],process.env);})()`);
+      verifyPlanContext(plan);
+      profile = acknowledgeClaudeDesktopProfile(root, profile, proof);
+    }
+    let restartReadiness;
+    if (continuation && profile && options.previousConnection) {
+      const previous = readClaudeTaskConnection(options.previousConnection, options.pid, true);
+      if (previous.pid !== options.pid) restartReadiness = { previousPid: previous.pid };
+    }
+    const profileReceipt = profile ? { file: resolve(root, "claude/desktop-profile.json"), digest: createHash2("sha256").update(readFileSync(resolve(root, "claude/desktop-profile.json"))).digest("hex") } : null;
+    const result = await evaluate(options.endpoint, nativeClaudeSettingsExpression(options.pid, { ...plan, ...profile ? { desktopProfile: profile.profile, desktopProfileReceipt: profileReceipt } : {}, ...restartReadiness ? { restartReadiness } : {} }, journal, options.apply));
+    verifyPlanContext(plan);
+    if (profileReceipt && createHash2("sha256").update(readFileSync(profileReceipt.file)).digest("hex") !== profileReceipt.digest) throw Error("Managed profile receipt changed during native startup.");
+    if (result.state !== (options.apply ? "native-settings-verified" : "settings-preflight") || result.applied !== options.apply)
+      throw new Error("Native startup result is not a qualified settings acknowledgement.");
+    if (options.apply) {
+      if (result.pinsVerified !== true || result.after?.length !== plan.members.length || result.after.some((r, i) => r.sessionId !== plan.members[i].sessionId || r.model !== plan.members[i].model || r.effort !== plan.members[i].effort || r.permissionMode !== plan.members[i].permissionMode || r.pinned !== true)) throw new Error("Native startup roster readback differs.");
+      durableRecord(journal, { kind: "startup-settings-verified", after: result.after });
+      const workConfig = resolve(root, "work/config.json");
+      if (existsSync(workConfig) && JSON.parse(readFileSync(workConfig, "utf8")).format === "topolo-task-dispatch-v2") {
+        const runtime = resolve(root, "claude/task-runtime");
+        mkdirSync(runtime, { recursive: true, mode: 448 });
+        const local = [resolve(root, "claude/desktop-task-connection.json"), resolve(root, "claude/desktop-task-connection-prepared.json")].filter(existsSync);
+        const known = (options.previousConnection ? [options.previousConnection] : local).map((file) => readClaudeTaskConnection(file, options.pid, true));
+        const current = known.filter((row) => row.pid === options.pid);
+        if (current.some((row) => Object.keys(row).some((key) => row[key] !== current[0][key]))) throw new Error("Multiple current native connection owners differ; preserve custody.");
+        const retained = current[0] ?? known[0] ?? null;
+        const previous = retained?.pid === options.pid ? retained : null;
+        const sameStore = previous?.runtime === runtime;
+        const secretPath = sameStore ? previous.secretPath : resolve(directory, plan.operationId + ".desktop-secret.json");
+        if (!sameStore) durableRecord(secretPath, { token: randomBytes(32).toString("hex") }, "wx");
+        const descriptor = sameStore ? previous : {
+          pid: options.pid,
+          runtime,
+          identity: createHash2("sha256").update(JSON.stringify({ root, pack: options.pack, operationId: plan.operationId })).digest("hex"),
+          socket: resolve("/tmp", "topolo-claude-task-" + plan.operationId + ".sock"),
+          secretPath
+        };
+        const boundCoordinators = previous ? claudeTaskConnectionCoordinators(previous) : [];
+        if (prior && boundCoordinators.length && JSON.stringify(prior.members) !== JSON.stringify(boundCoordinators)) throw new Error("Previous coordinator ownership proofs differ.");
+        const previousCoordinators = prior?.members ?? boundCoordinators;
+        const outgoing = previousCoordinators.filter((row) => !plan.members.some((member) => member.sessionId === row.sessionId));
+        const allCoordinators = [...plan.members.map((m) => ({ sessionId: m.sessionId, cwd: m.cwd })), ...previousCoordinators];
+        const coordinators = [...new Map(allCoordinators.map((row) => [row.sessionId, row])).values()];
+        const native = await evaluate(options.endpoint, nativeClaudeDesktopControlExpression(
+          options.pid,
+          root,
+          descriptor,
+          secretPath,
+          journal,
+          { existing: previous, coordinators }
+        ));
+        if (!["native-desktop-task-control-installed", "native-desktop-task-control-reused"].includes(native.state) || native.pid !== options.pid || native.identity !== descriptor.identity)
+          throw new Error("Native Desktop task control was not acknowledged.");
+        const connectionFile = resolve(root, "claude/desktop-task-connection.json"), temporary = resolve(directory, plan.operationId + ".connection.json");
+        durableRecord(temporary, descriptor, "wx");
+        renameSync(temporary, connectionFile);
+        syncDirectory(resolve(root, "claude"));
+        const input = resolve(directory, plan.operationId + ".frontdoors.json");
+        const binding = bind(root, options.pid, result.frontdoorSessions, input, void 0, descriptor);
+        verifyPlanContext(plan);
+        durableRecord(journal, { kind: "frontdoor-hooks-prepared", ...binding });
+        result.frontdoorHooksPrepared = true;
+        if (outgoing.length) {
+          const retirement = await evaluate(options.endpoint, nativeClaudeCoordinatorRetirementExpression(options.pid, outgoing, plan.members, descriptor, journal));
+          if (retirement.state !== "previous-coordinators-retired" || JSON.stringify(retirement.retired) !== JSON.stringify(outgoing.map((row) => row.sessionId)))
+            throw new Error("Previous coordinator retirement was not acknowledged; reconcile without replay.");
+          durableRecord(journal, { kind: "previous-coordinators-retired", retired: retirement.retired });
+          result.previousCoordinatorsRetired = retirement.retired;
+        }
+      }
+      unlinkSync(marker);
+      syncDirectory(resolve(root, "claude"));
+    }
+    return { ...result, journal, packActivated: false, cloudDispatchVerified: false };
+  } finally {
+    release();
+  }
+}
+async function completeClaudeStartup(options, evaluate = evaluateClaudeMain, bind = bindClaudeFrontdoorHooks) {
+  validateInspectorEndpoint(options.endpoint);
+  const root = realpathSync(options.store), release = await lockClaudeLibrary(root);
+  try {
+    const original = readClaudeReadinessContinuation(root, options.pack, true), plan = original.plan;
+    const prior = options.previousLibrary ? readClaudePreviousCoordinatorLibrary(options.previousLibrary, root) : null;
+    const current = { ...prepareClaudeNativePlan(root, options.pack, options.policy, "configure", true), ...prior ? { previousCoordinators: prior.members } : {} };
+    if (prior) {
+      Object.assign(current.context, prior.context);
+      current.globalContextFiles.push(...Object.keys(prior.context));
+    }
+    for (const key of Object.keys(current)) if (JSON.stringify(current[key]) !== JSON.stringify(plan[key])) throw Error("Late startup policy or original context differs.");
+    const tail = original.completionRows, settings = tail.filter((r) => r.kind === "settings-verified"), ack = tail.filter((r) => r.kind === "startup-settings-verified");
+    const allow = /* @__PURE__ */ new Set(["settings-baseline", "settings-pin-attempt", "settings-pin-acknowledged", "settings-verified", "startup-settings-verified", "native-python-capability-qualified", "native-desktop-task-control-installed", "native-desktop-task-control-reused", "frontdoor-hooks-prepared"]);
+    if (tail.some((r) => !allow.has(r.kind)) || settings.length !== 1 || ack.length !== 1 || tail.filter((r) => r.kind === "settings-baseline").length !== 1 || JSON.stringify(settings[0].after) !== JSON.stringify(ack[0].after)) throw Error("Only acknowledged settings/control startup can complete.");
+    const after = ack[0].after;
+    if (!Array.isArray(after) || after.length !== 3 || after.some((r, i) => r.sessionId !== plan.members[i].sessionId || r.key !== plan.members[i].key || r.model !== plan.members[i].model || r.effort !== plan.members[i].effort || r.permissionMode !== plan.members[i].permissionMode || r.pinned !== true || r.processAttached !== true || r.startupPermissionVerified !== true)) throw Error("Original effective startup settings ACK differs.");
+    for (const row of tail) {
+      if (row.operationId !== void 0 && row.operationId !== plan.operationId) throw Error("Startup audit belongs to another operation.");
+      if (row.kind.startsWith("settings-pin-") && (!plan.members.some((m) => m.sessionId === row.sessionId) || row.pinned !== true)) throw Error("Startup pin audit differs.");
+    }
+    const descriptor = readClaudeTaskConnection(resolve(root, "claude/desktop-task-connection.json"), options.pid);
+    const control = tail.filter((r) => ["native-desktop-task-control-installed", "native-desktop-task-control-reused"].includes(r.kind));
+    if (control.length !== 1 || Object.keys(descriptor).some((k) => control[0][k] !== descriptor[k])) throw Error("Original native control ACK differs.");
+    const profile = readClaudeDesktopProfile(root);
+    if (!profile || profile.state !== "native-profile-verified" || profile.pid !== options.pid) throw Error("Current native profile acknowledgement required.");
+    const profileFile = resolve(root, "claude/desktop-profile.json"), profileDigest = createHash2("sha256").update(readFileSync(profileFile)).digest("hex");
+    const input = resolve(root, "claude/journals", plan.operationId + ".frontdoors.json"), payload = JSON.parse(readFileSync(input, "utf8"));
+    if (payload.desktopPid !== options.pid || JSON.stringify(payload.nativeConnection) !== JSON.stringify(descriptor) || payload.roles?.length !== 3 || payload.roles.some((r, i) => r.key !== plan.members[i].key || r.cwd !== plan.members[i].cwd)) throw Error("Original front-door input identity differs.");
+    const inputDigest = createHash2("sha256").update(readFileSync(input)).digest("hex");
+    const observed = await evaluate(options.endpoint, `(async()=>{if(process.pid!==${options.pid})throw Error('Native process changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');const fs=load('node:fs'),crypto=load('node:crypto'),path=load('node:path'),caps=(${discoverClaudeNativeCapabilities.toString()})(load,process.resourcesPath),plan=${JSON.stringify(plan)},descriptor=${JSON.stringify(descriptor)},roles=${JSON.stringify(payload.roles)};
+   const check=()=>{caps.assertCurrent();(${verifyClaudeDesktopProfileNative.toString()})(${JSON.stringify(profile.profile)},process.pid,load('electron').app,caps.manager,process.env);if(crypto.createHash('sha256').update(fs.readFileSync(${JSON.stringify(profileFile)})).digest('hex')!==${JSON.stringify(profileDigest)})throw Error('Profile receipt changed');(${verifyClaudePlanContext.toString()})(plan,plan.members,fs,crypto,path,(${snapshotClaudeMarkdown.toString()}));};check();
+   const control=caps.manager[Symbol.for('topolo.agent-pack.desktop-task-control.v1')];if(!control||control.failed||control.active!==0||Object.keys(descriptor).some(k=>control.descriptor[k]!==descriptor[k]))throw Error('Existing native control changed');
+   for(let i=0;i<plan.members.length;i++){const m=plan.members[i],raw=await caps.manager.getSessionWhenLoaded(m.sessionId,'topolo-late-startup',{warnOnMiss:false}),dto=await caps.manager.getSession(m.sessionId),history=await caps.manager.getTranscript(m.sessionId);check();if(!raw?.query||!dto||raw.cliSessionId!==roles[i].sessionId||raw.sessionId!==m.sessionId||dto.sessionId!==m.sessionId||raw.cwd!==m.cwd||dto.cwd!==m.cwd||raw.isArchived||dto.isArchived||raw.isRunning||raw.pendingCycle||raw.pendingToolPermissions?.length||caps.manager.hasLosableWork(m.sessionId)||raw.bypassAvailableAtSpawn!==true||dto.isStarred!==true||['model','effort','permissionMode'].some(k=>dto[k]!==m[k]))throw Error('Native coordinator settings or custody changed');const users=history.filter(r=>r.type==='user'),text=users[0]?.message?.content;if(users.length!==1||users[0].uuid!==m.sessionId.slice(6)||text!=='Installation readiness probe only. Do not use tools, read task files, dispatch work or perform any task. Reply exactly TOPOLO_WORKER_READY:'+m.sessionId.slice(6)||history.some(r=>r.type==='assistant'&&r.message?.content?.some(c=>c.type==='tool_use')))throw Error('Coordinator received work after readiness');}
+   if(plan.previousCoordinators?.length)await (${verifyClaudePreviousCoordinatorCustody.toString()})(caps.manager,plan.previousCoordinators,check);check();return{state:'late-startup-native-custody-verified'};})()`);
+    if (observed.state !== "late-startup-native-custody-verified" || readFileSync(original.journal, "utf8") !== original.journalText || createHash2("sha256").update(readFileSync(input)).digest("hex") !== inputDigest) throw Error("Late startup readback or original journal changed.");
+    const binding = bind(root, options.pid, payload.roles, input, void 0, descriptor, true);
+    verifyPlanContext(plan);
+    if (!tail.some((r) => r.kind === "frontdoor-hooks-prepared")) durableRecord(original.journal, { kind: "frontdoor-hooks-prepared", ...binding });
+    if (plan.previousCoordinators?.length) {
+      const retired = await evaluate(options.endpoint, nativeClaudeCoordinatorRetirementExpression(options.pid, plan.previousCoordinators, plan.members, descriptor, original.journal));
+      if (retired.state !== "previous-coordinators-retired" || JSON.stringify(retired.retired) !== JSON.stringify(plan.previousCoordinators.map((r) => r.sessionId))) throw Error("Previous coordinator retirement not acknowledged.");
+      durableRecord(original.journal, { kind: "previous-coordinators-retired", retired: retired.retired });
+    }
+    verifyPlanContext(plan);
+    unlinkSync(resolve(root, "claude/startup-operation.json"));
+    syncDirectory(resolve(root, "claude"));
+    return { state: "native-startup-completed", operationId: plan.operationId, frontdoorHooksPrepared: true, nativeInputsReplayed: false, originalTerminalUnknownPreserved: true, cloudDispatchVerified: false, packActivated: false, journal: original.journal };
+  } finally {
+    release();
+  }
+}
 function runClaudeSmokeHelper(root, action, payload, source, launch = spawn) {
   if (!["prepare", "arm", "mark", "read", "verify"].includes(action) || typeof root !== "string" || typeof source !== "string")
     return Promise.reject(new Error("Closed owned smoke helper required."));
@@ -2399,27 +4014,50 @@ function operateClaudeLaneControl(options, request = requestClaudeApprovalContro
   const secret = JSON.parse(readFileSync(connection.secretPath, "utf8"));
   return request(connection, options.operation, secret.token);
 }
+
 export {
+  observeClaudeFrontdoors,
+  discoverClaudeNativeCapabilities,
+  snapshotClaudeWorkerSource,
+  materializeClaudeWorkerGuard,
+  qualifyClaudePython,
+  nativeClaudeDesktopControlExpression,
+  nativeClaudeSettingsExpression,
   CLAUDE_NATIVE_QUALIFIER,
-  claudeLaneExpression,
-  configureClaudePack,
+  validateInspectorEndpoint,
+  snapshotClaudeMarkdown,
+  prepareClaudeNativePlan,
+  verifyClaudePlanContext,
+  nativePackExpression,
   evaluateClaudeMain,
   lockClaudeLibrary,
-  nativePackExpression,
+  verifyClaudeOrganizationPolicy,
+  configureClaudePack,
+  materializeClaudeHookAdapter,
+  bindClaudeFrontdoorHooks,
+  readClaudeTaskConnection,
+  claudeTaskConnectionCoordinators,
+  readClaudePreviousCoordinatorLibrary,
+  verifyClaudePreviousCoordinatorCustody,
+  retireClaudeCoordinators,
+  ensureClaudeCoordinators,
+  prepareClaudeStartup,
+  reconcileClaudeStartupAbsence,
+  recoverClaudeStartup,
+  readClaudeReadinessContinuation,
+  verifyClaudeReadinessContinuation,
+  configureClaudeStartup,
+  completeClaudeStartup,
+  runClaudeSmokeHelper,
+  requestClaudeApprovalControl,
   operateClaudeApprovals,
-  operateClaudeLane,
-  operateClaudeLaneControl,
   operateClaudeSmoke,
   prepareClaudeDynamicLane,
-  prepareClaudeNativePlan,
-  prepareClaudePrivateHelperConnection,
   privateClaudeHelperEnvironment,
-  requestClaudeApprovalControl,
-  requireClaudePrivateQueryEffectQualified,
+  prepareClaudePrivateHelperConnection,
   runClaudeLaneHelper,
-  runClaudeSmokeHelper,
-  snapshotClaudeMarkdown,
-  validateInspectorEndpoint,
-  verifyClaudeOrganizationPolicy,
-  verifyClaudePlanContext
+  requireClaudePrivateQueryEffectQualified,
+  claudeLaneExpression,
+  operateClaudeLane,
+  operateClaudeLaneControl
 };