@topolo/cli 0.13.9 → 0.13.10

package/dist/{claude-pack-backend-4F4VHMI5.js → claude-pack-backend-RMSOPHVQ.js}

@@ -362,6 +362,259 @@ async function nativeClaudePackOperation(manager, sidebar, plan, apply, checkpoi
     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) {
@@ -579,10 +832,11 @@ async function nativeClaudeOwnedSmokeOperation(manager, members, operation, help
 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 byId = new Map(routes.map((r) => [r.sessionId, r]));
-  const byKey = new Map(routes.map((r) => [r.key, r]));
+  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 = byKey.get(r.intakeKey);
+    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.");
   }
@@ -595,7 +849,7 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
     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 || descriptor.spawnedFrom)
+    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;
   };
@@ -624,7 +878,7 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
     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, entries: /* @__PURE__ */ new Map(), notifications: /* @__PURE__ */ new Set(), deliveryAttempts: 0 };
+      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) => {
@@ -644,7 +898,7 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
             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 + ". 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." : "");
+          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++;
@@ -695,6 +949,8 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
           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) => {
@@ -737,6 +993,11 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
   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.");
@@ -750,10 +1011,118 @@ async function nativeClaudeApprovalOperation(manager, routes, operation, fingerp
   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 = {
@@ -1396,7 +1765,7 @@ function requestClaudeApprovalControl(connection, operation, token, connect = cr
       error ? fail(error) : done(result);
     };
     client.setEncoding("utf8");
-    client.setTimeout(operation.kind === "smoke-start" ? 6e4 : 1e4, () => finish(new Error("Native approval response timed out; reconcile without replay.")));
+    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;
@@ -1454,16 +1823,555 @@ async function operateClaudeSmoke(options, request = requestClaudeApprovalContro
     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,