@topolo/cli 0.13.0 → 0.13.1

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

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+
+// src/lib/claude-pack-backend.ts
+import { createHash, 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 } from "child_process";
+import { resolve, sep } from "path";
+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 {
+    verifyContext();
+    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"].includes(member.permissionMode)))
+        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 snapshot = async (members = plan.members) => {
+      const result = [];
+      for (const member of members) {
+        checkDeadline();
+        const 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);
+        if (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 && (session.backend?.kind !== "local" || session.backend.remoteTarget || session.worktreePath || session.worktreeLazy || session.spawnedFrom))
+          throw new Error("Incoming session is not a qualified local role.");
+        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
+        });
+      }
+      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 && (session.backend?.kind !== "local" || session.backend.remoteTarget || session.worktreePath || session.worktreeLazy || session.spawnedFrom || !manager.archiveCascadeClosureOf || manager.archiveCascadeClosureOf(session).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 (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) {
+          if (session.backend?.kind !== "local" || session.backend.remoteTarget || session.worktreePath || session.worktreeLazy || session.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;
+  }
+}
+
+// src/lib/claude-pack-backend.ts
+var CLAUDE_NATIVE_QUALIFIER = {
+  version: "2.31226.1",
+  manager: "index.chunk-BCHP6ll9.js",
+  sidebar: "index.chunk-4-bSRKfE.js",
+  hashes: {
+    "index.chunk-BCHP6ll9.js": "ec7c7cda3dd597a3cce034cc6eaea52e6e2b10d1b24f0eb9aee3964638afadf2",
+    "index.chunk-4-bSRKfE.js": "594213a92b61bb64a3d61695d2370b624981af91f359c18832debb42a7814d86",
+    "index.chunk-Cyt2WTko.js": "29738ec09f4bf44d511caae628b0f786e35956848e6a18c3159c9928d6ac1ad9"
+  }
+};
+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 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");
+    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
+    });
+  }
+  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.");
+  return { members, outgoing, context, contextInventories, sourceRevision: policy.sourceRevision, mode, activeBefore: active };
+}
+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;
+  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 verifyContext = () => {
+      if (!inventories || !Object.keys(inventories).length) throw new Error('Complete context inventory proof is unavailable.');
+      for (const [root, inventory] of Object.entries(inventories))
+        if (JSON.stringify(snapshotMarkdown(root, fs, crypto, path)) !== JSON.stringify(inventory))
+          throw new Error('Context or transcript changed during configuration: Markdown inventory ' + root);
+      for (const [file, hash] of Object.entries(context))
+        if (crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex') !== hash)
+          throw new Error('Context or transcript changed during configuration: ' + file);
+    };
+    return await (${nativeClaudePackOperation.toString()})(manager,
+      value => transport.U(value, transport.V),
+      { 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);
+  })()`;
+}
+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) {
+  if (!plan.contextInventories || !Object.keys(plan.contextInventories).length) throw new Error("Complete context inventory proof is unavailable.");
+  for (const [root, inventory] of Object.entries(plan.contextInventories))
+    if (JSON.stringify(snapshotClaudeMarkdown(root, filesystem, cryptography, paths)) !== JSON.stringify(inventory))
+      throw new Error("Context or transcript changed during configuration: Markdown inventory " + root);
+  for (const [file, hash] of Object.entries(plan.context))
+    if (createHash("sha256").update(readFileSync(file)).digest("hex") !== hash) throw new Error("Context or transcript changed during configuration: " + file);
+}
+async function configureClaudePack(options, evaluate = evaluateClaudeMain) {
+  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, 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 };
+      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 {
+      verifyPlanContext(plan);
+      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));
+      verifyPlanContext(plan);
+      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 (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.");
+        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 (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: true };
+    } 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();
+  }
+}
+export {
+  CLAUDE_NATIVE_QUALIFIER,
+  configureClaudePack,
+  evaluateClaudeMain,
+  lockClaudeLibrary,
+  nativePackExpression,
+  prepareClaudeNativePlan,
+  snapshotClaudeMarkdown,
+  validateInspectorEndpoint
+};