@topolo/cli 0.13.8 → 0.13.10

package/dist/claude-pack-backend-RMSOPHVQ.js

@@ -0,0 +1,2380 @@
+#!/usr/bin/env node
+
+// src/lib/claude-pack-backend.ts
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import * as filesystem from "fs";
+import * as cryptography from "crypto";
+import * as paths from "path";
+import { spawn, spawnSync } from "child_process";
+import { dirname, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { createConnection } from "net";
+import { WebSocket } from "undici";
+
+// src/lib/claude-native-pack.ts
+async function nativeClaudePackOperation(manager, sidebar, plan, apply, checkpoint, verifyContext = () => {
+}) {
+  const fenceKey = /* @__PURE__ */ Symbol.for("topolo.agent-pack.native-operation.v1");
+  const previous = manager[fenceKey];
+  const operationId = plan.operationId ?? "legacy-configuration";
+  if (apply && previous) throw new Error("Native operation is unresolved; reconcile its journal before another mutation.");
+  if (plan.mode === "recover" && previous && (previous.operationId !== operationId || previous.running))
+    throw new Error("Native recovery identity differs or the operation is still running.");
+  if (plan.noEffects && (plan.mode !== "recover" || previous?.effectAttempted)) throw new Error("No-effect recovery is not qualified.");
+  if (apply) manager[fenceKey] = { operationId, running: true, effectAttempted: false };
+  try {
+    const incremental = (plan.mode ?? "configure") === "configure";
+    verifyContext(incremental ? [] : void 0);
+    const checkDeadline = () => {
+      if (Date.now() >= plan.deadline) throw new Error("Native operation deadline expired; reconcile journal before retry.");
+    };
+    const command = async (value) => {
+      checkDeadline();
+      const result = await sidebar(value);
+      if (!result.ok) throw new Error(result.error || "Native sidebar acknowledgement refused.");
+      return result;
+    };
+    if (!["configure", "switch", "recover"].includes(plan.mode ?? "configure") || plan.mode === "recover" && apply || plan.outgoing?.length && !["switch", "recover"].includes(plan.mode ?? "configure"))
+      throw new Error("Unqualified native operation mode.");
+    if (plan.mode === "switch" || plan.mode === "recover") {
+      if (typeof manager.ensureArchivedSessionsLoaded !== "function") throw new Error("Archived ownership inventory is unavailable.");
+      await manager.ensureArchivedSessionsLoaded("ownership");
+    }
+    if (!plan.members.length || plan.members.length > 100 || (plan.outgoing?.length ?? 0) > 100 || new Set(plan.members.map((m) => m.sessionId)).size !== plan.members.length || new Set(plan.members.map((m) => m.key)).size !== plan.members.length)
+      throw new Error("A unique owned roster of 1\u2013100 sessions is required.");
+    const models = manager.getAvailableCodeModels();
+    const groups = manager.listCustomGroups();
+    if (!groups) throw new Error("Native sidebar groups have not been reported by the running window.");
+    for (const member of plan.members) {
+      if (!/^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(member.sessionId) || !plan.noEffects && (!["claude-opus-5-5", "claude-sonnet-5-5"].includes(member.model) || !["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 session settings in plan.");
+      if (!plan.noEffects && !models.includes(member.model)) throw new Error("Requested model is absent from the native account catalog: " + member.model);
+      if (!plan.noEffects && member.group !== null && groups.filter((g) => g.name === member.group).length > 1)
+        throw new Error("Ambiguous native sidebar group: " + member.group);
+    }
+    const nativeDescriptor = async (member) => {
+      if (typeof manager.getSessionWhenLoaded !== "function") throw new Error("Qualified native session descriptor API is unavailable.");
+      const descriptor = await manager.getSessionWhenLoaded(member.sessionId, "topolo-agent-pack", { warnOnMiss: false });
+      checkDeadline();
+      if (!descriptor || descriptor.sessionId !== member.sessionId || descriptor.cwd !== member.cwd || descriptor.title !== member.title)
+        throw new Error("Owned native session descriptor identity changed: " + member.key);
+      return descriptor;
+    };
+    const snapshot = async (members = plan.members) => {
+      const result = [];
+      for (const member of members) {
+        checkDeadline();
+        let session = await manager.getSession(member.sessionId);
+        if (!session || session.sessionId !== member.sessionId || session.cwd !== member.cwd || session.title !== member.title || session.isArchived && !["switch", "recover"].includes(plan.mode ?? "configure"))
+          throw new Error("Owned session identity or active membership changed: " + member.key);
+        let descriptor;
+        if (!incremental && (manager.hasLosableWork(member.sessionId) || session.isRunning || session.starting || session.pendingToolPermissions?.length))
+          throw new Error("Session has live or pending work; no changes permitted: " + member.key);
+        if (!plan.noEffects) {
+          descriptor = await nativeDescriptor(member);
+          session = await manager.getSession(member.sessionId);
+          checkDeadline();
+          if (!session || session.sessionId !== member.sessionId || session.cwd !== member.cwd || session.title !== member.title || (session.isArchived || descriptor.isArchived) && incremental) throw new Error("Owned session identity or active membership changed: " + member.key);
+          if (!incremental && (manager.hasLosableWork(member.sessionId) || session.isRunning || session.starting || session.pendingToolPermissions?.length || descriptor.isRunning || descriptor.starting || descriptor.pendingToolPermissions?.length))
+            throw new Error("Session has live or pending work; no changes permitted: " + member.key);
+          if (descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || descriptor.spawnedFrom)
+            throw new Error("Incoming session is not a qualified local role.");
+        }
+        const busyReasons = [
+          ...manager.hasLosableWork(member.sessionId) ? ["losable"] : [],
+          ...session.isRunning || descriptor?.isRunning ? ["running"] : [],
+          ...session.starting || descriptor?.starting ? ["starting"] : [],
+          ...session.pendingToolPermissions?.length || descriptor?.pendingToolPermissions?.length ? ["pending-permissions"] : []
+        ];
+        result.push({
+          key: member.key,
+          sessionId: session.sessionId,
+          cwd: session.cwd,
+          title: session.title,
+          group: manager.getSessionCustomGroup(member.sessionId)?.name ?? null,
+          pinned: session.isStarred === true,
+          model: session.model ?? null,
+          effort: session.effort ?? null,
+          permissionMode: session.permissionMode ?? null,
+          archived: session.isArchived === true,
+          ...incremental ? { busy: busyReasons.length > 0, busyReasons } : {}
+        });
+      }
+      return result;
+    };
+    const before = await snapshot();
+    const outgoing = plan.outgoing ?? [];
+    const identities = [...plan.members, ...outgoing].map((m) => m.sessionId);
+    if (new Set(identities).size !== identities.length) throw new Error("Incoming and outgoing native identities overlap.");
+    const outgoingSnapshot = async (members = outgoing) => {
+      const result = [];
+      for (const member of members) {
+        checkDeadline();
+        const session = await manager.getSession(member.sessionId);
+        if (!/^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(member.sessionId) || !session || session.sessionId !== member.sessionId || session.cwd !== member.cwd || session.title !== member.title)
+          throw new Error("Outgoing native identity differs.");
+        if (manager.hasLosableWork(member.sessionId) || session.isRunning || session.starting || session.pendingToolPermissions?.length)
+          throw new Error("Outgoing session has live or pending work.");
+        if (!plan.noEffects) {
+          const descriptor = await nativeDescriptor(member);
+          if (manager.hasLosableWork(member.sessionId) || descriptor.isRunning || descriptor.starting || descriptor.pendingToolPermissions?.length)
+            throw new Error("Outgoing session has live or pending work.");
+          if (descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || descriptor.spawnedFrom || !manager.archiveCascadeClosureOf || manager.archiveCascadeClosureOf(descriptor).length)
+            throw new Error("Outgoing native archive closure is not qualified.");
+        }
+        result.push({ key: member.key, sessionId: member.sessionId, cwd: session.cwd, title: session.title, archived: session.isArchived === true });
+      }
+      return result;
+    };
+    const outgoingBefore = await outgoingSnapshot();
+    const sections = await command({ kind: "list_sections" });
+    checkpoint({ kind: "baseline", before, outgoingBefore, sections: sections.sections, at: Date.now() });
+    if (incremental) {
+      const settings = ["group", "pinned", "model", "effort", "permissionMode"];
+      const idleBefore = plan.members.filter((_, i) => !before[i].busy);
+      verifyContext([]);
+      if (!apply) return {
+        state: "preflight",
+        before,
+        outgoingBefore,
+        sections: sections.sections,
+        availableModels: models,
+        applied: false,
+        contextVerifiedSessionIds: idleBefore.map((m) => m.sessionId)
+      };
+      const appliedFields = [];
+      const deferredReasons = /* @__PURE__ */ new Map();
+      const differences = (member, row) => settings.filter((field) => member[field] !== row[field]);
+      for (const member of plan.members) {
+        const initial = (await snapshot([member]))[0];
+        if (initial.busy) {
+          deferredReasons.set(member.sessionId, initial.busyReasons);
+          continue;
+        }
+        for (const setting of differences(member, initial)) {
+          let row = (await snapshot([member]))[0];
+          if (row.busy) {
+            deferredReasons.set(member.sessionId, row.busyReasons);
+            break;
+          }
+          if (row[setting] === member[setting]) continue;
+          verifyContext([member]);
+          if (setting === "group" && member.group !== null) {
+            let matching = manager.listCustomGroups()?.filter((g) => g.name === member.group);
+            if (!matching || matching.length > 1) throw new Error("Ambiguous native sidebar group: " + member.group);
+            if (!matching.length) {
+              row = (await snapshot([member]))[0];
+              if (row.busy) {
+                deferredReasons.set(member.sessionId, row.busyReasons);
+                break;
+              }
+              verifyContext([member]);
+              checkDeadline();
+              checkpoint({ kind: "attempt", operation: "create_group", key: member.key, name: member.group, at: Date.now() });
+              manager[fenceKey].effectAttempted = true;
+              const created = await command({ kind: "create_group", name: member.group });
+              checkpoint({ kind: "acknowledged", operation: "create_group", key: member.key, name: member.group, at: Date.now() });
+              matching = manager.listCustomGroups()?.filter((g) => g.name === member.group);
+              if (!created.groupId) throw new Error("Native create_group did not return an identity.");
+              if (matching?.length !== 1 || matching[0].id !== created.groupId)
+                throw new Error("Native group read-back mismatch.");
+              verifyContext([member]);
+              appliedFields.push({ key: member.key, operation: "create_group", name: member.group });
+            }
+          }
+          row = (await snapshot([member]))[0];
+          if (row.busy) {
+            deferredReasons.set(member.sessionId, row.busyReasons);
+            break;
+          }
+          if (row[setting] === member[setting]) continue;
+          verifyContext([member]);
+          checkDeadline();
+          if (setting === "model" && !manager.getAvailableCodeModels().includes(member.model))
+            throw new Error("Requested model is absent from the native account catalog: " + member.model);
+          const operation = setting === "group" ? "move_sessions" : setting === "pinned" ? "set_pinned" : setting === "model" ? "set_model" : setting === "effort" ? "set_effort" : "set_permission_mode";
+          checkpoint({ kind: "attempt", operation, setting, key: member.key, sessionId: member.sessionId, at: Date.now() });
+          manager[fenceKey].effectAttempted = true;
+          if (setting === "group") {
+            const matching = member.group === null ? [] : manager.listCustomGroups()?.filter((g) => g.name === member.group);
+            if (!matching || member.group !== null && matching.length !== 1) throw new Error("Native group identity changed.");
+            await command({
+              kind: "move_sessions",
+              sessionIds: [member.sessionId],
+              ...member.group === null ? {} : { groupId: matching[0].id }
+            });
+          } else if (setting === "pinned") await command({ kind: "set_pinned", sessionId: member.sessionId, pinned: member.pinned });
+          else if (setting === "model") await manager.setModel(member.sessionId, member.model);
+          else if (setting === "effort") await manager.setEffort(member.sessionId, member.effort);
+          else if (!await manager.setPermissionMode(member.sessionId, member.permissionMode, "picker"))
+            throw new Error("Native permission mode was refused: " + member.key);
+          checkpoint({ kind: "acknowledged", operation, setting, key: member.key, sessionId: member.sessionId, at: Date.now() });
+          const actual = (await snapshot([member]))[0];
+          if (actual[setting] !== member[setting]) throw new Error("Native read-back mismatch: " + member.key + " / " + setting);
+          verifyContext([member]);
+          appliedFields.push({ key: member.key, sessionId: member.sessionId, setting, value: member[setting] });
+          checkpoint({ kind: "verified-field", operation, setting, key: member.key, sessionId: member.sessionId, at: Date.now() });
+        }
+      }
+      const after2 = await snapshot();
+      const idleAfter = plan.members.filter((member, i) => !after2[i].busy && !deferredReasons.has(member.sessionId));
+      verifyContext(idleAfter);
+      const deferred = plan.members.flatMap((member, i) => {
+        const row = after2[i], fields = differences(member, row);
+        if (!fields.length) return [];
+        const reasons = deferredReasons.get(member.sessionId) ?? row.busyReasons;
+        if (!reasons?.length) throw new Error("Native read-back mismatch: " + member.key + " / " + fields.join(","));
+        return [{ key: member.key, sessionId: member.sessionId, fields, reasons }];
+      });
+      const attestedBusyKeys = after2.filter((row) => row.busy && !deferred.some((d) => d.sessionId === row.sessionId)).map((row) => row.key);
+      checkpoint({ kind: deferred.length ? "partial-verified" : "verified", after: after2, appliedFields, deferred, attestedBusyKeys, at: Date.now() });
+      delete manager[fenceKey];
+      return {
+        state: deferred.length ? "native-settings-partial" : "native-settings-verified",
+        before,
+        after: after2,
+        outgoingAfter: [],
+        verifiedAgents: after2.length - deferred.length,
+        complete: deferred.length === 0,
+        applied: appliedFields.length > 0,
+        appliedFields,
+        deferred,
+        attestedBusyKeys,
+        contextVerifiedSessionIds: idleAfter.map((m) => m.sessionId),
+        busyObservations: [...deferredReasons].map(([sessionId, reasons]) => ({ key: plan.members.find((m) => m.sessionId === sessionId).key, sessionId, reasons })),
+        modelInferenceVerified: false,
+        readOnlyConfinementVerified: false,
+        fullPackSwitchSupported: false
+      };
+    }
+    if (plan.mode === "recover") {
+      if (plan.noEffects) {
+        verifyContext();
+        checkpoint({ kind: "reconciled-no-effects", after: before, at: Date.now() });
+        delete manager[fenceKey];
+        return { state: "native-reconciled-no-effects", after: before, applied: false, nativeEffectsReplayed: false };
+      }
+      for (let i = 0; i < plan.members.length; i++) {
+        const wanted = plan.members[i];
+        const actual = before[i];
+        for (const setting of ["group", "pinned", "model", "effort", "permissionMode"])
+          if (actual[setting] !== wanted[setting]) throw new Error("Recovery read-back is incomplete; no native effects replayed.");
+        if (actual.archived) throw new Error("Recovery incoming session is still archived.");
+      }
+      if (outgoingBefore.some((s) => !s.archived)) throw new Error("Recovery outgoing roster is incomplete.");
+      verifyContext();
+      checkpoint({ kind: "reconciled", after: before, outgoingAfter: outgoingBefore, at: Date.now() });
+      delete manager[fenceKey];
+      return { state: "native-reconciled", after: before, outgoingAfter: outgoingBefore, applied: false, nativeEffectsReplayed: false };
+    }
+    if (!apply) return { state: "preflight", before, outgoingBefore, sections: sections.sections, availableModels: models, applied: false };
+    const effect = async (description, run) => {
+      checkDeadline();
+      verifyContext();
+      const affected = description.sessionIds ?? (description.sessionId ? [description.sessionId] : null);
+      await snapshot(affected ? plan.members.filter((m) => affected.includes(m.sessionId)) : plan.members);
+      await outgoingSnapshot(affected ? outgoing.filter((m) => affected.includes(m.sessionId)) : outgoing);
+      checkpoint({ kind: "attempt", ...description, at: Date.now() });
+      manager[fenceKey].effectAttempted = true;
+      await run();
+      checkpoint({ kind: "acknowledged", ...description, at: Date.now() });
+    };
+    const groupIds = new Map(groups.map((g) => [g.name, g.id]));
+    if (plan.mode === "switch") {
+      for (const member of outgoing) {
+        if (!(await manager.getSession(member.sessionId)).isArchived)
+          await effect({ operation: "archive", sessionId: member.sessionId }, () => manager.archiveSession(
+            member.sessionId,
+            { cleanupWorktree: false, forceWorktreeCleanup: false, discardUntracked: false, isAutomatic: true }
+          ));
+      }
+      for (const member of plan.members) {
+        const session = await manager.getSession(member.sessionId);
+        if (session.isArchived) {
+          const descriptor = await nativeDescriptor(member);
+          if (descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || descriptor.spawnedFrom)
+            throw new Error("Incoming session is not a qualified local role.");
+          await effect({ operation: "unarchive", sessionId: member.sessionId }, async () => {
+            await manager.unarchiveSession(member.sessionId);
+          });
+        }
+      }
+    }
+    for (const name of new Set(plan.members.map((m) => m.group).filter((g) => g !== null))) {
+      if (!groupIds.has(name)) await effect({ operation: "create_group", name }, async () => {
+        const result = await command({ kind: "create_group", name });
+        if (!result.groupId) throw new Error("Native create_group did not return an identity.");
+        groupIds.set(name, result.groupId);
+      });
+    }
+    await effect({ operation: "set_view" }, () => command({
+      kind: "set_view",
+      view: { groupBy: "custom", status: "active", sortBy: "recency", lastActivityDays: 0 }
+    }));
+    for (const group of new Set(plan.members.map((m) => m.group))) {
+      const sessionIds = plan.members.filter((m) => m.group === group).map((m) => m.sessionId);
+      await effect({ operation: "move_sessions", group, sessionIds }, () => command({
+        kind: "move_sessions",
+        sessionIds,
+        ...group === null ? {} : { groupId: groupIds.get(group) }
+      }));
+    }
+    for (const member of plan.members) {
+      await effect({ operation: "set_pinned", sessionId: member.sessionId }, () => command({ kind: "set_pinned", sessionId: member.sessionId, pinned: member.pinned }));
+      await effect({ operation: "set_model", sessionId: member.sessionId }, () => manager.setModel(member.sessionId, member.model));
+      await effect({ operation: "set_effort", sessionId: member.sessionId }, () => manager.setEffort(member.sessionId, member.effort));
+      await effect({ operation: "set_permission_mode", sessionId: member.sessionId }, async () => {
+        if (!await manager.setPermissionMode(member.sessionId, member.permissionMode, "picker"))
+          throw new Error("Native permission mode was refused: " + member.key);
+      });
+    }
+    const after = await snapshot();
+    const outgoingAfter = await outgoingSnapshot();
+    if (after.some((s) => s.archived) || outgoingAfter.some((s) => !s.archived)) throw new Error("Native archive membership read-back mismatch.");
+    for (let i = 0; i < plan.members.length; i++) {
+      const wanted = plan.members[i];
+      const actual = after[i];
+      for (const setting of ["group", "pinned", "model", "effort", "permissionMode"])
+        if (actual[setting] !== wanted[setting]) throw new Error("Native read-back mismatch: " + wanted.key + " / " + setting);
+    }
+    verifyContext();
+    checkpoint({ kind: "verified", after, outgoingAfter, at: Date.now() });
+    delete manager[fenceKey];
+    return {
+      state: "native-settings-verified",
+      before,
+      after,
+      outgoingAfter,
+      verifiedAgents: after.length,
+      applied: true,
+      modelInferenceVerified: false,
+      readOnlyConfinementVerified: false,
+      fullPackSwitchSupported: plan.mode === "switch"
+    };
+  } catch (error) {
+    if (apply) manager[fenceKey] = {
+      operationId,
+      running: false,
+      recoveryRequired: true,
+      effectAttempted: manager[fenceKey]?.effectAttempted === true
+    };
+    throw error;
+  }
+}
+async function nativeClaudeDynamicLaneOperation(manager, plan, operation, checkpoint, verifyContext, qualifyOrganization, verifyHistory) {
+  if (!["read", "configure", "retire"].includes(operation) || !/^[a-z0-9][a-z0-9-]*$/.test(plan.laneId) || !/^[a-f0-9]{64}$/.test(plan.planDigest) || !plan.intake.key.includes("/intakes/") || (/* @__PURE__ */ new Set([plan.nativeId, plan.source.sessionId, plan.intake.sessionId])).size !== 3 || !["low", "medium", "high", "max"].includes(plan.effort) || !["default", "acceptEdits", "bypassPermissions"].includes(plan.permissionMode) || ![plan.nativeId, plan.source.sessionId, plan.intake.sessionId].every((id) => /^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id)) || plan.cwd !== plan.source.cwd)
+    throw new Error("Exact child, source role and originating intake plan required.");
+  const symbol = /* @__PURE__ */ Symbol.for("topolo.agent-pack.dynamic-lane.operation.v1");
+  if (manager[symbol]) throw new Error("An unresolved child operation retains native custody.");
+  const fence = () => {
+    if (Date.now() >= plan.deadline) throw new Error("Child operation deadline expired; no retry.");
+    verifyContext();
+  };
+  const fixed = async (role) => {
+    const raw = await manager.getSessionWhenLoaded(role.sessionId, "topolo-dynamic-source", { warnOnMiss: false });
+    const dto = await manager.getSession(role.sessionId);
+    fence();
+    if (!raw || !dto || raw.sessionId !== role.sessionId || dto.sessionId !== role.sessionId || raw.cwd !== role.cwd || dto.cwd !== role.cwd || raw.title !== role.title || dto.title !== role.title || raw.isArchived || dto.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom)
+      throw new Error("Source role or intake raw native identity differs.");
+    return { raw, dto };
+  };
+  const child = async (allowArchived = false) => {
+    await fixed(plan.source);
+    await fixed(plan.intake);
+    const raw = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-child", { warnOnMiss: false });
+    const dto = await manager.getSession(plan.nativeId);
+    fence();
+    if (!raw || !dto || raw.sessionId !== plan.nativeId || dto.sessionId !== plan.nativeId || raw.cwd !== plan.cwd || dto.cwd !== plan.cwd || raw.title !== plan.title || dto.title !== plan.title || !allowArchived && (raw.isArchived || dto.isArchived) || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom?.sessionId !== plan.intake.sessionId || raw.spawnedFrom?.sideSession !== true)
+      throw new Error("Actual child raw descriptor or original native parent differs.");
+    const busy = raw.isRunning || raw.starting || dto.isRunning || dto.starting || raw.pendingToolPermissions?.length || dto.pendingToolPermissions?.length || manager.hasLosableWork(plan.nativeId);
+    return {
+      nativeId: plan.nativeId,
+      cwd: dto.cwd,
+      model: dto.model,
+      effort: dto.effort,
+      permissionMode: dto.permissionMode,
+      nativeParentId: raw.spawnedFrom.sessionId,
+      archived: raw.isArchived === true && dto.isArchived === true,
+      busy: !!busy,
+      pendingApprovals: dto.pendingToolPermissions?.length ?? 0,
+      backend: "local",
+      foreignWorkspace: false
+    };
+  };
+  fence();
+  const before = await child();
+  if (!manager.getAvailableCodeModels().includes(plan.model)) throw new Error("Exact task model is unavailable; no parent fallback.");
+  if (operation === "read") return { state: "native-child-read", ...before, settingsACK: false, contextACK: false };
+  if (before.busy) throw new Error("Own child has active or pending work.");
+  await qualifyOrganization();
+  fence();
+  let attempted = false;
+  manager[symbol] = { laneId: plan.laneId, planDigest: plan.planDigest, attempted: false };
+  try {
+    if (operation === "retire") {
+      if (plan.lifecycleState !== "settled") throw new Error("Only a settled child with verified operation outcome may retire.");
+      const history = await verifyHistory(plan.nativeId);
+      if (typeof manager.archiveCascadeClosureOf !== "function" || typeof manager.archiveSession !== "function")
+        throw new Error("Qualified preserved-history native archive API unavailable.");
+      const raw = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-retire", { warnOnMiss: false });
+      const closure = manager.archiveCascadeClosureOf(raw);
+      if (!Array.isArray(closure) || closure.length) throw new Error("Child archive would affect another native session.");
+      const current = await child();
+      if (current.busy) throw new Error("Child became busy before archive.");
+      fence();
+      checkpoint({ state: "archive-may-have-effects", laneId: plan.laneId, nativeId: plan.nativeId });
+      attempted = true;
+      manager[symbol].attempted = true;
+      await manager.archiveSession(plan.nativeId, { cleanupWorktree: false, forceWorktreeCleanup: false, discardUntracked: false, isAutomatic: true });
+      const after2 = await child(true);
+      if (!after2.archived || after2.busy || await verifyHistory(plan.nativeId, history) !== true)
+        throw new Error("Native child archive or transcript preservation is unproven.");
+      checkpoint({ state: "retired", laneId: plan.laneId, nativeId: plan.nativeId, historyPreserved: true });
+      delete manager[symbol];
+      return { state: "retired", ...after2, historyPreserved: true };
+    }
+    for (const field of ["model", "effort", "permissionMode"]) {
+      const current = await child();
+      if (current.busy) throw new Error("Child became busy before native settings effect.");
+      if (current[field] === plan[field]) continue;
+      await qualifyOrganization();
+      fence();
+      if (!manager.getAvailableCodeModels().includes(plan.model)) throw new Error("Native account catalog changed.");
+      checkpoint({ state: "settings-may-have-effects", laneId: plan.laneId, nativeId: plan.nativeId, field });
+      attempted = true;
+      manager[symbol].attempted = true;
+      if (field === "model") await manager.setModel(plan.nativeId, plan.model);
+      else if (field === "effort") await manager.setEffort(plan.nativeId, plan.effort);
+      else if (!await manager.setPermissionMode(plan.nativeId, plan.permissionMode, "picker")) throw new Error("Child permission setting refused.");
+      const actual = await child();
+      if (actual[field] !== plan[field]) throw new Error("Actual child " + field + " differs; no fallback or task dispatch.");
+      checkpoint({ state: "native-field-ACK", laneId: plan.laneId, nativeId: plan.nativeId, field, value: actual[field] });
+    }
+    const after = await child();
+    const processRecord = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-process-settings", { warnOnMiss: false });
+    fence();
+    if (!processRecord?.query || typeof manager.getEffort !== "function" || typeof manager.readRunningModel !== "function")
+      throw new Error("Actual child process settings are unavailable; settings ACK is unproven.");
+    const query = processRecord.query;
+    const actualModel = await manager.readRunningModel(processRecord, query);
+    const actualEffort = await manager.getEffort(plan.nativeId);
+    const reread = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-process-settings", { warnOnMiss: false });
+    const finalChild = await child();
+    if (reread !== processRecord || reread.query !== query || actualModel !== plan.model || actualEffort !== plan.effort || finalChild.busy)
+      throw new Error("Actual child process model/effort differs or is unavailable; settings ACK is unproven.");
+    await qualifyOrganization();
+    fence();
+    if (after.model !== plan.model || after.effort !== plan.effort || after.permissionMode !== plan.permissionMode || after.busy)
+      throw new Error("Actual child settings are not the complete requested tuple.");
+    checkpoint({ state: "configured-settings-ACK", laneId: plan.laneId, nativeId: plan.nativeId, after });
+    delete manager[symbol];
+    return { state: "configured-settings-ACK", ...after, settingsACK: true, contextACK: false, modelTurnsStarted: false };
+  } catch (error) {
+    if (!attempted) delete manager[symbol];
+    else checkpoint({ state: "uncertain-effect-hold", laneId: plan.laneId, nativeId: plan.nativeId });
+    throw error;
+  }
+}
+async function nativeClaudeDynamicContext(manager, plan, operation, helper, fingerprint, verifyContext, qualifyOrganization) {
+  if (!["context-start", "context-read"].includes(operation.kind) || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(operation.operationId))
+    throw new Error("Closed own-child context operation required.");
+  const ready = async () => {
+    verifyContext();
+    const raw = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-context", { warnOnMiss: false });
+    const view = await manager.getSession(plan.nativeId);
+    verifyContext();
+    if (!raw || !view || raw.sessionId !== plan.nativeId || view.sessionId !== plan.nativeId || raw.cwd !== plan.cwd || view.cwd !== plan.cwd || raw.title !== plan.title || view.title !== plan.title || raw.isArchived || view.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom?.sessionId !== plan.intake.sessionId || raw.spawnedFrom?.sideSession !== true || raw.isRunning || view.isRunning || raw.starting || view.starting || raw.pendingToolPermissions?.length || view.pendingToolPermissions?.length || manager.hasLosableWork(plan.nativeId))
+      throw new Error("Exact configured child is not idle on the original native parent.");
+    if (!raw.query || typeof manager.readRunningModel !== "function" || typeof manager.getEffort !== "function" || await manager.readRunningModel(raw, raw.query) !== plan.model || await manager.getEffort(plan.nativeId) !== plan.effort)
+      throw new Error("Current actual child process model/effort ACK differs.");
+    await qualifyOrganization();
+    verifyContext();
+  };
+  await ready();
+  if (typeof manager.getTranscriptForCallerElsewhere !== "function") throw new Error("Qualified own-child transcript resolver unavailable.");
+  if (operation.kind === "context-read") {
+    const history = await manager.getTranscriptForCallerElsewhere(plan.nativeId);
+    await ready();
+    if (!Array.isArray(history) || !history.length) throw new Error("Own-child context transcript is missing; no acknowledgement.");
+    return helper("context-ack", { laneId: plan.laneId, operationId: operation.operationId, messages: history });
+  }
+  const symbol = /* @__PURE__ */ Symbol.for("topolo.agent-pack.dynamic-context.v1");
+  if (manager[symbol]) throw new Error("An unresolved child bootstrap owns delivery; no replay.");
+  manager[symbol] = { laneId: plan.laneId, operationId: operation.operationId };
+  let armed = false;
+  try {
+    const bootstrap = await helper("context-prepare", { laneId: plan.laneId, operationId: operation.operationId });
+    const history = await manager.getTranscriptForCallerElsewhere(plan.nativeId);
+    if (!Array.isArray(history)) throw new Error("Exact own-child pre-bootstrap history is unavailable.");
+    await ready();
+    await helper("context-mark", {
+      laneId: plan.laneId,
+      operationId: operation.operationId,
+      state: "start-may-have-effects",
+      historyCount: history.length,
+      historyDigest: fingerprint(history)
+    });
+    armed = true;
+    const result = await manager.sendMessage(
+      plan.nativeId,
+      bootstrap.text,
+      void 0,
+      { messageUuid: operation.operationId, initiator: "agent", origin: { kind: "task-notification" } }
+    );
+    const state = result?.delivered === true ? "native-delivered" : result?.delivered === false ? "native-refused" : "uncertain";
+    await helper("context-mark", { laneId: plan.laneId, operationId: operation.operationId, state });
+    if (state === "uncertain") throw new Error("Child context delivery is uncertain; never replay.");
+    delete manager[symbol];
+    return { state, laneId: plan.laneId, operationId: operation.operationId, contextACK: false };
+  } catch (error) {
+    if (!armed) delete manager[symbol];
+    throw error;
+  }
+}
+async function nativeClaudeDynamicFixture(manager, plan, operation, helper, verifyContext, qualifyOrganization) {
+  if (!["fixture-start", "fixture-read"].includes(operation.kind) || operation.kind === "fixture-start" && !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(operation.operationId ?? ""))
+    throw new Error("Closed one-child native fixture operation required.");
+  const read = async () => {
+    const raw2 = await manager.getSessionWhenLoaded(plan.nativeId, "topolo-dynamic-fixture", { warnOnMiss: false });
+    const dto = await manager.getSession(plan.nativeId);
+    verifyContext();
+    if (!raw2 || !dto || raw2.sessionId !== plan.nativeId || dto.sessionId !== plan.nativeId || raw2.cwd !== plan.cwd || dto.cwd !== plan.cwd || raw2.title !== plan.title || dto.title !== plan.title || raw2.isArchived || dto.isArchived || raw2.backend?.kind !== "local" || raw2.backend.remoteTarget || raw2.worktreePath || raw2.worktreeLazy || raw2.spawnedFrom?.sessionId !== plan.intake.sessionId || raw2.spawnedFrom?.sideSession !== true) throw new Error("Own native fixture child identity or original intake parent changed.");
+    return { raw: raw2, native: {
+      nativeId: plan.nativeId,
+      busy: !!(raw2.isRunning || raw2.starting || dto.isRunning || dto.starting || manager.hasLosableWork(plan.nativeId)),
+      pendingApprovals: dto.pendingToolPermissions?.length ?? 0
+    } };
+  };
+  const { raw, native } = await read();
+  if (operation.kind === "fixture-read") {
+    if (native.busy || native.pendingApprovals) return { state: "native-fixture-pending", ...native };
+    const messages = await manager.getTranscriptForCallerElsewhere(plan.nativeId);
+    const latest = await read();
+    if (latest.native.busy || latest.native.pendingApprovals) return { state: "native-fixture-pending", ...latest.native };
+    if (!Array.isArray(messages)) throw new Error("Own native fixture transcript is unavailable.");
+    return helper("fixture-outcome", { laneId: plan.laneId, messages, native: latest.native });
+  }
+  if (native.busy || native.pendingApprovals || !raw.query || await manager.readRunningModel(raw, raw.query) !== plan.model || await manager.getEffort(plan.nativeId) !== plan.effort) throw new Error("Own fixture needs idle child and current actual process tuple ACK.");
+  await qualifyOrganization();
+  verifyContext();
+  const symbol = /* @__PURE__ */ Symbol.for("topolo.agent-pack.dynamic-fixture.v1");
+  if (manager[symbol]) throw new Error("An unresolved native fixture retains delivery custody.");
+  manager[symbol] = { laneId: plan.laneId, operationId: operation.operationId };
+  let armed = false;
+  try {
+    const fixture = await helper("fixture-prepare", { laneId: plan.laneId, operationId: operation.operationId });
+    const latest = await read();
+    if (latest.native.busy || latest.native.pendingApprovals) throw new Error("Own child became busy before fixture dispatch.");
+    await qualifyOrganization();
+    verifyContext();
+    await helper("fixture-mark", { laneId: plan.laneId, operationId: operation.operationId, state: "start-may-have-effects" });
+    armed = true;
+    const result = await manager.sendMessage(
+      plan.nativeId,
+      fixture.text,
+      void 0,
+      { messageUuid: operation.operationId, initiator: "agent", origin: { kind: "task-notification" } }
+    );
+    const state = result?.delivered === true ? "native-delivered" : result?.delivered === false ? "native-refused" : "uncertain";
+    await helper("fixture-mark", { laneId: plan.laneId, operationId: operation.operationId, state });
+    if (state === "uncertain") throw new Error("Native fixture delivery is uncertain; no replay.");
+    delete manager[symbol];
+    return { state, laneId: plan.laneId, operationId: operation.operationId, operationEffectVerified: false };
+  } catch (error) {
+    if (!armed) delete manager[symbol];
+    throw error;
+  }
+}
+async function nativeClaudeReadEmptyCreation(manager, planned, verifyContext) {
+  const pending = planned.creationNativeId ? { nativeId: planned.creationNativeId } : manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.native-creation.v1")]?.get(planned.laneId);
+  if (!pending?.nativeId) throw new Error("Own actual created native identity is unresolved; no replay.");
+  const raw = await manager.getSessionWhenLoaded(pending.nativeId, "topolo-dynamic-empty-process", { warnOnMiss: false });
+  const view = await manager.getSession(pending.nativeId);
+  verifyContext();
+  if (!raw || !view || raw.sessionId !== pending.nativeId || view.sessionId !== pending.nativeId || raw.cwd !== planned.role.cwd || view.cwd !== planned.role.cwd || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.spawnedFrom?.sessionId !== planned.intake.nativeId || raw.spawnedFrom?.sideSession !== true || raw.isArchived || view.isArchived || raw.worktreePath || raw.worktreeLazy) throw new Error("Actual fresh native child placement/parent differs.");
+  if (raw.isRunning || view.isRunning || raw.messageBuffer?.length || raw.heldAcrossLoss?.length || raw.pendingToolPermissions?.length || view.pendingToolPermissions?.length || manager.hasLosableWork(pending.nativeId))
+    throw new Error("Fresh child has held/input/active work before configuration-only ACK.");
+  if (!raw.query || raw.pendingFirstStart || raw.startResumeInFlight) return { state: "created-initializing", nativeId: pending.nativeId, requestedTaskStarted: false, privateMCPVerified: false };
+  return {
+    state: "ready",
+    nativeId: pending.nativeId,
+    cwd: raw.cwd,
+    title: raw.title,
+    model: view.model,
+    effort: view.effort,
+    nativeParentId: raw.spawnedFrom.sessionId,
+    archived: false,
+    backend: "local",
+    foreignWorkspace: false,
+    busy: false,
+    pendingApprovals: 0,
+    requestedTaskStarted: false,
+    modelTurnsStarted: false,
+    privateMCPVerified: false,
+    proof: "current-native-descriptor-only"
+  };
+}
+
+// src/lib/claude-pack-approvals.ts
+async function nativeClaudeApprovalControl(manager, descriptor, token, net, fs, invoke, qualify, checkpoint) {
+  const key = /* @__PURE__ */ Symbol.for("topolo.agent-pack.approval-control.v1");
+  qualify();
+  if (!Number.isSafeInteger(descriptor.pid) || descriptor.pid < 1 || !/^[a-f0-9]{64}$/.test(token) || !/^[a-f0-9]{64}$/.test(descriptor.identity)) throw new Error("Unqualified native control identity.");
+  const previous = manager[key];
+  if (fs.existsSync(descriptor.socket)) throw new Error("Native control socket path already exists; no unowned takeover.");
+  if (previous) {
+    if (previous.active) throw new Error("Native approval control requests are still in flight.");
+    await new Promise((done, fail) => previous.server.close((error) => error ? fail(error) : done()));
+    delete manager[key];
+  }
+  const control = { active: 0, server: null, descriptor };
+  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) > 65536) {
+        dispatched = true;
+        connection.destroy();
+        return;
+      }
+      if (!buffer.includes("\n")) return;
+      dispatched = true;
+      control.active++;
+      try {
+        if (control.failure) throw new Error(control.failure);
+        qualify();
+        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 approval control authentication or process identity differs.");
+        const op = request.operation;
+        const fields = op?.kind === "smoke-start" ? ["kind", "key", "caseId", "operationId"] : op?.kind === "smoke-read" ? ["kind", "operationId"] : ["kind", "key", "intake", "fingerprint", "decision", "humanDecisionRecorded"];
+        if (!op || !["list", "details", "respond", "smoke-start", "smoke-read"].includes(op.kind) || Object.keys(op).some((k) => !fields.includes(k)))
+          throw new Error("Unsupported native control operation.");
+        const result = await invoke(op);
+        const reply = JSON.stringify({ result }) + "\n";
+        if (Buffer.byteLength(reply) > 262144) throw new Error("Native approval details exceed bounded transport; use the original native interaction.");
+        connection.end(reply);
+      } catch (error) {
+        try {
+          checkpoint({ kind: "approval-control-refused" });
+        } catch {
+          control.failure = "Native approval audit unavailable; reconcile through the original interaction.";
+        }
+        connection.end(JSON.stringify({ error: control.failure || (error instanceof Error ? error.message : "Native approval control refused.") }) + "\n");
+      } finally {
+        control.active--;
+      }
+    });
+  });
+  control.server = server;
+  await new Promise((done, fail) => {
+    const failed = (error) => fail(error);
+    server.once("error", failed);
+    server.listen(descriptor.socket, () => {
+      server.off("error", failed);
+      done();
+    });
+  });
+  try {
+    fs.chmodSync(descriptor.socket, 384);
+    checkpoint({ kind: "approval-control-installed", ...descriptor });
+  } catch (error) {
+    await new Promise((done) => server.close(() => done()));
+    throw error;
+  }
+  server.on("error", () => {
+    control.failure = "Native approval control failed; reconcile through the original interaction.";
+    try {
+      checkpoint({ kind: "approval-control-error" });
+    } catch {
+      control.failure = "Native approval audit unavailable; reconcile through the original interaction.";
+    }
+  });
+  manager[key] = control;
+  return { state: "native-approval-control-installed", ...descriptor };
+}
+async function nativeClaudeOwnedSmokeOperation(manager, members, operation, helper, fingerprint, nativeIdentity, qualifyNative = () => {
+}) {
+  const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+  const fields = operation?.kind === "smoke-start" ? ["kind", "key", "caseId", "operationId"] : ["kind", "operationId"];
+  if (!operation || !["smoke-start", "smoke-read"].includes(operation.kind) || Object.keys(operation).sort().join() !== fields.sort().join() || !uuid.test(operation.operationId) || operation.kind === "smoke-start" && (!/^[a-z0-9-]+\/[a-z0-9-]+\/[a-z0-9-]+$/.test(operation.key) || !["stg-context-memory-bytes", "stg-peer-ack", "prod-role-context-ack"].includes(operation.caseId)))
+    throw new Error("Exact closed native smoke operation required.");
+  if (!members.length || members.length > 70 || new Set(members.map((m) => m.key)).size !== members.length || new Set(members.map((m) => m.sessionId)).size !== members.length) throw new Error("Unique native smoke roster required.");
+  const owner = /* @__PURE__ */ Symbol.for("topolo.agent-pack.owned-smoke.v1");
+  const rosterIdentity = fingerprint(members);
+  const summary = (record) => Object.fromEntries([
+    "operationId",
+    "harness",
+    "caseId",
+    "key",
+    "state",
+    "nativeId",
+    "hostedUsageVerified",
+    "operationEffectVerified",
+    "nativeStatus",
+    "historyPreserved",
+    "ack"
+  ].filter((k) => k in record).map((k) => [k, record[k]]));
+  const check = (member2, session) => {
+    if (!session || session.sessionId !== member2.sessionId || session.cwd !== member2.cwd || session.title !== member2.title || session.isArchived || session.backend?.kind !== "local" || session.backend.remoteTarget || session.worktreePath || session.worktreeLazy || session.spawnedFrom || session.isRunning || session.starting || session.pendingToolPermissions?.length || manager.hasLosableWork(member2.sessionId) || session.model !== member2.model || session.effort !== member2.effort || session.permissionMode !== member2.permissionMode || member2.permissionMode !== "bypassPermissions" || !member2.permissionConsent || !manager.getAvailableCodeModels().includes(member2.model)) throw new Error("Exact idle native smoke ownership/settings unavailable.");
+  };
+  const current = () => {
+    qualifyNative();
+    if (manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.native-operation.v1")] || fingerprint(members) !== rosterIdentity)
+      throw new Error("Unresolved native configuration or changed smoke roster remains.");
+    for (const member2 of members) check(member2, manager.getSession(member2.sessionId));
+  };
+  const ready = async () => {
+    current();
+    for (const member2 of members) {
+      const descriptor = await manager.getSessionWhenLoaded(member2.sessionId, "topolo-owned-smoke", { warnOnMiss: false });
+      check(member2, descriptor);
+      check(member2, manager.getSession(member2.sessionId));
+    }
+    current();
+  };
+  if (operation.kind === "smoke-read") {
+    const record = await helper("read", { operation: operation.operationId });
+    if (record.state !== "native-delivered") return summary(record);
+    if (record.nativeIdentity !== nativeIdentity) return { ...summary(record), connectionCurrent: false };
+    const member2 = members.find((m) => m.key === record.key && m.sessionId === record.row.nativeId && m.cwd === record.row.cwd);
+    if (!member2) throw new Error("Native smoke read custody differs.");
+    const session = await manager.getSession(member2.sessionId);
+    if (session?.isRunning || session?.starting || manager[owner]) return summary(record);
+    check(member2, session);
+    const history = await manager.getTranscript(member2.sessionId);
+    if (!Array.isArray(history)) throw new Error("Qualified native smoke transcript API unavailable.");
+    const same = fingerprint(history.slice(0, record.historyCount)) === record.historyHash;
+    const markers = history.map((m, index) => m.uuid === record.operationId ? index : -1).filter((i) => i >= 0);
+    const marker = markers[0] ?? -1;
+    const user = markers.length === 1 && marker === record.historyCount && history[marker]?.type === "user" ? marker : -1;
+    const nextUser = history.findIndex((m, index) => index > user && m.type === "user");
+    const assistants = user < 0 ? [] : history.slice(user + 1, nextUser < 0 ? history.length : nextUser).filter((m) => m.type === "assistant");
+    const text = assistants.at(-1)?.message?.content?.filter((b) => b.type === "text").map((b) => b.text).join("");
+    let ack;
+    if (typeof text === "string" && text.length <= 2048) {
+      try {
+        ack = JSON.parse(text);
+      } catch {
+      }
+    }
+    const expected = {
+      operationId: record.operationId,
+      logicalId: record.row.logicalId,
+      agentVersionId: record.row.agentVersionId,
+      contextMarkerHash: record.row.contextMarkerHash,
+      artifactHash: record.row.artifactHash
+    };
+    const valid = same && Number.isSafeInteger(record.historyCount) && record.historyCount >= 0 && ack && typeof ack === "object" && !Array.isArray(ack) && Object.keys(ack).sort().join() === [...Object.keys(expected), "status"].sort().join() && Object.entries(expected).every(([k, v]) => ack[k] === v) && ["ok", "blocked"].includes(ack.status);
+    await helper("verify", { operation: operation.operationId });
+    return summary(await helper("mark", {
+      operation: operation.operationId,
+      state: "uncertain",
+      nativeStatus: "terminal-evidence-unavailable",
+      historyPreserved: same,
+      ...valid ? { ack } : {}
+    }));
+  }
+  if (manager[owner]) throw new Error("Native smoke dispatch already reserved.");
+  const member = members.find((m) => m.key === operation.key);
+  if (!member) throw new Error("Smoke role is not natively owned.");
+  manager[owner] = operation.operationId;
+  let prepared = false;
+  try {
+    await ready();
+    const plan = await helper("prepare", {
+      key: operation.key,
+      case: operation.caseId,
+      operation: operation.operationId,
+      native_identity: nativeIdentity
+    });
+    prepared = true;
+    const actual = plan.roster.map((r) => [r.key, r.nativeId, r.cwd, r.title]).sort();
+    const wanted = members.map((m) => [m.key, m.sessionId, m.cwd, m.title]).sort();
+    if (JSON.stringify(actual) !== JSON.stringify(wanted)) throw new Error("Smoke binding must match the complete owned native roster.");
+    await ready();
+    await helper("verify", { operation: operation.operationId });
+    const history = await manager.getTranscript(member.sessionId);
+    if (!Array.isArray(history)) throw new Error("Qualified native smoke transcript API unavailable.");
+    await helper("mark", { operation: operation.operationId, state: "prepared", historyCount: history.length, historyHash: fingerprint(history) });
+    await ready();
+    const admission = await helper("arm", { operation: operation.operationId, native_identity: nativeIdentity });
+    current();
+    if (admission.operationId !== operation.operationId || admission.nativeIdentity !== nativeIdentity || admission.state !== "start-may-have-effects" || admission.bindingHash !== plan.record.bindingHash || !/^[a-f0-9]{64}$/.test(admission.bindingHash) || !Number.isFinite(admission.expiresAt) || admission.expiresAt !== plan.record.dispatchExpiresAt || Date.now() >= admission.expiresAt * 1e3)
+      throw new Error("Original smoke final dispatch admission expired or differs.");
+    const ack = await manager.sendMessage(
+      member.sessionId,
+      plan.text,
+      void 0,
+      { messageUuid: operation.operationId, initiator: "agent", origin: { kind: "task-notification" } }
+    );
+    return summary(await helper("mark", {
+      operation: operation.operationId,
+      state: ack?.delivered === true ? "native-delivered" : ack?.delivered === false ? "native-refused" : "uncertain",
+      nativeId: operation.operationId
+    }));
+  } catch (error) {
+    if (prepared) {
+      const record = await helper("read", { operation: operation.operationId });
+      await helper("mark", { operation: operation.operationId, state: record.state === "prepared" ? "preflight-refused" : "uncertain" });
+    }
+    throw error;
+  } finally {
+    delete manager[owner];
+  }
+}
+async function nativeClaudeApprovalOperation(manager, routes, operation, fingerprint, checkpoint, history = []) {
+  const symbol = /* @__PURE__ */ Symbol.for("topolo.agent-pack.approvals.v1");
+  if (!routes.length || routes.length > 100 || new Set(routes.map((r) => r.sessionId)).size !== routes.length || new Set(routes.map((r) => r.key)).size !== routes.length) throw new Error("Unique owned approval roster required.");
+  const existing = manager[symbol];
+  const byId = existing?.byId ?? new Map(routes.map((r) => [r.sessionId, r]));
+  const byKey = existing?.byKey ?? new Map(routes.map((r) => [r.key, r]));
+  for (const r of routes) {
+    const intake = routes.find((candidate) => candidate.key === r.intakeKey);
+    if (!/^org:.+$/.test(r.contextKey) || !intake || !intake.key.includes("/intakes/") || intake.contextKey !== r.contextKey || intake.sessionId !== r.intakeSessionId)
+      throw new Error("Approval route has no same-context owned intake.");
+  }
+  const identity = fingerprint(routes);
+  let state = manager[symbol];
+  if (state?.auditFailed) throw new Error("Native approval audit unavailable; use the original native interaction.");
+  const owned = async (route) => {
+    if (typeof manager.getSessionWhenLoaded !== "function") throw new Error("Qualified native session descriptor API is unavailable.");
+    const descriptor = await manager.getSessionWhenLoaded(route.sessionId, "topolo-agent-pack-approval", { warnOnMiss: false });
+    const session = await manager.getSession(route.sessionId);
+    if (!session || session.sessionId !== route.sessionId || session.cwd !== route.cwd || session.title !== route.title || session.isArchived)
+      throw new Error("Native approval session identity differs: " + route.key);
+    if (!descriptor || descriptor.sessionId !== route.sessionId || descriptor.cwd !== route.cwd || descriptor.title !== route.title || descriptor.isArchived || descriptor.backend?.kind !== "local" || descriptor.backend.remoteTarget || descriptor.worktreePath || descriptor.worktreeLazy || (route.dynamic ? descriptor.spawnedFrom?.sessionId !== route.dynamic.nativeParentId || descriptor.spawnedFrom?.sideSession !== true || route.dynamic.nativeParentId !== route.intakeSessionId || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) : descriptor.spawnedFrom))
+      throw new Error("Native approval session descriptor identity differs: " + route.key);
+    return session;
+  };
+  if (state && state.identity !== identity) {
+    if (operation.kind !== "install" || state.notifications.size || [...state.entries.values()].some((e) => ["pending", "response-may-have-effects"].includes(e.record.state)))
+      throw new Error("An existing native approval owner has a different roster.");
+    for (const r of routes) await owned(r);
+    for (const route of state.routes) {
+      const session = await manager.getSession(route.sessionId);
+      if (!session || session.cwd !== route.cwd || session.title !== route.title || session.isRunning || session.starting || session.pendingToolPermissions?.length || manager.hasLosableWork(route.sessionId))
+        throw new Error("Outgoing approval owner is not safely idle.");
+    }
+    if (typeof manager.off !== "function") throw new Error("Native approval listener ownership cannot be released.");
+    manager.off("event", state.listener);
+    delete manager[symbol];
+    state = void 0;
+  }
+  const current = async (entry2) => {
+    const source2 = await owned(byId.get(entry2.record.sourceSessionId));
+    const matches = (source2.pendingToolPermissions ?? []).filter((r) => r.requestId === entry2.request.requestId);
+    if (matches.length !== 1 || fingerprint(matches[0]) !== entry2.record.fingerprint)
+      throw new Error("Exact native request is no longer pending; no replay.");
+    return matches[0];
+  };
+  if (operation.kind === "install") {
+    for (const r of routes) await owned(r);
+    if (!state) {
+      if (typeof manager.on !== "function" || typeof manager.sendMessage !== "function" || typeof manager.respondToToolPermission !== "function") throw new Error("Native approval transport unavailable.");
+      state = { identity, routes, byId, byKey, entries: /* @__PURE__ */ new Map(), notifications: /* @__PURE__ */ new Set(), deliveryAttempts: 0 };
+      manager[symbol] = state;
+      const save = (entry2) => checkpoint({ ...entry2.record });
+      const deliver = async (entry2) => {
+        const record = entry2.record;
+        if (state.notifications.has(record.key) || !["not-delivered", "awaiting-idle-intake"].includes(record.notificationState)) return;
+        if (record.sourceSessionId === record.intakeSessionId) {
+          record.notificationState = "native-intake";
+          save(entry2);
+          return;
+        }
+        state.notifications.add(record.key);
+        try {
+          await current(entry2);
+          const intake = await owned(byId.get(record.intakeSessionId));
+          if (manager.hasLosableWork(record.intakeSessionId) || intake.isRunning || intake.starting || intake.pendingToolPermissions?.length) {
+            record.notificationState = "awaiting-idle-intake";
+            save(entry2);
+            return;
+          }
+          const text = "Permission relay (generated by the Topolo pack adapter). " + record.sourceKey + " awaits a native decision. Request " + record.key + ", fingerprint " + record.fingerprint + ". Read exact live details using topolo agent-packs approvals details " + record.key + " --harness claude --intake " + record.intakeSessionId + " --fingerprint " + record.fingerprint + (byId.get(record.sourceSessionId)?.dynamic?.connectionId ? " --connection " + byId.get(record.sourceSessionId).dynamic.connectionId : "") + ". Present this to the human in this intake and relay only the recorded answer. This notification grants no approval." + (record.cardOnly ? " Claude requires approval on the original native card; report this limitation here." : "");
+          record.notificationState = "may-have-effects";
+          save(entry2);
+          state.deliveryAttempts++;
+          const ack = await manager.sendMessage(
+            record.intakeSessionId,
+            text,
+            void 0,
+            { initiator: "agent", origin: { kind: "task-notification" } }
+          );
+          record.notificationState = ack?.delivered === true ? "delivered" : "delivery-refused";
+          save(entry2);
+        } catch {
+          record.notificationState = record.notificationState === "may-have-effects" ? "delivery-uncertain" : "delivery-failed";
+          save(entry2);
+        } finally {
+          state.notifications.delete(record.key);
+        }
+      };
+      const capture = async (sessionId, request) => {
+        const route = byId.get(sessionId);
+        if (!route || !request || typeof request.requestId !== "string") return;
+        const source2 = await owned(route);
+        const matches = (source2.pendingToolPermissions ?? []).filter((r) => r.requestId === request.requestId);
+        if (matches.length !== 1) throw new Error("Native event is not in the owned pending inventory.");
+        const pending2 = matches[0];
+        const key = fingerprint([identity, pending2.requestId]);
+        const hash = fingerprint(pending2);
+        let entry2 = state.entries.get(key);
+        if (entry2 && entry2.record.fingerprint !== hash) throw new Error("Native request identity was reused.");
+        if (!entry2) {
+          const old = history.filter((row) => row.key === key).at(-1);
+          if (old && (old.fingerprint !== hash || old.sourceSessionId !== sessionId || old.intakeSessionId !== route.intakeSessionId || old.contextKey !== route.contextKey))
+            throw new Error("Durable approval identity differs; no replay.");
+          entry2 = { request: pending2, record: {
+            key,
+            fingerprint: hash,
+            sourceKey: route.key,
+            sourceSessionId: sessionId,
+            intakeKey: route.intakeKey,
+            intakeSessionId: route.intakeSessionId,
+            contextKey: route.contextKey,
+            state: "pending",
+            notificationState: "not-delivered",
+            cardOnly: pending2.onlyOnCard === true || pending2.noAllowOnNotification === true,
+            nativeApproved: false,
+            ...old ? { state: old.state, notificationState: old.notificationState } : {}
+          } };
+          state.entries.set(key, entry2);
+          save(entry2);
+        }
+        const lifecycle2 = state.dynamicLifecycle?.get(sessionId);
+        if (lifecycle2 && entry2.record.state === "pending") await lifecycle2.request(entry2.record, pending2);
+        if (entry2.record.state === "pending") await deliver(entry2);
+      };
+      state.listener = async (event) => {
+        try {
+          if (event?.type === "tool_permission_request") await capture(event.sessionId, event.request);
+          else if (event?.type === "session_updated") {
+            const source2 = byId.get(event.sessionId);
+            if (source2) {
+              const session = await owned(source2);
+              for (const entry2 of state.entries.values())
+                if (entry2.record.state === "pending" && entry2.record.sourceSessionId === event.sessionId && !(session.pendingToolPermissions ?? []).some((r) => r.requestId === entry2.request.requestId)) {
+                  entry2.record.state = "native-request-no-longer-pending";
+                  delete entry2.request;
+                  save(entry2);
+                }
+            }
+            for (const entry2 of state.entries.values())
+              if (entry2.record.state === "pending" && entry2.record.intakeSessionId === event.sessionId) await deliver(entry2);
+          }
+        } catch {
+          try {
+            checkpoint({ kind: "approval-routing-refused", sessionId: event?.sessionId });
+          } catch {
+            state.auditFailed = true;
+          }
+        }
+      };
+      manager.on("event", state.listener);
+      checkpoint({ kind: "approval-listener-installed", identity, roles: routes.length });
+      for (const r of routes) for (const request of (await owned(r)).pendingToolPermissions ?? []) await capture(r.sessionId, request);
+    }
+    return {
+      state: "native-approval-listener-installed",
+      identity,
+      roles: routes.length,
+      modelTurnsMayHaveStartedByInstallation: state.deliveryAttempts > 0
+    };
+  }
+  if (!state) throw new Error("Native approval listener is not installed.");
+  if (operation.kind === "list") return { requests: [...state.entries.values()].map((e) => ({ ...e.record })) };
+  const entry = state.entries.get(operation.key);
+  if (!entry || entry.record.state !== "pending" || entry.record.intakeSessionId !== operation.intake || entry.record.fingerprint !== operation.fingerprint) throw new Error("Exact pending request and owning intake required.");
+  if (operation.kind === "respond" && operation.decision === "once" && byId.get(entry.record.sourceSessionId)?.dynamic)
+    throw Object.assign(
+      new Error("native_private_query_prestart_contract_unqualified: dynamic private query authorization remains closed."),
+      { code: "native_private_query_prestart_contract_unqualified" }
+    );
+  const pending = await current(entry);
+  if (manager[symbol] !== state || state.entries.get(operation.key) !== entry || entry.record.state !== "pending" || state.auditFailed)
+    throw new Error("Exact pending request changed during native identity validation; reconcile without replay.");
+  if (operation.kind === "details") return { record: { ...entry.record }, request: pending };
+  if (operation.kind !== "respond" || operation.humanDecisionRecorded !== true || !["once", "deny"].includes(operation.decision ?? ""))
+    throw new Error("Recorded human one-request decision required; never auto-approve.");
+  if (operation.decision !== "deny" && entry.record.cardOnly) throw new Error("Claude requires the original card; intake cannot impersonate its origin.");
+  entry.record.state = "response-may-have-effects";
+  checkpoint({ ...entry.record });
+  await manager.respondToToolPermission(pending.requestId, operation.decision, void 0, "elsewhere");
+  const source = await owned(byId.get(entry.record.sourceSessionId));
+  if (source.pendingToolPermissions?.some((r) => r.requestId === pending.requestId))
+    throw new Error("Native decision did not settle; reconcile without replay.");
+  const lifecycle = state.dynamicLifecycle?.get(entry.record.sourceSessionId);
+  if (lifecycle) await lifecycle.decision(entry.record, pending, operation.decision);
+  entry.record.state = "native-request-settled";
+  checkpoint({ ...entry.record });
+  return { state: entry.record.state, nativeApproved: false, operationEffectVerified: false };
+}
+async function nativeClaudeAppendDynamicRoute(manager, route, verify, checkpoint, lifecycle) {
+  const state = manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.approvals.v1")];
+  if (!state || state.auditFailed || !state.byId || !state.byKey || !route.dynamic || !/^[a-f0-9]{64}$/.test(route.dynamic.planDigest) || route.dynamic.nativeParentId !== route.intakeSessionId)
+    throw new Error("Current qualified original approval listener required.");
+  const intake = state.byId.get(route.intakeSessionId);
+  if (!intake || intake.key !== route.intakeKey || intake.contextKey !== route.contextKey || !intake.key.includes("/intakes/"))
+    throw new Error("Dynamic approval route has no exact same-context original intake.");
+  await verify();
+  const raw = await manager.getSessionWhenLoaded(route.sessionId, "topolo-dynamic-route", { warnOnMiss: false });
+  const dto = await manager.getSession(route.sessionId);
+  if (!raw || !dto || raw.sessionId !== route.sessionId || raw.cwd !== route.cwd || raw.title !== route.title || dto.sessionId !== route.sessionId || dto.cwd !== route.cwd || dto.title !== route.title || raw.isArchived || dto.isArchived || raw.backend?.kind !== "local" || raw.backend.remoteTarget || raw.worktreePath || raw.worktreeLazy || raw.spawnedFrom?.sessionId !== route.intakeSessionId || raw.spawnedFrom?.sideSession !== true)
+    throw new Error("Actual dynamic child descriptor differs before route append.");
+  await verify();
+  if (manager[/* @__PURE__ */ Symbol.for("topolo.agent-pack.approvals.v1")] !== state || state.auditFailed)
+    throw new Error("Original native permission connection changed.");
+  const old = state.byId.get(route.sessionId);
+  if (old) {
+    if (JSON.stringify(old) !== JSON.stringify(route)) throw new Error("Native child route conflicts with an existing owner.");
+    return { state: "dynamic-route-current", generation: state.identity };
+  }
+  if (state.byKey.has(route.key)) throw new Error("Dynamic role key is already owned.");
+  checkpoint({ state: "dynamic-route-append", route });
+  state.byId.set(route.sessionId, route);
+  state.byKey.set(route.key, route);
+  state.dynamicRoutes ??= /* @__PURE__ */ new Map();
+  state.dynamicRoutes.set(route.sessionId, route);
+  if (lifecycle) {
+    state.dynamicLifecycle ??= /* @__PURE__ */ new Map();
+    state.dynamicLifecycle.set(route.sessionId, lifecycle);
+  }
+  return { state: "dynamic-route-appended", generation: state.identity, pendingRequestsPreserved: true };
+}
+async function nativeClaudeLaneControl(net, fs, manager, descriptor, token, invoke, qualify, checkpoint) {
+  if (!/^[a-f0-9]{64}$/.test(token) || !/^[a-f0-9]{64}$/.test(descriptor.identity) || !/^[a-z0-9][a-z0-9-]*$/.test(descriptor.laneId) || !Number.isSafeInteger(descriptor.pid) || descriptor.pid < 1)
+    throw new Error("Exact private lane native control identity required.");
+  const symbol = /* @__PURE__ */ Symbol.for("topolo.agent-pack.dynamic-controls.v1");
+  manager[symbol] ??= /* @__PURE__ */ new Map();
+  const controls = manager[symbol];
+  if (controls.has(descriptor.laneId) || fs.existsSync(descriptor.socket)) throw new Error("Own native lane control already exists; no takeover.");
+  qualify();
+  const control = { active: 0, descriptor, server: null, closed: false };
+  const allowed = /* @__PURE__ */ new Set(["read", "context-start", "context-read", "fixture-start", "fixture-read", "retire", "approval-list", "approval-details", "approval-respond", "close"]);
+  const server = net.createServer((connection) => {
+    let text = "";
+    let dispatched = false;
+    connection.setEncoding("utf8");
+    connection.setTimeout(24e4, () => connection.destroy());
+    connection.on("error", () => connection.destroy());
+    connection.on("data", async (chunk) => {
+      if (dispatched) return;
+      text += chunk;
+      if (Buffer.byteLength(text) > 65536) {
+        dispatched = true;
+        connection.destroy();
+        return;
+      }
+      if (!text.includes("\n")) return;
+      dispatched = true;
+      control.active++;
+      try {
+        qualify();
+        const request = JSON.parse(text);
+        if (Object.keys(request).sort().join() !== "identity,operation,pid,token" || request.token !== token || request.pid !== descriptor.pid || request.identity !== descriptor.identity)
+          throw new Error("Private native lane control authentication differs.");
+        const operation = request.operation;
+        const fields = operation?.kind === "approval-respond" ? ["kind", "key", "intake", "fingerprint", "decision", "humanDecisionRecorded"] : operation?.kind === "approval-details" ? ["kind", "key", "intake", "fingerprint"] : ["context-start", "context-read", "fixture-start"].includes(operation?.kind) ? ["kind", "operationId"] : ["kind"];
+        if (!operation || !allowed.has(operation.kind) || Object.keys(operation).some((k) => !fields.includes(k))) throw new Error("Closed private lane operation required.");
+        if (operation.kind === "close" && control.active !== 1) throw new Error("Own native control has other in-flight operations.");
+        const result = await invoke(operation);
+        const encoded = JSON.stringify({ result }) + "\n";
+        if (Buffer.byteLength(encoded) > 1048576) throw new Error("Bounded private native lane reply exceeded.");
+        connection.end(encoded);
+        if (operation.kind === "close") connection.once("close", () => server.close(() => {
+          control.closed = true;
+          controls.delete(descriptor.laneId);
+          checkpoint({ state: "normal-own-lane-control-closed", laneId: descriptor.laneId });
+          if (fs.existsSync(descriptor.socket)) {
+            const current = fs.lstatSync(descriptor.socket);
+            if (current.ino === control.inode && current.uid === control.uid) fs.unlinkSync(descriptor.socket);
+          }
+        }));
+      } catch (error) {
+        connection.end(JSON.stringify({ error: error instanceof Error ? error.message : "Native lane control 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);
+    const stat = fs.lstatSync(descriptor.socket);
+    control.inode = stat.ino;
+    control.uid = stat.uid;
+    checkpoint({ state: "private-native-lane-control-ready", ...descriptor });
+    controls.set(descriptor.laneId, control);
+  } catch (error) {
+    await new Promise((done) => server.close(() => done()));
+    throw error;
+  }
+  return { state: "private-native-lane-control-ready", ...descriptor };
+}
+
+// src/lib/claude-pack-backend.ts
+var CLAUDE_NATIVE_QUALIFIER = {
+  version: "2.37337.1",
+  manager: "index.chunk-BolytlRP.js",
+  sidebar: "index.chunk-BoQoqlAs.js",
+  hashes: {
+    "index.chunk-BolytlRP.js": "e387edfb06a34a59d99b54c04365f6e32d0108e8710124b4d1a628eea726d030",
+    "index.chunk-BoQoqlAs.js": "5c07a7e836d98dcd6afcfc2a62619e71d173a136ecb9af847716ea377b58b1df",
+    "index.chunk-BWk6pVUt.js": "f7d74e113f34761a675816fe2abf65b3ddc190327ee7623d9c822f7b59cceaca"
+  }
+};
+function validateInspectorEndpoint(endpoint) {
+  const url = new URL(endpoint);
+  if (url.protocol !== "ws:" || url.hostname !== "127.0.0.1" || !url.port || url.username || url.password || url.search || url.hash || !/^\/[0-9a-f-]{36}$/.test(url.pathname))
+    throw new Error("An explicit ws://127.0.0.1:<port>/<inspector UUID> endpoint is required.");
+  return url.href;
+}
+function snapshotClaudeMarkdown(root, fs, crypto, path) {
+  const inventory = {};
+  const visit = (directory) => {
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Owned context directory is not regular: " + directory);
+    for (const name of fs.readdirSync(directory).sort()) {
+      const file = path.resolve(directory, name);
+      const entry = fs.lstatSync(file);
+      if (entry.isSymbolicLink()) throw new Error("Owned context must not follow symlinks: " + file);
+      if (entry.isDirectory()) visit(file);
+      else if (/\.md$/i.test(name)) {
+        if (!entry.isFile()) throw new Error("Owned Markdown context is not a regular file: " + file);
+        inventory[file] = crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+      }
+    }
+  };
+  visit(root);
+  return inventory;
+}
+function prepareClaudeNativePlan(store, pack, policyPath, mode = "configure") {
+  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"));
+  const policy = JSON.parse(readFileSync(policyPath, "utf8"));
+  if (state.harness !== "claude" || policy.format !== "topolo-agent-execution-policy" || policy.pack !== pack)
+    throw new Error("Claude state and reviewed policy must name the same pack.");
+  const records = state.agents.filter((a) => a.pack === pack);
+  if (!records.length || records.length !== policy.agents.length) throw new Error("Reviewed policy must cover the complete installed roster.");
+  const members = [];
+  const context = {};
+  const roleContextFiles = {};
+  const contextInventories = {};
+  const captureMarkdown = (cwd) => {
+    contextInventories[cwd] = snapshotClaudeMarkdown(cwd, filesystem, cryptography, paths);
+    Object.assign(context, contextInventories[cwd]);
+  };
+  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")
+      throw new Error("Reviewed policy does not match adopted role: " + record.key);
+    const role = matches[0];
+    const settings = role.harnesses.claude.nativeSettings;
+    const cwd = realpathSync(record.workspace);
+    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] = createHash("sha256").update(readFileSync(charter)).digest("hex");
+    context[transcript] = createHash("sha256").update(readFileSync(transcript)).digest("hex");
+    roleContextFiles[record.desktopSessionId] = [charter, transcript];
+    members.push({
+      key: record.key,
+      sessionId: record.desktopSessionId,
+      cwd,
+      title: record.title,
+      group: record.pinnedRequested ? null : role.sidebar.group,
+      pinned: record.pinnedRequested === true,
+      model: settings.model,
+      effort: settings.effortLevel,
+      permissionMode: settings.permissions.defaultMode,
+      ...policy.installationConsent || settings.permissions.defaultMode === "bypassPermissions" ? {
+        permissionConsent: qualifyPermissionConsent(policy, record.key, records, settings.permissions.defaultMode === "bypassPermissions")
+      } : {}
+    });
+  }
+  for (const file of [resolve(root, "claude/state.json"), realpathSync(policyPath)])
+    context[file] = createHash("sha256").update(readFileSync(file)).digest("hex");
+  const activePath = resolve(root, "claude/active.json");
+  const active = existsSync(activePath) ? JSON.parse(readFileSync(activePath, "utf8")) : null;
+  const target = new Set(members.map((m) => m.key));
+  const outgoing = [];
+  if (active) {
+    if (!Array.isArray(active.keys) || new Set(active.keys).size !== active.keys.length) throw new Error("Invalid verified active roster.");
+    for (const key of active.keys.filter((key2) => !target.has(key2))) {
+      if (mode !== "switch") throw new Error("Use a native switch to replace the verified active roster.");
+      const candidates = state.agents.filter((a) => a.key === key && a.importState === "desktop-adopted");
+      if (candidates.length !== 1) throw new Error("Outgoing role has no unique owned adoption record.");
+      const record = candidates[0];
+      const cwd = realpathSync(record.workspace);
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(record.pack)) throw new Error("Invalid outgoing pack name.");
+      if (!cwd.startsWith(resolve(root, "claude/workspaces", record.pack) + sep)) throw new Error("Outgoing workspace is outside the owned pack.");
+      captureMarkdown(cwd);
+      for (const file of [resolve(cwd, "CLAUDE.md"), realpathSync(record.transcript)])
+        context[file] = createHash("sha256").update(readFileSync(file)).digest("hex");
+      outgoing.push({ key, sessionId: record.desktopSessionId, cwd, title: record.title });
+    }
+  } else if (mode === "switch") throw new Error("Configure and verify an initial active roster before switching.");
+  const approvalRoutes = members.filter((m) => m.permissionConsent).map((m) => {
+    const intake = members.find((i) => i.key === m.permissionConsent.intakeKey);
+    if (!intake) throw new Error("Owning intake is not in the native roster.");
+    return {
+      key: m.key,
+      sessionId: m.sessionId,
+      cwd: m.cwd,
+      title: m.title,
+      ...m.permissionConsent,
+      intakeSessionId: intake.sessionId
+    };
+  });
+  return {
+    members,
+    outgoing,
+    context,
+    contextInventories,
+    roleContextFiles,
+    globalContextFiles: [resolve(root, "claude/state.json"), realpathSync(policyPath)],
+    approvalRoutes,
+    installationConsent: policy.installationConsent,
+    libraryRoot: root,
+    sourceRevision: policy.sourceRevision,
+    mode,
+    activeBefore: active
+  };
+}
+function verifyClaudePlanContext(plan, members, fs, crypto, path, snapshotMarkdown) {
+  if (!plan.contextInventories || !Object.keys(plan.contextInventories).length) throw new Error("Complete context inventory proof is unavailable.");
+  if (members && (!plan.roleContextFiles || !plan.globalContextFiles?.length)) throw new Error("Scoped role context proof is unavailable.");
+  const selected = members ?? plan.members;
+  if (new Set(selected.map((m) => m.sessionId)).size !== selected.length || selected.some((m) => !plan.members.some((p) => p.sessionId === m.sessionId && p.key === m.key && p.cwd === m.cwd && p.title === m.title)))
+    throw new Error("Scoped context identity differs from the complete roster.");
+  const roots = members ? selected.map((m) => m.cwd) : Object.keys(plan.contextInventories);
+  for (const root of roots) {
+    const inventory = plan.contextInventories[root];
+    if (!inventory || JSON.stringify(snapshotMarkdown(root, fs, crypto, path)) !== JSON.stringify(inventory))
+      throw new Error("Context or transcript changed during configuration: Markdown inventory " + root);
+  }
+  const files = members ? [...plan.globalContextFiles, ...selected.flatMap((m) => {
+    const files2 = plan.roleContextFiles[m.sessionId];
+    if (!files2?.length) throw new Error("Scoped role context proof is unavailable.");
+    return files2;
+  })] : Object.keys(plan.context);
+  for (const file of files)
+    if (!plan.context[file] || crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") !== plan.context[file])
+      throw new Error("Context or transcript changed during configuration: " + file);
+}
+function qualifyPermissionConsent(policy, key, records, full) {
+  const consent = policy.installationConsent;
+  const intakeKey = consent?.intakeRoutes?.[key];
+  if (consent?.format !== "topolo-pack-installation-consent" || consent.schemaVersion !== 1 || consent.authority !== "local-installation-consent" || consent.approved !== true || consent.pack !== policy.pack || typeof consent.contextKey !== "string" || !/^org:.+$/.test(consent.contextKey) || !consent.principalId || !["manual", "role-default", "full-access"].includes(consent.profile) || full && (consent.overrides?.[key] ?? consent.profile) !== "full-access" || !records.some((record) => record.key === intakeKey && record.key.includes("/intakes/")))
+    throw new Error("Explicit organization-bound full access and owned intake consent required.");
+  return { contextKey: consent.contextKey, intakeKey };
+}
+function nativePackExpression(pid, plan, journal, apply) {
+  if (!Number.isSafeInteger(pid) || pid < 1) throw new Error("Explicit Claude main-process PID required.");
+  const qualifier = CLAUDE_NATIVE_QUALIFIER;
+  const here = dirname(fileURLToPath(import.meta.url));
+  const smokeSource = [resolve(here, "../../agent-packs/src"), resolve(here, "../agent-packs/src")].find(existsSync);
+  if (!smokeSource) throw new Error("Bundled owned smoke source unavailable.");
+  return `(async () => {
+    const expected = ${JSON.stringify({ pid, qualifier, journal, apply })};
+    if (process.pid !== expected.pid || typeof process.getBuiltinModule !== 'function') throw new Error('Claude process identity or Node runtime differs.');
+    const load = process.getBuiltinModule('module').createRequire(process.resourcesPath + '/app.asar/package.json');
+    if (load('electron').app.getVersion() !== expected.qualifier.version) throw new Error('Unqualified Claude Desktop version.');
+    const fs = load('node:fs'), crypto = load('node:crypto'), path = load('node:path');
+    const base = process.resourcesPath + '/app.asar/.vite/build/';
+    for (const [file, hash] of Object.entries(expected.qualifier.hashes)) {
+      if (crypto.createHash('sha256').update(fs.readFileSync(base + file)).digest('hex') !== hash) throw new Error('Claude native module hash changed: ' + file);
+    }
+    const manager = load(base + expected.qualifier.manager).claudeCodeSessionManager;
+    const transport = load(base + expected.qualifier.sidebar);
+    const checkpoint = value => {
+      const fd = fs.openSync(expected.journal, 'a');
+      try { fs.writeSync(fd, JSON.stringify(value) + '\\n'); fs.fsyncSync(fd); } finally { fs.closeSync(fd); }
+    };
+    const context = ${JSON.stringify(plan.context)};
+    const inventories = ${JSON.stringify(plan.contextInventories)};
+    const snapshotMarkdown = (${snapshotClaudeMarkdown.toString()});
+    const contextPlan = {context, contextInventories: inventories, members: ${JSON.stringify(plan.members)},
+      roleContextFiles: ${JSON.stringify(plan.roleContextFiles)}, globalContextFiles: ${JSON.stringify(plan.globalContextFiles)}};
+    const verifyContext = members => (${verifyClaudePlanContext.toString()})(contextPlan, members, fs, crypto, path, snapshotMarkdown);
+    const result = await (${nativeClaudePackOperation.toString()})(manager,
+      value => transport.P(value, transport.M),
+      { members: ${JSON.stringify(plan.members)}, outgoing: ${JSON.stringify(plan.outgoing)},
+        operationId: ${JSON.stringify(plan.operationId)}, mode: ${JSON.stringify(plan.recovery ? "recover" : plan.mode)},
+        noEffects: ${JSON.stringify(plan.noEffects)},
+        deadline: Date.now() + 45000 }, expected.apply, checkpoint, verifyContext);
+    ${plan.approvalRoutes.length ? `const routes = ${JSON.stringify(plan.approvalRoutes)};
+      const fingerprint = value => crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+        const qualifyNative = () => {
+          if (process.pid !== expected.pid || load('electron').app.getVersion() !== expected.qualifier.version) throw new Error('Native process changed.');
+          for (const [file, hash] of Object.entries(expected.qualifier.hashes))
+            if (crypto.createHash('sha256').update(fs.readFileSync(base + file)).digest('hex') !== hash) throw new Error('Native module changed.');
+        };
+       const smokeIdentity = fingerprint({pid: expected.pid, qualifier: expected.qualifier, routes});
+       const invoke = op => ['smoke-start', 'smoke-read'].includes(op.kind) ?
+         (${nativeClaudeOwnedSmokeOperation.toString()})(manager, ${JSON.stringify(plan.members)}, op,
+           (action, payload) => (${runClaudeSmokeHelper.toString()})(${JSON.stringify(plan.libraryRoot)}, action, payload,
+             ${JSON.stringify(realpathSync(smokeSource))}, load('node:child_process').spawn), fingerprint, smokeIdentity, qualifyNative) :
+         (${nativeClaudeApprovalOperation.toString()})(manager, routes, op, fingerprint,
+        row => checkpoint({kind: 'approval', ...row}),
+        fs.readFileSync(expected.journal, 'utf8').split('\\n').filter(Boolean).map(line => JSON.parse(line)));
+      if (expected.apply) {
+        const control = ${JSON.stringify(plan.control)};
+        if (!control) throw new Error('Owned native control setup is unavailable.');
+        const identity = fingerprint(routes);
+        const current = manager[Symbol.for('topolo.agent-pack.approval-control.v1')];
+        const listener = manager[Symbol.for('topolo.agent-pack.approvals.v1')];
+        const incremental = ${JSON.stringify(plan.mode === "configure" && !plan.recovery)};
+        const unchanged = listener?.identity === identity && listener.listener && !listener.auditFailed &&
+          current?.descriptor.pid === expected.pid && current.descriptor.identity === identity &&
+          current.descriptor.socket === control.socket && current.server?.listening === true && !current.failure;
+        if (!incremental) {
+          result.approvalRouting = await invoke({kind: 'install'});
+          const stat = fs.lstatSync(control.secretPath);
+          if (!stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid() || (stat.mode & 63)) throw new Error('Unowned native control secret.');
+          const secret = JSON.parse(fs.readFileSync(control.secretPath, 'utf8'));
+          result.approvalRouting.control = await (${nativeClaudeApprovalControl.toString()})(manager,
+            {socket: control.socket, pid: expected.pid, identity}, secret.token,
+            load('node:net'), fs, invoke, qualifyNative, checkpoint);
+        } else if (unchanged) {
+          // Re-attest the owned listener/control; do not replace matching hooks
+          // or interrupt an in-flight request merely to configure idle settings.
+          result.approvalRouting = {state: 'native-approval-listener-installed', roles: routes.length,
+            identity, control: current.descriptor, unchanged: true};
+        } else {
+          qualifyNative();
+          const deferred = [];
+          for (const route of routes) {
+            const descriptor = await manager.getSessionWhenLoaded(route.sessionId, 'topolo-agent-pack-approval', {warnOnMiss: false});
+            const session = await manager.getSession(route.sessionId);
+            if (!descriptor || descriptor.sessionId !== route.sessionId || descriptor.cwd !== route.cwd || descriptor.title !== route.title ||
+                descriptor.isArchived || descriptor.backend?.kind !== 'local' || descriptor.backend.remoteTarget || descriptor.worktreePath ||
+                descriptor.worktreeLazy || descriptor.spawnedFrom || !session || session.sessionId !== route.sessionId ||
+                session.cwd !== route.cwd || session.title !== route.title || session.isArchived)
+              throw new Error('Native approval route ownership changed.');
+            if (session.pendingToolPermissions?.length || descriptor.pendingToolPermissions?.length)
+              deferred.push({key: route.key, fields: ['intakeHooks'], reason: 'pending-permissions'});
+          }
+          if (current?.active || current?.failure || listener?.auditFailed ||
+              (listener && listener.identity !== identity) ||
+              (current && (current.descriptor.pid !== expected.pid || current.descriptor.identity !== identity)))
+            for (const route of routes) deferred.push({key: route.key, fields: ['intakeHooks'], reason: 'existing-control-custody'});
+          if (deferred.length) {
+            result.routingDeferred = deferred;
+            result.state = 'native-settings-partial';result.complete = false;
+            checkpoint({kind: 'routing-deferred', deferred, at: Date.now()});
+          } else {
+            verifyContext(result.after.filter(row => !row.busy).map(row => contextPlan.members.find(m => m.sessionId === row.sessionId)));
+            result.approvalRouting = await invoke({kind: 'install'});
+            const stat = fs.lstatSync(control.secretPath);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid() || (stat.mode & 63)) throw new Error('Unowned native control secret.');
+            const secret = JSON.parse(fs.readFileSync(control.secretPath, 'utf8'));
+            result.approvalRouting.control = await (${nativeClaudeApprovalControl.toString()})(manager,
+              {socket: control.socket, pid: expected.pid, identity}, secret.token,
+              load('node:net'), fs, invoke, qualifyNative, checkpoint);
+          }
+        }
+      } else if (${JSON.stringify(plan.recovery === true && !plan.noEffects)}) {
+        const current = manager[Symbol.for('topolo.agent-pack.approval-control.v1')];
+        if (!current || current.descriptor.pid !== expected.pid || current.descriptor.identity !== fingerprint(routes))
+          throw new Error('Native intake control is not reconciled.');
+        result.approvalRouting = {state: 'native-approval-listener-installed', roles: routes.length, control: current.descriptor};
+      }` : ""}
+    return result;
+  })()`;
+}
+function evaluateClaudeMain(endpoint, expression, socketFactory = (url) => new WebSocket(url)) {
+  const url = validateInspectorEndpoint(endpoint);
+  return new Promise((resolveResult, reject) => {
+    const socket = socketFactory(url);
+    let finished = false;
+    const finish = (error, result) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      socket.close();
+      if (error) reject(error);
+      else resolveResult(result);
+    };
+    const timer = setTimeout(() => finish(new Error("Claude backend timed out; reconcile the journal before retry.")), 55e3);
+    socket.addEventListener("open", () => socket.send(JSON.stringify({
+      id: 1,
+      method: "Runtime.evaluate",
+      params: { expression, awaitPromise: true, returnByValue: true }
+    })));
+    socket.addEventListener("message", (event) => {
+      try {
+        const reply = JSON.parse(String(event.data));
+        if (reply.id !== 1) return;
+        if (reply.error || reply.result?.exceptionDetails)
+          finish(new Error(reply.error?.message || reply.result.exceptionDetails.exception?.description || "Native operation failed; reconcile the journal."));
+        else finish(void 0, reply.result.result.value);
+      } catch {
+        finish(new Error("Invalid Claude backend reply; reconcile the journal."));
+      }
+    });
+    socket.addEventListener("error", () => finish(new Error("Claude backend connection failed.")));
+    socket.addEventListener("close", () => finish(new Error("Claude backend disconnected; reconcile the journal.")));
+  });
+}
+async function lockClaudeLibrary(root) {
+  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"] });
+  await new Promise((done, fail) => {
+    let ready = false;
+    const timer = setTimeout(() => {
+      child.kill();
+      fail(new Error("Pack library lock timed out."));
+    }, 5e3);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      fail(error);
+    });
+    child.stdout.once("data", (data) => {
+      if (String(data).trim() === "locked") {
+        ready = true;
+        clearTimeout(timer);
+        done();
+      }
+    });
+    child.once("exit", () => {
+      clearTimeout(timer);
+      if (!ready) fail(new Error("Another operation owns the pack library, or its lock is unavailable."));
+    });
+    child.stderr.resume();
+  });
+  return async () => {
+    await new Promise((done) => {
+      if (child.exitCode !== null || child.signalCode !== null) done();
+      else {
+        child.once("exit", () => done());
+        child.stdin.end();
+      }
+    });
+  };
+}
+function durableRecord(path, value, flag = "a") {
+  const fd = openSync(path, flag, 384);
+  try {
+    writeFileSync(fd, JSON.stringify(value) + "\n");
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function syncDirectory(path) {
+  const fd = openSync(path, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function verifyPlanContext(plan, members) {
+  verifyClaudePlanContext(plan, members, filesystem, cryptography, paths, snapshotClaudeMarkdown);
+}
+function verifyClaudeOrganizationPolicy(root, pack, consent, run = spawnSync, locate = existsSync) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const bundled = [resolve(here, "../../agent-packs/src"), resolve(here, "../agent-packs/src")].find(locate);
+  if (!bundled) throw new Error("Bundled organization policy loader unavailable.");
+  const source = realpathSync(bundled);
+  const script = 'import json,sys\nsys.path.insert(0,sys.argv[4])\nfrom topolo_agent_pack import permissions,topolo\nfrom topolo_agent_pack.storage import Library\nlib=Library(sys.argv[1]);manifest,_=lib.load(sys.argv[2]);c=permissions.load(lib,sys.argv[2],manifest["agents"])\nif c!=json.loads(sys.argv[3]):raise RuntimeError("Installation consent changed")\np,proof=topolo.organization_execution_policy(topolo.Client(c["environment"],c["contextKey"]),c,manifest["agents"],c.get("agentWorkspaceId"))\npermissions.authorize_native_scope(proof)\nprint(json.dumps(proof))';
+  const result = run(
+    "python3",
+    ["-I", "-B", "-c", script, root, pack, JSON.stringify(consent), source],
+    { encoding: "utf8", timeout: 2e5, cwd: source, env: { ...process.env } }
+  );
+  if (result.error || result.status !== 0) throw new Error("Fresh authenticated organization policy qualification failed; no native permission widening.");
+  const proof = JSON.parse(result.stdout);
+  if (proof.profileCeilingVerified !== true || proof.contextKey !== consent.contextKey || proof.scopePolicyMode !== "unrestricted" || proof.toolActionRestrictionRequested !== false)
+    throw new Error("Organization profile ceiling proof differs.");
+  return proof;
+}
+async function configureClaudePack(options, evaluate = evaluateClaudeMain, qualify = verifyClaudeOrganizationPolicy) {
+  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 {
+    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.");
+    if (!recovering && existsSync(markerPath)) throw new Error("An unresolved Claude operation requires read-only recovery before another operation.");
+    const directory = resolve(root, "claude/journals");
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    if (lstatSync(directory).isSymbolicLink()) throw new Error("Claude journal directory must not be a symlink.");
+    const operationId = randomUUID();
+    let plan;
+    let journal;
+    let marker;
+    if (recovering) {
+      if (!existsSync(markerPath) || lstatSync(markerPath).isSymbolicLink()) throw new Error("No owned unresolved Claude operation is available.");
+      marker = JSON.parse(readFileSync(markerPath, "utf8"));
+      journal = realpathSync(marker.journal);
+      if (!journal.startsWith(realpathSync(directory) + sep)) throw new Error("Recovery journal is outside the owned library.");
+      const lines = readFileSync(journal, "utf8").split("\n").filter(Boolean);
+      const line = lines[0];
+      if (createHash("sha256").update(line).digest("hex") !== marker.planHash) throw new Error("Recovery plan identity changed.");
+      const record = JSON.parse(line);
+      if (record.pack !== options.pack || record.operationId !== marker.operationId || !record.apply) throw new Error("Recovery pack or operation identity differs.");
+      plan = { ...record, approvalRoutes: record.approvalRoutes ?? [], recovery: true, noEffects: marker.format === 2 && marker.dispatchState === "not-dispatched" && !lines.map((line2) => JSON.parse(line2)).some((r) => r.kind === "attempt") };
+    } else {
+      plan = { ...prepareClaudeNativePlan(root, options.pack, options.policy, options.mode === "switch" ? "switch" : "configure"), operationId };
+      if (options.apply && plan.approvalRoutes.length) {
+        const connectionPath = resolve(root, "claude/approval-connection.json");
+        if (plan.mode === "configure" && existsSync(connectionPath)) {
+          const entry = lstatSync(connectionPath);
+          if (!entry.isFile() || entry.isSymbolicLink() || typeof process.getuid !== "function" || entry.uid !== process.getuid() || entry.mode & 63)
+            throw new Error("Unowned native approval connection.");
+          const connection = JSON.parse(readFileSync(connectionPath, "utf8"));
+          if (connection.pid === options.pid && connection.pack === options.pack && JSON.stringify(connection.routes) === JSON.stringify(plan.approvalRoutes) && JSON.stringify(connection.installationConsent) === JSON.stringify(plan.installationConsent)) {
+            if (typeof connection.secretPath !== "string" || typeof connection.socket !== "string" || !resolve(connection.secretPath).startsWith(realpathSync(resolve(root, "claude/private")) + sep) || realpathSync(connection.secretPath) !== resolve(connection.secretPath) || dirname(resolve(connection.socket)) !== resolve("/tmp", "topolo-claude-pack-" + createHash("sha256").update(root).digest("hex").slice(0, 16)))
+              throw new Error("Native approval connection is outside owned control paths.");
+            const secret = lstatSync(connection.secretPath);
+            if (!secret.isFile() || secret.isSymbolicLink() || typeof process.getuid !== "function" || secret.uid !== process.getuid() || secret.mode & 63)
+              throw new Error("Unowned native control secret.");
+            plan.control = { socket: connection.socket, secretPath: connection.secretPath };
+          }
+        }
+        if (!plan.control) {
+          const directory2 = resolve(root, "claude/private");
+          mkdirSync(directory2, { recursive: true, mode: 448 });
+          const socketDirectory = resolve("/tmp", "topolo-claude-pack-" + createHash("sha256").update(root).digest("hex").slice(0, 16));
+          mkdirSync(socketDirectory, { recursive: true, mode: 448 });
+          for (const path of [directory2, socketDirectory]) {
+            const stat = lstatSync(path);
+            if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 63)
+              throw new Error("Native control directory must be owned and private.");
+          }
+          plan.control = { socket: resolve(socketDirectory, operationId + ".sock"), secretPath: resolve(directory2, operationId + ".json") };
+          durableRecord(plan.control.secretPath, { token: randomBytes(32).toString("hex") }, "wx");
+          syncDirectory(directory2);
+        }
+      }
+      journal = resolve(directory, operationId + ".jsonl");
+      const record = { kind: "plan", pack: options.pack, ...plan, apply: options.apply };
+      durableRecord(journal, record, "wx");
+      marker = { format: 2, dispatchState: "not-dispatched", operationId, journal, planHash: createHash("sha256").update(JSON.stringify(record)).digest("hex") };
+      if (options.apply) durableRecord(markerPath, marker, "wx");
+      syncDirectory(directory);
+      syncDirectory(resolve(root, "claude"));
+    }
+    try {
+      const incremental = !recovering && plan.mode === "configure";
+      verifyPlanContext(plan, incremental ? [] : void 0);
+      const organizationPolicy = options.apply && plan.approvalRoutes.length ? qualify(root, options.pack, plan.installationConsent) : null;
+      if (options.apply) {
+        const dispatched = { ...marker, dispatchState: "may-have-effects" };
+        const temporaryMarker = resolve(root, "claude/native-dispatch-" + operationId + ".json");
+        durableRecord(temporaryMarker, dispatched, "wx");
+        renameSync(temporaryMarker, markerPath);
+        syncDirectory(resolve(root, "claude"));
+        marker = dispatched;
+      }
+      const result = await evaluate(options.endpoint, nativePackExpression(options.pid, plan, journal, options.apply));
+      if (incremental && result.contextVerifiedSessionIds !== void 0) {
+        if (!Array.isArray(result.contextVerifiedSessionIds) || new Set(result.contextVerifiedSessionIds).size !== result.contextVerifiedSessionIds.length || result.contextVerifiedSessionIds.some((id) => !plan.members.some((m) => m.sessionId === id)))
+          throw new Error("Native scoped context identities differ.");
+        const observations = result.busyObservations ?? [];
+        if (!Array.isArray(observations) || observations.some((row) => !plan.members.some((m) => m.key === row.key && m.sessionId === row.sessionId) || !Array.isArray(row.reasons) || !row.reasons.length || row.reasons.some((reason) => !["running", "starting", "losable", "pending-permissions"].includes(reason))))
+          throw new Error("Native busy context attestation differs.");
+        for (let i = 0; i < plan.members.length; i++)
+          if (!result.contextVerifiedSessionIds.includes(plan.members[i].sessionId) && result.after?.[i]?.busy !== true && !observations.some((row) => row.sessionId === plan.members[i].sessionId))
+            throw new Error("Native result omits idle context qualification.");
+      }
+      const contextMembers = incremental && Array.isArray(result.after) ? plan.members.filter((m, i) => result.after[i]?.busy !== true && (result.contextVerifiedSessionIds === void 0 || result.contextVerifiedSessionIds.includes(m.sessionId))) : void 0;
+      verifyPlanContext(plan, contextMembers);
+      if (options.apply || recovering) {
+        if (plan.noEffects) {
+          if (result.state !== "native-reconciled-no-effects" || result.nativeEffectsReplayed !== false || result.after?.length !== plan.members.length || result.after.some((actual, i) => ["key", "sessionId", "cwd", "title"].some((key) => actual[key] !== plan.members[i][key])))
+            throw new Error("No-effect recovery has no qualified native acknowledgement.");
+          const activePath2 = resolve(root, "claude/active.json");
+          const current2 = existsSync(activePath2) ? JSON.parse(readFileSync(activePath2, "utf8")) : null;
+          if (JSON.stringify(current2) !== JSON.stringify(plan.activeBefore)) throw new Error("Active roster changed during no-effect recovery.");
+          durableRecord(journal, { kind: "context-verified", context: plan.context, nativeEffects: "none-attempted" });
+          if (JSON.stringify(JSON.parse(readFileSync(markerPath, "utf8"))) !== JSON.stringify(marker)) throw new Error("Recovery marker identity changed.");
+          unlinkSync(markerPath);
+          syncDirectory(resolve(root, "claude"));
+          return { ...result, journal, contextPreserved: true };
+        }
+        if (incremental && result.state === "native-settings-partial") {
+          const settings = ["group", "pinned", "model", "effort", "permissionMode"];
+          if (result.after?.length !== plan.members.length || !Array.isArray(result.deferred) || !result.deferred.length && !result.routingDeferred?.length) throw new Error("Native partial result has no qualified complete roster.");
+          if (new Set(result.deferred.map((d) => d.sessionId)).size !== result.deferred.length || result.deferred.some((d) => !plan.members.some((m) => m.key === d.key && m.sessionId === d.sessionId) || !Array.isArray(d.fields) || !d.fields.length || new Set(d.fields).size !== d.fields.length || d.fields.some((field) => !settings.includes(field)) || !Array.isArray(d.reasons) || !d.reasons.length || d.reasons.some((reason) => !["running", "starting", "losable", "pending-permissions"].includes(reason))))
+            throw new Error("Native deferred identity or fields differ.");
+          if (result.routingDeferred !== void 0 && (!Array.isArray(result.routingDeferred) || result.routingDeferred.some((d) => !plan.approvalRoutes.some((r) => r.key === d.key) || JSON.stringify(d.fields) !== JSON.stringify(["intakeHooks"]) || !["pending-permissions", "existing-control-custody"].includes(d.reason))))
+            throw new Error("Native deferred routing ownership differs.");
+          for (let i = 0; i < plan.members.length; i++) {
+            const wanted = plan.members[i], actual = result.after[i];
+            if (actual.archived !== false || ["key", "sessionId", "cwd", "title"].some((key) => actual[key] !== wanted[key]))
+              throw new Error("Native partial roster identity differs.");
+            const mismatch = settings.filter((key) => actual[key] !== wanted[key]);
+            const deferred = result.deferred.find((d) => d.sessionId === wanted.sessionId);
+            if (JSON.stringify(mismatch.slice().sort()) !== JSON.stringify((deferred?.fields ?? []).slice().sort()))
+              throw new Error("Native partial result hides an undeferred mismatch.");
+          }
+          const activePath2 = resolve(root, "claude/active.json");
+          const active2 = existsSync(activePath2) ? JSON.parse(readFileSync(activePath2, "utf8")) : null;
+          if (JSON.stringify(active2) !== JSON.stringify(plan.activeBefore)) throw new Error("Active roster changed during partial configuration.");
+          durableRecord(journal, {
+            kind: "partial-verified",
+            after: result.after,
+            deferred: result.deferred,
+            routingDeferred: result.routingDeferred ?? [],
+            appliedFields: result.appliedFields ?? [],
+            activeUnchanged: true
+          });
+          if (JSON.stringify(JSON.parse(readFileSync(markerPath, "utf8"))) !== JSON.stringify(marker)) throw new Error("Recovery marker identity changed.");
+          unlinkSync(markerPath);
+          syncDirectory(resolve(root, "claude"));
+          return {
+            ...result,
+            complete: false,
+            journal,
+            contextPreserved: contextMembers?.length === plan.members.length,
+            idleContextsVerified: contextMembers?.map((m) => m.key),
+            activeRosterUnchanged: true,
+            resume: "explicit-configure-only"
+          };
+        }
+        if (result.state !== (recovering ? "native-reconciled" : "native-settings-verified") || result.after?.length !== plan.members.length) throw new Error("Native result has no complete verified roster.");
+        for (let i = 0; i < plan.members.length; i++) {
+          const wanted = plan.members[i];
+          const actual = result.after[i];
+          if (actual.archived !== false || ["key", "sessionId", "cwd", "title", "group", "pinned", "model", "effort", "permissionMode"].some((key) => actual[key] !== wanted[key])) throw new Error("Native result settings do not match the reviewed roster.");
+        }
+        if (plan.outgoing.length && (result.outgoingAfter?.length !== plan.outgoing.length || result.outgoingAfter.some((actual, i) => actual.archived !== true || ["key", "sessionId", "cwd", "title"].some((key) => actual[key] !== plan.outgoing[i][key]))))
+          throw new Error("Native outgoing archive result does not match the reviewed roster.");
+        if (plan.approvalRoutes.length && (options.apply || recovering) && (result.approvalRouting?.state !== "native-approval-listener-installed" || result.approvalRouting.roles !== plan.members.length || result.approvalRouting.control?.pid !== options.pid || result.approvalRouting.control?.socket !== plan.control?.socket))
+          throw new Error("Complete native intake routing acknowledgement is unavailable.");
+        const activePath = resolve(root, "claude/active.json");
+        const current = existsSync(activePath) ? JSON.parse(readFileSync(activePath, "utf8")) : null;
+        const active = { operationId: plan.operationId, pack: options.pack, keys: plan.members.map((m) => m.key), sourceRevision: plan.sourceRevision };
+        if (JSON.stringify(current) !== JSON.stringify(plan.activeBefore) && JSON.stringify(current) !== JSON.stringify(active))
+          throw new Error("Verified active roster changed outside this operation.");
+        const temporary = resolve(root, "claude/active-" + plan.operationId + ".json");
+        if (existsSync(temporary)) {
+          if (lstatSync(temporary).isSymbolicLink() || readFileSync(temporary, "utf8") !== JSON.stringify(active) + "\n") throw new Error("Active commit identity changed.");
+        } else durableRecord(temporary, active, "wx");
+        renameSync(temporary, activePath);
+        syncDirectory(resolve(root, "claude"));
+        durableRecord(journal, { kind: "context-verified", context: plan.context, active });
+        if ((options.apply || recovering) && plan.approvalRoutes.length) {
+          const target = resolve(root, "claude/approval-connection.json");
+          const temporaryConnection = resolve(root, "claude/approval-connection-" + plan.operationId + ".json");
+          durableRecord(temporaryConnection, {
+            pid: options.pid,
+            socket: plan.control.socket,
+            secretPath: plan.control.secretPath,
+            identity: result.approvalRouting.control.identity,
+            pack: options.pack,
+            installationConsent: plan.installationConsent,
+            routes: plan.approvalRoutes,
+            journal,
+            organizationPolicy
+          }, "wx");
+          renameSync(temporaryConnection, target);
+          syncDirectory(resolve(root, "claude"));
+        }
+        if (JSON.stringify(JSON.parse(readFileSync(markerPath, "utf8"))) !== JSON.stringify(marker)) throw new Error("Recovery marker identity changed.");
+        unlinkSync(markerPath);
+        syncDirectory(resolve(root, "claude"));
+      } else durableRecord(journal, { kind: "context-verified", context: plan.context });
+      return {
+        ...result,
+        journal,
+        contextPreserved: !incremental || contextMembers?.length === plan.members.length,
+        ...incremental ? { idleContextsVerified: contextMembers?.map((m) => m.key) } : {}
+      };
+    } catch (error) {
+      durableRecord(journal, { kind: "recovery-required" });
+      throw new Error(`Claude configuration is incomplete. Reconcile ${journal}. ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } finally {
+    await 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."));
+  const script = 'import sys,json\nsys.path.insert(0,sys.argv[3])\nfrom topolo_agent_pack.storage import Library\nfrom topolo_agent_pack.live import OwnedSmoke\ns=OwnedSmoke(Library(sys.argv[1]),"claude")\np=json.loads(sys.stdin.read(16384))\na=sys.argv[2]\nr=s.prepare(**p) if a=="prepare" else s.arm(**p) if a=="arm" else s.mark(**p) if a=="mark" else s.verify(p["operation"]) if a=="verify" else s.read(p["operation"])\nprint(json.dumps(r))';
+  return new Promise((done, fail) => {
+    const child = launch("python3", ["-I", "-B", "-c", script, root, action, source], { stdio: ["pipe", "pipe", "pipe"] });
+    let output = "";
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      error ? fail(error) : done(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(new Error("Owned smoke helper timed out; reconcile without replay."));
+    }, 6e4);
+    child.stdout.setEncoding("utf8");
+    child.stderr.resume();
+    child.stdout.on("data", (data) => {
+      output += data;
+      if (Buffer.byteLength(output) > 1048576) {
+        child.kill("SIGTERM");
+        finish(new Error("Owned smoke evidence exceeds bounded transport."));
+      }
+    });
+    child.on("error", () => finish(new Error("Bundled owned smoke helper unavailable.")));
+    child.on("close", (code) => {
+      if (settled) return;
+      if (code !== 0) return finish(new Error("Owned smoke qualification refused; preserve its journal."));
+      try {
+        finish(void 0, JSON.parse(output));
+      } catch {
+        finish(new Error("Invalid owned smoke helper result."));
+      }
+    });
+    child.stdin.on("error", () => finish(new Error("Owned smoke helper input failed; reconcile without replay.")));
+    child.stdin.end(JSON.stringify(payload));
+  });
+}
+function requestClaudeApprovalControl(connection, operation, token, connect = createConnection) {
+  const parent = lstatSync(dirname(connection.socket));
+  const socket = lstatSync(connection.socket);
+  if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== process.getuid?.() || parent.mode & 63 || !socket.isSocket() || socket.uid !== process.getuid?.() || socket.mode & 63)
+    throw new Error("Unowned native control socket.");
+  return new Promise((done, fail) => {
+    const client = connect({ path: connection.socket });
+    let reply = "";
+    let finished = false;
+    const finish = (error, result) => {
+      if (finished) return;
+      finished = true;
+      client.destroy();
+      error ? fail(error) : done(result);
+    };
+    client.setEncoding("utf8");
+    client.setTimeout(connection.laneId ? 24e4 : operation.kind === "smoke-start" ? 6e4 : 1e4, () => finish(new Error("Native approval response timed out; reconcile without replay.")));
+    client.on("connect", () => client.write(JSON.stringify({ token, pid: connection.pid, identity: connection.identity, operation }) + "\n"));
+    client.on("data", (chunk) => {
+      reply += chunk;
+      if (Buffer.byteLength(reply) > 262144) return finish(new Error("Native approval response exceeds bounded transport."));
+      if (!reply.includes("\n")) return;
+      try {
+        const result = JSON.parse(reply);
+        finish(result.error ? new Error(result.error) : void 0, result.result);
+      } catch {
+        finish(new Error("Invalid native approval response."));
+      }
+    });
+    client.on("error", () => finish(new Error("Existing native approval control is unavailable.")));
+    client.on("close", () => finish(new Error("Native approval response was lost; reconcile without replay.")));
+  });
+}
+async function operateClaudeApprovals(options, request = requestClaudeApprovalControl, qualify = verifyClaudeOrganizationPolicy) {
+  const root = realpathSync(options.store);
+  const file = resolve(root, "claude/approval-connection.json");
+  if (lstatSync(file).isSymbolicLink()) throw new Error("Unowned approval connection.");
+  const connection = JSON.parse(readFileSync(file, "utf8"));
+  if (!Number.isSafeInteger(connection.pid) || connection.pid < 1 || !Array.isArray(connection.routes))
+    throw new Error("Unqualified native approval connection.");
+  if (options.kind === "respond" && options.decision === "once")
+    qualify(root, connection.pack, connection.installationConsent);
+  const journal = realpathSync(connection.journal);
+  if (!journal.startsWith(realpathSync(resolve(root, "claude/journals")) + sep)) throw new Error("Unowned approval journal.");
+  const privateDirectory = resolve(root, "claude/private");
+  const secretPath = realpathSync(connection.secretPath);
+  const stat = lstatSync(connection.secretPath);
+  if (!secretPath.startsWith(realpathSync(privateDirectory) + sep) || !stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid?.() || stat.mode & 63) throw new Error("Unowned native control secret.");
+  const secret = JSON.parse(readFileSync(secretPath, "utf8"));
+  if (!/^[a-f0-9]{64}$/.test(secret.token) || !/^[a-f0-9]{64}$/.test(connection.identity)) throw new Error("Native control identity is invalid.");
+  if (options.kind === "smoke-start" || options.kind === "smoke-read") return request(
+    connection,
+    {
+      kind: options.kind,
+      operationId: options.operationId,
+      ...options.kind === "smoke-start" ? { key: options.key, caseId: options.caseId } : {}
+    },
+    secret.token
+  );
+  return request(connection, {
+    kind: options.kind,
+    key: options.key,
+    intake: options.intake,
+    fingerprint: options.fingerprint,
+    decision: options.decision,
+    humanDecisionRecorded: options.humanDecisionRecorded
+  }, secret.token);
+}
+async function operateClaudeSmoke(options, request = requestClaudeApprovalControl) {
+  const fields = options.kind === "smoke-start" ? ["store", "kind", "operationId", "key", "caseId"] : ["store", "kind", "operationId"];
+  if (!["smoke-start", "smoke-read"].includes(options.kind) || Object.keys(options).some((k) => !fields.includes(k)) || !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(options.operationId) || options.kind === "smoke-start" && (!/^[a-z0-9-]+\/[a-z0-9-]+\/[a-z0-9-]+$/.test(options.key ?? "") || !["stg-context-memory-bytes", "stg-peer-ack", "prod-role-context-ack"].includes(options.caseId ?? "")))
+    throw new Error("Exact closed native smoke fields required.");
+  return operateClaudeApprovals(options, request);
+}
+function prepareClaudeDynamicLane(store, pack, policyPath, laneId) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(pack) || !/^[a-z0-9][a-z0-9-]*$/.test(laneId)) throw new Error("Exact pack and lane IDs required.");
+  const root = realpathSync(store);
+  const file = resolve(root, "dynamic-lanes/claude", laneId + ".json");
+  const owned = (path) => {
+    const info = lstatSync(path);
+    if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1 || info.uid !== process.getuid?.() || info.mode & 18)
+      throw new Error("Dynamic lane requires an owned regular context record.");
+    return path;
+  };
+  owned(file);
+  if (lstatSync(file).size > 131072) throw new Error("Dynamic lane record exceeds its schema bound.");
+  const record = JSON.parse(readFileSync(file, "utf8"));
+  const canonical = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
+  const digest = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+  if (record.format !== "topolo-dynamic-lane" || record.schemaVersion !== 1 || record.harness !== "claude" || record.laneId !== laneId || record.planDigest !== digest(record.plan) || record.creationReceiptDigest !== digest(record.creationReceipt) || typeof record.nativeTitle !== "string" || !record.nativeTitle || record.nativeTitle.length > 256 || record.plan.role.packId !== pack || record.plan.nativeParentId !== record.plan.intake.nativeId)
+    throw new Error("Durable dynamic child identity or plan digest differs.");
+  const stateFile = owned(resolve(root, "claude/state.json"));
+  const state = JSON.parse(readFileSync(stateFile, "utf8"));
+  const policyFile = owned(realpathSync(policyPath));
+  const policy = JSON.parse(readFileSync(policyFile, "utf8"));
+  if (state.harness !== "claude" || policy.format !== "topolo-agent-execution-policy" || policy.pack !== pack || policy.sourceRevision !== record.plan.role.packRevision || !policy.installationConsent)
+    throw new Error("Dynamic child source policy or organization-bound installation is stale.");
+  const context = {
+    [stateFile]: createHash("sha256").update(readFileSync(stateFile)).digest("hex"),
+    [policyFile]: createHash("sha256").update(readFileSync(policyFile)).digest("hex")
+  };
+  const inventories = {};
+  const fixed = (descriptor) => {
+    const rows = state.agents.filter((a) => a.key === descriptor.key && a.desktopSessionId === descriptor.nativeId && a.pack === pack && a.sourceRevision === policy.sourceRevision && a.importState === "desktop-adopted");
+    const settings = policy.agents.filter((r) => r.key === descriptor.key);
+    if (rows.length !== 1 || settings.length !== 1) throw new Error("Dynamic source has no unique current adopted role.");
+    const row = rows[0];
+    const cwd = realpathSync(row.workspace);
+    if (cwd !== descriptor.cwd || !cwd.startsWith(resolve(root, "claude/workspaces", pack) + sep) || canonical(settings[0].harnesses.claude.nativeSettings) !== canonical(descriptor.settings))
+      throw new Error("Dynamic source workspace or current fixed settings differ.");
+    const files = [resolve(cwd, "CLAUDE.md"), resolve(cwd, "topolo-connection.json"), resolve(cwd, ".mcp.json")];
+    const hashes = {};
+    for (const f of files) hashes[owned(f)] = createHash("sha256").update(readFileSync(f)).digest("hex");
+    const connection = JSON.parse(readFileSync(files[1], "utf8"));
+    const expected = {
+      environment: descriptor.environment,
+      contextKey: descriptor.contextKey,
+      pack,
+      packRevision: descriptor.packRevision,
+      nativeThreadId: descriptor.nativeId,
+      agentId: descriptor.AgentLogicalId,
+      agentVersionId: descriptor.AgentVersionId,
+      agentWorkspaceId: descriptor.AgentWorkspaceId,
+      bytesWorkspaceId: descriptor.BytesWorkspaceId,
+      instanceId: descriptor.installationId
+    };
+    if (Object.entries(expected).some(([k, v]) => connection[k] !== v) || connection.identity?.organizationId !== descriptor.organizationId || descriptor.contextKey !== "org:" + descriptor.organizationId || descriptor.privateMCPDescriptorHash !== hashes[files[2]] || descriptor.contextDigest !== digest(hashes))
+      throw new Error("Current hosted Agent, Bytes, private MCP or loaded-source context descriptor differs.");
+    Object.assign(context, hashes);
+    inventories[cwd] = snapshotClaudeMarkdown(cwd, filesystem, cryptography, paths);
+    return { key: row.key, sessionId: row.desktopSessionId, cwd, title: row.title };
+  };
+  const source = fixed(record.plan.role);
+  const intake = fixed(record.plan.intake);
+  const consent = policy.installationConsent;
+  if (consent.contextKey !== record.plan.role.contextKey || consent.environment !== record.plan.role.environment || consent.intakeRoutes?.[source.key] !== intake.key || record.creationReceipt.cwd !== source.cwd)
+    throw new Error("Dynamic child original intake or installation scope differs.");
+  return {
+    root,
+    pack,
+    record,
+    context,
+    contextInventories: inventories,
+    consent,
+    nativePlan: {
+      laneId,
+      planDigest: record.planDigest,
+      nativeId: record.nativeId,
+      cwd: record.creationReceipt.cwd,
+      title: record.nativeTitle,
+      source,
+      intake,
+      lifecycleState: record.state,
+      ...record.plan.resolution.resolved,
+      permissionMode: record.plan.verificationProfile === "manual" ? "default" : record.plan.role.settings.permissions.defaultMode,
+      contextDigest: record.plan.role.contextDigest,
+      deadline: Date.now() + 45e3
+    }
+  };
+}
+function privateClaudeHelperEnvironment(connection, fs, crypto, path, hostEnv) {
+  const fields = ["format", "schemaVersion", "root", "pack", "sourceRoleKey", "policyFile", "bindingFile", "policyDigest", "bindingDigest", "stateDigest", "profile"];
+  if (!connection || typeof connection !== "object" || Array.isArray(connection) || Object.keys(connection).sort().join() !== fields.sort().join() || connection.format !== "topolo-private-helper-connection" || connection.schemaVersion !== 1 || !/^[a-z0-9][a-z0-9-]*$/.test(connection.pack) || typeof connection.sourceRoleKey !== "string" || connection.sourceRoleKey.split("/").length !== 3)
+    throw new Error("Explicit approved private helper connection required before client startup.");
+  const canonical = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
+  const hash = (bytes) => crypto.createHash("sha256").update(bytes).digest("hex");
+  const owned = (file) => {
+    const info = fs.lstatSync(file);
+    if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.() || info.nlink !== 1 || info.mode & 18)
+      throw new Error("Private helper metadata requires owned regular records.");
+  };
+  const read = (file, expected) => {
+    owned(file);
+    const bytes = fs.readFileSync(file);
+    if (hash(bytes) !== expected) throw new Error("Private helper connection metadata changed before client startup.");
+    return JSON.parse(bytes.toString("utf8"));
+  };
+  const root = fs.realpathSync(connection.root);
+  if (root !== connection.root) throw new Error("Private helper library identity changed.");
+  const policy = read(connection.policyFile, connection.policyDigest), consent = policy.installationConsent;
+  const state = read(path.resolve(root, "claude/state.json"), connection.stateDigest);
+  const binding = read(connection.bindingFile, connection.bindingDigest), profile = connection.profile;
+  if (!profile || typeof profile !== "object" || Object.keys(profile).sort().join() !== ["format", "schemaVersion", "configPath", "environment", "contextKey", "identity"].sort().join() || profile.format !== "topolo-private-credential-profile" || profile.schemaVersion !== 1 || !["development", "staging", "production"].includes(profile.environment) || typeof profile.contextKey !== "string" || !profile.identity || Object.keys(profile.identity).sort().join() !== "organizationId,userId" || typeof profile.identity.userId !== "string" || !profile.identity.userId || typeof profile.identity.organizationId !== "string" || !profile.identity.organizationId || profile.contextKey !== "org:" + profile.identity.organizationId)
+    throw new Error("Exact per-environment private profile identity reference required.");
+  if (connection.bindingFile !== path.resolve(root, "connections", connection.pack, profile.environment, hash(profile.contextKey) + ".json") || canonical(binding.privateCredentialProfile) !== canonical(profile) || canonical(binding.identity) !== canonical(profile.identity) || binding.environment !== profile.environment || binding.contextKey !== profile.contextKey || policy.format !== "topolo-agent-execution-policy" || policy.pack !== connection.pack || policy.sourceRevision !== binding.packRevision || state.harness !== "claude" || !consent || consent.format !== "topolo-pack-installation-consent" || consent.schemaVersion !== 1 || consent.authority !== "local-installation-consent" || consent.approved !== true || consent.pack !== connection.pack || consent.environment !== profile.environment || consent.contextKey !== profile.contextKey || consent.principalId !== profile.identity.userId || !consent.agentWorkspaceId || binding.agentWorkspaceId !== consent.agentWorkspaceId || typeof binding.input?.instanceId !== "string" || !binding.input.instanceId || typeof binding.input.bytesWorkspaceId !== "string" || !binding.input.bytesWorkspaceId)
+    throw new Error("Private helper profile differs from the actual pack installation and policy.");
+  const intakeKey = consent.intakeRoutes?.[connection.sourceRoleKey];
+  if (typeof intakeKey !== "string" || !intakeKey.includes("/intakes/")) throw new Error("Private helper original intake is missing.");
+  for (const key of [connection.sourceRoleKey, intakeKey]) {
+    const logical = key.split("/").slice(1).join("/");
+    const rows = state.agents?.filter((row) => row.key === key && row.pack === connection.pack && row.sourceRevision === binding.packRevision && row.importState === "desktop-adopted");
+    const roles = binding.input.roles?.filter((row) => row.logicalId === logical);
+    if (key.split("/")[0] !== connection.pack || rows?.length !== 1 || roles?.length !== 1 || !policy.agents?.some((row) => row.key === key) || typeof roles[0].agentId !== "string" || !roles[0].agentId || typeof roles[0].agentVersionId !== "string" || !roles[0].agentVersionId)
+      throw new Error("Private helper source or original intake is outside the current bound pack.");
+    const cwd = fs.realpathSync(rows[0].workspace);
+    if (!cwd.startsWith(path.resolve(root, "claude/workspaces", connection.pack) + path.sep)) throw new Error("Private helper role workspace is outside its pack.");
+    const descriptorFile = path.resolve(cwd, "topolo-connection.json");
+    owned(descriptorFile);
+    const descriptor = JSON.parse(fs.readFileSync(descriptorFile, "utf8"));
+    const expected = {
+      harness: "claude",
+      pack: connection.pack,
+      packRevision: binding.packRevision,
+      role: logical,
+      nativeThreadId: rows[0].desktopSessionId,
+      environment: profile.environment,
+      contextKey: profile.contextKey,
+      instanceId: binding.input.instanceId,
+      agentId: roles[0].agentId,
+      agentVersionId: roles[0].agentVersionId,
+      agentWorkspaceId: binding.agentWorkspaceId,
+      bytesWorkspaceId: binding.input.bytesWorkspaceId
+    };
+    if (Object.entries(expected).some(([name, value]) => descriptor[name] !== value) || canonical(descriptor.identity) !== canonical(profile.identity))
+      throw new Error("Private helper role descriptor does not match the actual public connection binding.");
+  }
+  if (typeof profile.configPath !== "string" || !path.isAbsolute(profile.configPath) || fs.realpathSync(profile.configPath) !== profile.configPath)
+    throw new Error("Explicit protected profile path must be absolute and must not follow links.");
+  const leaf = fs.lstatSync(profile.configPath), parent = fs.lstatSync(path.dirname(profile.configPath));
+  if (!leaf.isFile() || leaf.isSymbolicLink() || leaf.uid !== process.getuid?.() || leaf.nlink !== 1 || (leaf.mode & 511) !== 384 || !parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== process.getuid?.() || (parent.mode & 511) !== 448)
+    throw new Error("Private helper profile requires owned0600 single-link storage in an owned0700 directory.");
+  const env = {};
+  for (const key of ["HOME", "USER", "LOGNAME", "PATH", "LANG", "LC_ALL", "TMPDIR"]) if (typeof hostEnv[key] === "string") env[key] = hostEnv[key];
+  return { ...env, TOPOLO_CONFIG_PATH: profile.configPath, TOPOLO_ENV: profile.environment, TOPOLO_CONTEXT: profile.contextKey };
+}
+function prepareClaudePrivateHelperConnection(store, pack, policyPath, sourceRoleKey) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(pack) || typeof sourceRoleKey !== "string" || sourceRoleKey.split("/").length !== 3)
+    throw new Error("Exact existing pack source role required for a private helper connection.");
+  const root = realpathSync(store), policyFile = realpathSync(policyPath);
+  const policyBytes = readFileSync(policyFile), policy = JSON.parse(policyBytes.toString("utf8")), consent = policy.installationConsent;
+  if (!consent || !["development", "staging", "production"].includes(consent.environment) || typeof consent.contextKey !== "string")
+    throw new Error("Existing approved per-environment private connection required.");
+  const bindingFile = resolve(root, "connections", pack, consent.environment, createHash("sha256").update(consent.contextKey).digest("hex") + ".json");
+  const bindingBytes = readFileSync(bindingFile), binding = JSON.parse(bindingBytes.toString("utf8"));
+  const connection = {
+    format: "topolo-private-helper-connection",
+    schemaVersion: 1,
+    root,
+    pack,
+    sourceRoleKey,
+    policyFile,
+    bindingFile,
+    policyDigest: createHash("sha256").update(policyBytes).digest("hex"),
+    bindingDigest: createHash("sha256").update(bindingBytes).digest("hex"),
+    stateDigest: createHash("sha256").update(readFileSync(resolve(root, "claude/state.json"))).digest("hex"),
+    profile: binding.privateCredentialProfile
+  };
+  privateClaudeHelperEnvironment(connection, filesystem, cryptography, paths, process.env);
+  return connection;
+}
+function runClaudeLaneHelper(root, pack, policyPath, action, payload, source, connection, launch = spawn, runtime = { fs: filesystem, crypto: cryptography, path: paths, env: process.env }, qualifyEnvironment = privateClaudeHelperEnvironment) {
+  const actions = [
+    "peek",
+    "plan",
+    "creation-begin",
+    "creation-record",
+    "creation-read",
+    "adopt",
+    "configure-begin",
+    "configure-ack",
+    "context-prepare",
+    "context-mark",
+    "context-ack",
+    "fixture-prepare",
+    "fixture-mark",
+    "fixture-outcome",
+    "permission-request",
+    "permission-decision",
+    "retire-begin",
+    "retire-ack",
+    "read"
+  ];
+  if (!actions.includes(action) || !/^[a-z0-9][a-z0-9-]*$/.test(pack) || !payload || typeof payload !== "object" || Array.isArray(payload))
+    return Promise.reject(new Error("Closed typed native lifecycle helper required."));
+  const encoded = JSON.stringify(payload);
+  if (Buffer.byteLength(encoded) > 2097152) return Promise.reject(new Error("Own-child native transcript exceeds bounded transport; no broad history read."));
+  const selectedRole = payload.sourceRoleKey ?? payload.request?.sourceRoleKey ?? payload.plan?.role?.key ?? payload.operation?.record?.plan?.role?.key;
+  if (!connection || root !== connection.root || pack !== connection.pack || policyPath !== connection.policyFile || selectedRole !== void 0 && selectedRole !== connection.sourceRoleKey)
+    return Promise.reject(new Error("Private helper arguments differ from the exact bound source connection."));
+  let childEnv;
+  try {
+    childEnv = qualifyEnvironment(connection, runtime.fs, runtime.crypto, runtime.path, runtime.env);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  const script = "import sys,json\nsys.path.insert(0,sys.argv[5])\nfrom topolo_agent_pack.storage import Library\nfrom topolo_agent_pack.lanes import ClaudeLifecycle\ns=ClaudeLifecycle(Library(sys.argv[1]),sys.argv[2],sys.argv[3])\np=json.loads(sys.stdin.read(2097153))\nprint(json.dumps(s.dispatch(sys.argv[4],p)))";
+  return new Promise((done, fail) => {
+    const child = launch("python3", ["-I", "-B", "-c", script, root, pack, policyPath, action, source], { stdio: ["pipe", "pipe", "pipe"], env: childEnv });
+    let output = "";
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      error ? fail(error) : done(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(new Error("Owned lifecycle helper timed out; preserve possible-effect custody."));
+    }, 2e5);
+    child.stdout.setEncoding("utf8");
+    child.stderr.resume();
+    child.stdout.on("data", (data) => {
+      output += data;
+      if (Buffer.byteLength(output) > 1048576) {
+        child.kill("SIGTERM");
+        finish(new Error("Bounded native lifecycle reply exceeded."));
+      }
+    });
+    child.on("error", () => finish(new Error("Bundled lifecycle helper unavailable.")));
+    child.on("close", (code) => {
+      if (settled) return;
+      if (code !== 0) return finish(new Error("Current context/policy/native lifecycle helper refused; no fallback or replay."));
+      try {
+        finish(void 0, JSON.parse(output));
+      } catch {
+        finish(new Error("Typed lifecycle helper returned invalid JSON."));
+      }
+    });
+    child.stdin.on("error", () => finish(new Error("Own lifecycle helper input closed; reconcile original effect.")));
+    child.stdin.end(encoded);
+  });
+}
+function requireClaudePrivateQueryEffectQualified(operation) {
+  if (["create", "configure", "context-start", "fixture-start", "retire", "approval-once"].includes(operation))
+    throw Object.assign(
+      new Error("native_private_query_prestart_contract_unqualified: private native query startup, exclusion and owned lifecycle are not qualified."),
+      { code: "native_private_query_prestart_contract_unqualified" }
+    );
+}
+function claudeLaneExpression(options, source, journal, prepared) {
+  if (!Number.isSafeInteger(options.pid) || options.pid < 1 || !["plan", "create", "create-read", "adopt", "read", "configure", "context-start", "context-read", "fixture-start", "fixture-read", "retire"].includes(options.operation))
+    throw new Error("Closed typed Claude lane operation required.");
+  requireClaudePrivateQueryEffectQualified(options.operation);
+  if (!options.privateConnection) throw new Error("Explicit approved private helper connection required before native access.");
+  return `(async()=>{
+    const expected=${JSON.stringify({ ...options, qualifier: CLAUDE_NATIVE_QUALIFIER, source, journal })};
+    const requireClaudePrivateQueryEffectQualified=(${requireClaudePrivateQueryEffectQualified.toString()});
+    requireClaudePrivateQueryEffectQualified(expected.operation);
+    if(process.pid!==expected.pid || typeof process.getBuiltinModule!=='function')throw new Error('Native process identity 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 base=process.resourcesPath+'/app.asar/.vite/build/';
+    const qualify=()=>{
+      if(process.pid!==expected.pid || load('electron').app.getVersion()!==expected.qualifier.version)throw new Error('Native version/PID changed.');
+      for(const [file,hash] of Object.entries(expected.qualifier.hashes))
+        if(crypto.createHash('sha256').update(fs.readFileSync(base+file)).digest('hex')!==hash)throw new Error('Native module changed.');
+    };
+    qualify();const manager=load(base+expected.qualifier.manager).claudeCodeSessionManager;
+    const canonical=value=>JSON.stringify(value,(_key,item)=>item&&typeof item==='object'&&!Array.isArray(item)?Object.fromEntries(Object.keys(item).sort().map(k=>[k,item[k]])):item);
+    const fingerprint=value=>crypto.createHash('sha256').update(canonical(value)).digest('hex');
+    const generation=fingerprint({pid:expected.pid,qualifier:expected.qualifier,root:expected.root,pack:expected.pack});
+    const models=()=>{
+      qualify();const rows=manager.getAvailableCodeModels();
+      if(!Array.isArray(rows)||!rows.length||rows.some(m=>typeof m!=='string')||new Set(rows).size!==rows.length)throw new Error('Current native account model IDs unavailable.');
+      return {harness:'claude',source:'native-account-model-ids',connectionGeneration:generation,models:[...rows].sort()};
+    };
+    const privateClaudeHelperEnvironment=(${privateClaudeHelperEnvironment.toString()});
+    const helper=(action,payload)=>(${runClaudeLaneHelper.toString()})(expected.root,expected.pack,expected.policy,action,
+      {...payload,...(action==='context-mark'?{historyCount:payload.historyCount??null,historyDigest:payload.historyDigest??null}:{}),models:models()},
+      expected.source,expected.privateConnection,load('node:child_process').spawn,{fs,crypto,path,env:process.env},privateClaudeHelperEnvironment);
+    const checkpoint=value=>{const fd=fs.openSync(expected.journal,'a');try{fs.writeSync(fd,JSON.stringify(value)+'\\n');fs.fsyncSync(fd);}finally{fs.closeSync(fd);}};
+    const fixed=async role=>{
+      const raw=await manager.getSessionWhenLoaded(role.nativeId,'topolo-dynamic-source',{warnOnMiss:false});
+      const view=await manager.getSession(role.nativeId);qualify();
+      if(!raw||!view||raw.sessionId!==role.nativeId||view.sessionId!==role.nativeId||raw.cwd!==role.cwd||view.cwd!==role.cwd||
+        raw.isArchived||view.isArchived||raw.backend?.kind!=='local'||raw.backend.remoteTarget||raw.spawnedFrom||raw.worktreePath||raw.worktreeLazy)
+        throw new Error('Exact source/intake actual native descriptor unavailable.');
+      return {raw,view};
+    };
+    if(expected.operation==='plan'){
+      if(Object.keys(expected.input).join()!=='request')throw new Error('Closed intake lane request required.');
+      const current=await helper('peek',{sourceRoleKey:expected.input.request.sourceRoleKey});
+      await fixed(current.role);await fixed(current.intake);
+      const rows=await manager.getAllSessions();qualify();
+      if(!Array.isArray(rows))throw new Error('Actual native ID-only creation inventory unavailable.');
+      return helper('plan',{request:expected.input.request,nativeIds:rows.map(r=>r.sessionId)});
+    }
+    if(expected.operation==='create-read'){
+      if(Object.keys(expected.input).join()!=='laneId')throw new Error('Exact immutable owned creation lane required.');
+      const laneId=expected.input.laneId;
+      const pending=await helper('creation-read',{laneId});
+      const p=pending.plan;
+      await fixed(p.role);await fixed(p.intake);
+      const current=async()=>{const proof=await helper('creation-read',{laneId});
+        if(canonical(proof.plan)!==canonical(p))throw new Error('Current immutable creation plan differs.');};
+      if(!pending.creation.nativeId)throw new Error('Own native creation identity is unresolved; no replay.');
+      await current();
+      const native=await (${nativeClaudeReadEmptyCreation.toString()})(manager,{...p,creationNativeId:pending.creation.nativeId},qualify);
+      if(native.state!=='ready')return {...native,laneId};
+      const receipt={format:'topolo-native-lane-created',schemaVersion:1,state:'ready',planDigest:fingerprint(p),
+        harness:'claude',nativeId:native.nativeId,logicalOriginThreadId:p.logicalOriginThreadId,cwd:native.cwd,
+        model:native.model,effort:native.effort,nativeParentId:native.nativeParentId,fresh:true,creationSource:'supported-native-host-tool'};
+      const record=await helper('adopt',{plan:p,receipt,native});
+      return {state:'created-adopted-unconfigured',receipt,record,modelTurnsStarted:false,requestedTaskStarted:false};
+    }
+    if(expected.operation==='adopt'){
+      if(Object.keys(expected.input).sort().join()!=='plan,receipt')throw new Error('Exact own host plan and creation receipt required.');
+      const p=expected.input.plan,r=expected.input.receipt;await fixed(p.role);await fixed(p.intake);
+      const raw=await manager.getSessionWhenLoaded(r.nativeId,'topolo-dynamic-adopt',{warnOnMiss:false});
+      const view=await manager.getSession(r.nativeId);qualify();
+      if(!raw||!view||raw.sessionId!==r.nativeId||view.sessionId!==r.nativeId||raw.cwd!==r.cwd||view.cwd!==r.cwd||raw.title!==view.title||
+        raw.isArchived||view.isArchived||raw.backend?.kind!=='local'||raw.backend.remoteTarget||raw.worktreePath||raw.worktreeLazy||
+        raw.spawnedFrom?.sessionId!==p.intake.nativeId||raw.spawnedFrom?.sideSession!==true)throw new Error('Actual child native raw parent or placement differs.');
+      return helper('adopt',{plan:p,receipt:r,native:{nativeId:r.nativeId,cwd:view.cwd,title:view.title,model:view.model,effort:view.effort,
+        nativeParentId:raw.spawnedFrom.sessionId,archived:false,backend:'local',foreignWorkspace:false,
+        busy:!!(view.isRunning||view.starting||raw.isRunning||raw.starting||manager.hasLosableWork(r.nativeId)),pendingApprovals:view.pendingToolPermissions?.length??0}});
+    }
+    const prepared=${JSON.stringify(prepared ?? null)};
+    if(!prepared)throw new Error('Exact registered own child preparation required.');
+    const nativePlan={...prepared.nativePlan,deadline:Date.now()+200000};
+    const snapshotMarkdown=(${snapshotClaudeMarkdown.toString()});
+    const verifyContext=()=>{
+      qualify();
+      for(const [file,hash] of Object.entries(prepared.context))
+        if(crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')!==hash)throw new Error('Current source/registration/policy context changed.');
+      for(const [cwd,inventory] of Object.entries(prepared.contextInventories))
+        if(canonical(snapshotMarkdown(cwd,fs,crypto,path))!==canonical(inventory))throw new Error('Current source charter inventory changed.');
+    };
+    const qualifyOrganization=async()=>{await helper('read',{laneId:nativePlan.laneId});verifyContext();};
+    let historyBefore;
+    const ownHistory=async()=>{
+      const raw=await manager.getSessionWhenLoaded(nativePlan.nativeId,'topolo-dynamic-history',{warnOnMiss:false});
+      if(!raw||raw.backend?.kind!=='local'||raw.backend.remoteTarget||raw.spawnedFrom?.sessionId!==nativePlan.intake.sessionId)throw new Error('Own child transcript eligibility changed.');
+      const messages=await manager.getTranscriptForCallerElsewhere(nativePlan.nativeId);qualify();
+      if(!Array.isArray(messages))throw new Error('Exact own child transcript resolver unavailable.');return messages;
+    };
+    const history=(id,before)=>{if(id!==nativePlan.nativeId)throw new Error('Unrelated transcript forbidden.');
+      return before===undefined?historyBefore:fingerprint(historyBefore)===before;};
+    if(expected.operation==='configure'){
+      const operation=await helper('configure-begin',{laneId:nativePlan.laneId,generation});
+      // Helper's owned marker changes the registration; verify immutable source inputs and that precise beforeimage.
+      delete prepared.context[path.resolve(expected.root,'dynamic-lanes/claude',nativePlan.laneId+'.json')];
+      const result=await (${nativeClaudeDynamicLaneOperation.toString()})(manager,nativePlan,'configure',checkpoint,verifyContext,qualifyOrganization,history);
+      const configured=await helper('configure-ack',{operation,native:result});
+      const intakeRoute={key:prepared.record.plan.intake.key,sessionId:nativePlan.intake.sessionId,cwd:nativePlan.intake.cwd,title:nativePlan.intake.title,
+        contextKey:prepared.record.plan.intake.contextKey,intakeKey:prepared.record.plan.intake.key,intakeSessionId:nativePlan.intake.sessionId};
+      if(!manager[Symbol.for('topolo.agent-pack.approvals.v1')])
+        await (${nativeClaudeApprovalOperation.toString()})(manager,[intakeRoute],{kind:'install'},fingerprint,checkpoint);
+      const route={key:prepared.record.plan.role.key+'/dynamic/'+nativePlan.laneId,sessionId:nativePlan.nativeId,cwd:nativePlan.cwd,title:nativePlan.title,
+        contextKey:prepared.record.plan.role.contextKey,intakeKey:prepared.record.plan.intake.key,intakeSessionId:nativePlan.intake.sessionId,
+        dynamic:{laneId:nativePlan.laneId,planDigest:nativePlan.planDigest,nativeParentId:nativePlan.intake.sessionId,generation,connectionId:nativePlan.laneId}};
+      await (${nativeClaudeAppendDynamicRoute.toString()})(manager,route,qualifyOrganization,checkpoint,{
+        request:async(record,pending)=>{if(typeof pending.toolUseId!=='string')throw new Error('Actual native permission toolUseId is missing.');
+          await helper('permission-request',{laneId:nativePlan.laneId,request:{nativeId:nativePlan.nativeId,fingerprint:record.fingerprint,requestId:pending.requestId,
+            generation,intakeKey:record.intakeKey,intakeNativeId:record.intakeSessionId,toolUseId:pending.toolUseId}});},
+        decision:async(record,pending,decision)=>helper('permission-decision',{laneId:nativePlan.laneId,decision:decision==='once'?'approved':'denied',
+          intakeKey:record.intakeKey,fingerprint:record.fingerprint,generation})});
+      const control=expected.control;
+      if(!control)throw new Error('Exact owned per-lane native control setup required.');
+      const secretInfo=fs.lstatSync(control.secretPath);
+      if(!secretInfo.isFile()||secretInfo.isSymbolicLink()||secretInfo.uid!==process.getuid()||secretInfo.mode&63)throw new Error('Unowned private native control secret.');
+      const secret=JSON.parse(fs.readFileSync(control.secretPath,'utf8'));
+      const ownedOperation=async op=>{
+        requireClaudePrivateQueryEffectQualified(op.kind==='approval-respond'&&op.decision==='once'?'approval-once':op.kind);
+        qualify();const current=await helper('read',{laneId:nativePlan.laneId});
+        const scopedPlan={...nativePlan,lifecycleState:current.state,deadline:Date.now()+200000};
+        if(op.kind.startsWith('approval-')){
+          const state=manager[Symbol.for('topolo.agent-pack.approvals.v1')];
+          if(!state)throw new Error('Original native approval listener unavailable.');
+          if(op.kind!=='approval-list'){
+            const entry=state.entries.get(op.key);
+            if(!entry||entry.record.sourceSessionId!==nativePlan.nativeId||entry.record.intakeSessionId!==nativePlan.intake.sessionId)
+              throw new Error('Native approval is outside the exact owned child/original intake.');
+          }
+          const result=await (${nativeClaudeApprovalOperation.toString()})(manager,state.routes,
+            {...op,kind:op.kind.slice('approval-'.length)},fingerprint,checkpoint);
+          return op.kind==='approval-list'?{requests:result.requests.filter(r=>r.sourceSessionId===nativePlan.nativeId)}:result;
+        }
+        if(op.kind==='context-start'||op.kind==='context-read')return (${nativeClaudeDynamicContext.toString()})(manager,scopedPlan,
+          {kind:op.kind,operationId:op.operationId},helper,fingerprint,verifyContext,qualifyOrganization);
+        if(op.kind==='fixture-start'||op.kind==='fixture-read')return (${nativeClaudeDynamicFixture.toString()})(manager,scopedPlan,
+          {kind:op.kind,operationId:op.operationId},helper,verifyContext,qualifyOrganization);
+        if(op.kind==='read')return (${nativeClaudeDynamicLaneOperation.toString()})(manager,scopedPlan,'read',checkpoint,verifyContext,qualifyOrganization,history);
+        if(op.kind==='retire'){
+          const messages=await ownHistory();const before=fingerprint(messages);const retirement=await helper('retire-begin',{laneId:scopedPlan.laneId});
+          const result=await (${nativeClaudeDynamicLaneOperation.toString()})(manager,scopedPlan,'retire',checkpoint,verifyContext,qualifyOrganization,
+            async(id,saved)=>{if(id!==scopedPlan.nativeId)throw new Error('Unrelated transcript forbidden.');return saved===undefined?before:fingerprint(await ownHistory())===saved;});
+          const retired=await helper('retire-ack',{operation:retirement,native:result});
+          const state=manager[Symbol.for('topolo.agent-pack.approvals.v1')];
+          if([...state.entries.values()].some(e=>e.record.sourceSessionId===scopedPlan.nativeId&&['pending','response-may-have-effects'].includes(e.record.state)))
+            throw new Error('Own retired route still has an unresolved native request.');
+          state.byId.delete(scopedPlan.nativeId);state.byKey.delete(route.key);state.dynamicRoutes?.delete(scopedPlan.nativeId);state.dynamicLifecycle?.delete(scopedPlan.nativeId);
+          return retired;
+        }
+        if(op.kind==='close'){
+          if(current.state!=='retired')throw new Error('Only a normally retired own child control may close.');
+          return {state:'normal-own-lane-control-close-approved',laneId:scopedPlan.laneId};
+        }
+        throw new Error('Unsupported exact owned native lane operation.');
+      };
+      const connection=await (${nativeClaudeLaneControl.toString()})(load('node:net'),fs,manager,
+        {socket:control.socket,pid:expected.pid,identity:control.identity,laneId:nativePlan.laneId},secret.token,
+        ownedOperation,qualify,checkpoint);
+      return {record:configured,connection};
+
+    }
+    if(expected.operation==='read')return (${nativeClaudeDynamicLaneOperation.toString()})(manager,nativePlan,'read',checkpoint,verifyContext,qualifyOrganization,history);
+    if(expected.operation==='context-start'||expected.operation==='context-read'){
+      delete prepared.context[path.resolve(expected.root,'dynamic-lanes/claude',nativePlan.laneId+'.json')];
+      return (${nativeClaudeDynamicContext.toString()})(manager,nativePlan,{kind:expected.operation,operationId:expected.input.operationId},
+        helper,fingerprint,verifyContext,qualifyOrganization);
+    }
+    if(expected.operation==='fixture-start'||expected.operation==='fixture-read'){
+      delete prepared.context[path.resolve(expected.root,'dynamic-lanes/claude',nativePlan.laneId+'.json')];
+      return (${nativeClaudeDynamicFixture.toString()})(manager,nativePlan,{kind:expected.operation,operationId:expected.input.operationId},
+        helper,verifyContext,qualifyOrganization);
+    }
+    if(expected.operation==='retire'){
+      historyBefore=await ownHistory();const before=fingerprint(historyBefore);
+      const operation=await helper('retire-begin',{laneId:nativePlan.laneId});
+      delete prepared.context[path.resolve(expected.root,'dynamic-lanes/claude',nativePlan.laneId+'.json')];
+      const result=await (${nativeClaudeDynamicLaneOperation.toString()})(manager,nativePlan,'retire',checkpoint,verifyContext,qualifyOrganization,
+        async(id,saved)=>{if(id!==nativePlan.nativeId)throw new Error('Unrelated archive transcript forbidden.');if(saved===undefined)return before;return fingerprint(await ownHistory())===saved;});
+      historyBefore=await ownHistory();if(fingerprint(historyBefore)!==before)throw new Error('Own child transcript preservation differs.');
+      return helper('retire-ack',{operation,native:{...result,historyPreserved:true}});
+    }
+    throw new Error('Closed native fixture operation not yet qualified on this connection.');
+  })()`;
+}
+async function operateClaudeLane(options, evaluate = evaluateClaudeMain) {
+  requireClaudePrivateQueryEffectQualified(options.operation);
+  validateInspectorEndpoint(options.endpoint);
+  const root = realpathSync(options.store);
+  const policy = realpathSync(options.policy);
+  const release = await lockClaudeLibrary(root);
+  try {
+    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("Installed typed lifecycle helper source unavailable.");
+    const directory = resolve(root, "claude/dynamic-journals");
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    if (lstatSync(directory).isSymbolicLink()) throw new Error("Unowned native lifecycle journal directory.");
+    const journal = resolve(directory, randomUUID() + ".jsonl");
+    durableRecord(journal, { operation: options.operation, pid: options.pid, at: Date.now() }, "wx");
+    const prepared = ["plan", "create", "create-read", "adopt"].includes(options.operation) ? void 0 : prepareClaudeDynamicLane(root, options.pack, policy, options.input.laneId);
+    let sourceRoleKey = prepared?.record.plan.role.key ?? (options.operation === "plan" ? options.input.request?.sourceRoleKey : options.input.plan?.role?.key);
+    if (["create", "create-read"].includes(options.operation)) {
+      if (typeof options.input.laneId !== "string" || !/^[a-z0-9][a-z0-9-]*$/.test(options.input.laneId)) throw new Error("Exact existing creation lane required.");
+      const file = resolve(root, "dynamic-lanes/claude/plans", options.input.laneId + ".json");
+      const info = lstatSync(file);
+      if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1 || info.uid !== process.getuid?.() || info.mode & 18)
+        throw new Error("Unowned immutable creation plan.");
+      sourceRoleKey = JSON.parse(readFileSync(file, "utf8")).role?.key;
+    }
+    const privateConnection = prepareClaudePrivateHelperConnection(root, options.pack, policy, sourceRoleKey);
+    let control;
+    let connectionFile;
+    if (options.operation === "configure") {
+      if (!prepared) throw new Error("Exact fresh child preparation required.");
+      const laneId = prepared.nativePlan.laneId;
+      const privateRoot = resolve(root, "claude/dynamic-controls");
+      mkdirSync(privateRoot, { recursive: true, mode: 448 });
+      if (lstatSync(privateRoot).isSymbolicLink()) throw new Error("Unowned dynamic control directory.");
+      const directory2 = resolve(privateRoot, laneId);
+      mkdirSync(directory2, { mode: 448 });
+      const secretPath = resolve(directory2, "secret.json");
+      durableRecord(secretPath, { token: randomBytes(32).toString("hex") }, "wx");
+      const identity = createHash("sha256").update(JSON.stringify({ pid: options.pid, laneId, planDigest: prepared.record.planDigest, qualifier: CLAUDE_NATIVE_QUALIFIER })).digest("hex");
+      const socketDirectory = resolve("/tmp", "topolo-claude-" + process.getuid?.() + "-" + createHash("sha256").update(root + "\0" + laneId).digest("hex").slice(0, 24));
+      mkdirSync(socketDirectory, { mode: 448 });
+      const socket = resolve(socketDirectory, "control.sock");
+      control = { socket, secretPath, identity };
+      connectionFile = resolve(directory2, "connection.json");
+      durableRecord(connectionFile, { state: "prepared", pid: options.pid, laneId, pack: options.pack, policy, root, journal, ...control }, "wx");
+    }
+    const result = await evaluate(options.endpoint, claudeLaneExpression({
+      root,
+      pack: options.pack,
+      policy,
+      pid: options.pid,
+      operation: options.operation,
+      input: options.input,
+      privateConnection,
+      ...control ? { control } : {}
+    }, realpathSync(source), journal, prepared));
+    if (connectionFile) {
+      const value = JSON.parse(readFileSync(connectionFile, "utf8"));
+      writeFileSync(connectionFile, JSON.stringify({ ...value, state: "ready" }) + "\n", { mode: 384 });
+    }
+    return result;
+  } finally {
+    await release();
+  }
+}
+function operateClaudeLaneControl(options, request = requestClaudeApprovalControl) {
+  requireClaudePrivateQueryEffectQualified(options.operation.kind === "approval-respond" && options.operation.decision === "once" ? "approval-once" : options.operation.kind);
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(options.connection)) throw new Error("Exact owned native lane connection ID required.");
+  const root = realpathSync(options.store);
+  const directory = resolve(root, "claude/dynamic-controls", options.connection);
+  const owned = (file2) => {
+    const info = lstatSync(file2);
+    if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.() || info.mode & 63)
+      throw new Error("Unowned private native lane connection record.");
+  };
+  const file = resolve(directory, "connection.json");
+  owned(file);
+  const connection = JSON.parse(readFileSync(file, "utf8"));
+  if (connection.state !== "ready" || connection.laneId !== options.connection || connection.root !== root || !Number.isSafeInteger(connection.pid))
+    throw new Error("Exact current ready native lane connection required.");
+  owned(connection.secretPath);
+  if (realpathSync(connection.secretPath) !== resolve(directory, "secret.json")) throw new Error("Private native secret path differs.");
+  const secret = JSON.parse(readFileSync(connection.secretPath, "utf8"));
+  return request(connection, options.operation, secret.token);
+}
+export {
+  CLAUDE_NATIVE_QUALIFIER,
+  claudeLaneExpression,
+  configureClaudePack,
+  evaluateClaudeMain,
+  lockClaudeLibrary,
+  nativePackExpression,
+  operateClaudeApprovals,
+  operateClaudeLane,
+  operateClaudeLaneControl,
+  operateClaudeSmoke,
+  prepareClaudeDynamicLane,
+  prepareClaudeNativePlan,
+  prepareClaudePrivateHelperConnection,
+  privateClaudeHelperEnvironment,
+  requestClaudeApprovalControl,
+  requireClaudePrivateQueryEffectQualified,
+  runClaudeLaneHelper,
+  runClaudeSmokeHelper,
+  snapshotClaudeMarkdown,
+  validateInspectorEndpoint,
+  verifyClaudeOrganizationPolicy,
+  verifyClaudePlanContext
+};