@topolo/cli 0.13.17 → 0.13.21

package/dist/claude-desktop-profile-JCQKSY3K.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  acknowledgeClaudeDesktopProfile,
+  launchClaudeDesktopProfile,
+  readClaudeDesktopProfile,
+  verifyClaudeDesktopProfileNative
+} from "./chunk-NYDIAYVY.js";
+export {
+  acknowledgeClaudeDesktopProfile,
+  launchClaudeDesktopProfile,
+  readClaudeDesktopProfile,
+  verifyClaudeDesktopProfileNative
+};

package/dist/claude-pack-activation-Q25MCEPU.js

@@ -0,0 +1,506 @@
+#!/usr/bin/env node
+import {
+  bindClaudeFrontdoorHooks,
+  discoverClaudeNativeCapabilities,
+  evaluateClaudeMain,
+  lockClaudeLibrary,
+  materializeClaudeHookAdapter,
+  nativeClaudeDesktopControlExpression,
+  observeClaudeFrontdoors,
+  qualifyClaudePython,
+  readClaudeTaskConnection,
+  validateInspectorEndpoint
+} from "./chunk-UY5LEU5C.js";
+import {
+  acknowledgeClaudeDesktopProfile,
+  launchClaudeDesktopProfile,
+  readClaudeDesktopProfile,
+  verifyClaudeDesktopProfileNative
+} from "./chunk-NYDIAYVY.js";
+
+// src/lib/claude-desktop-menu.ts
+import { spawnSync } from "child_process";
+var claudeInspectorMenuScript = `on run argv
+ set targetPID to item 1 of argv as integer
+ set desiredEnabled to item 2 of argv is "enable"
+ tell application "System Events"
+  repeat 100 times
+   set targets to application processes whose unix id is targetPID
+   if (count of targets) > 1 then error "Native process identity is ambiguous"
+   if (count of targets) is 1 then exit repeat
+   delay 0.1
+  end repeat
+  if (count of targets) is not 1 then error "Exact native process is unavailable"
+  set targetProcess to item 1 of targets
+  if name of targetProcess is not "Claude" then error "Native application identity differs"
+  tell targetProcess
+   set ready to false
+   repeat 100 times
+    set matches to {}
+    set parentNames to {}
+    try
+     repeat with topItem in menu bar items of menu bar 1
+      try
+       set candidates to menu items of menu 1 of topItem whose name is "Enable Main Process Debugger"
+       repeat with candidate in candidates
+        set end of matches to contents of candidate
+        set end of parentNames to name of topItem
+       end repeat
+      end try
+     end repeat
+    end try
+    if (count of matches) > 1 then error "Unique native main-debugger capability is unavailable"
+    if (count of matches) is 1 then
+     if enabled of item 1 of matches is true then
+      set ready to true
+      exit repeat
+     end if
+    end if
+    delay 0.1
+   end repeat
+   if ready is not true then error "Unique enabled native main-debugger capability did not become ready"
+   set exactItem to item 1 of matches
+   if enabled of exactItem is not true then error "Native main-debugger capability is disabled"
+   set mark to value of attribute "AXMenuItemMarkChar" of exactItem
+   set isChecked to mark is not missing value and mark is not ""
+   if isChecked is desiredEnabled then error "Native inspector checkbox is already in the requested state; ownership must be reconciled"
+   set parentName to item 1 of parentNames
+   set frontmost to true
+   set parents to menu bar items of menu bar 1 whose name is parentName
+   if (count of parents) is not 1 then error "Native debugger parent changed"
+   if (count of (value of attribute "AXVisibleChildren" of menu 1 of item 1 of parents)) is 0 then perform action "AXPress" of item 1 of parents
+   set opened to false
+   repeat 40 times
+    set parents to menu bar items of menu bar 1 whose name is parentName
+    if (count of parents) is not 1 then error "Native debugger parent changed"
+    if (count of (value of attribute "AXVisibleChildren" of menu 1 of item 1 of parents)) > 0 then
+     set opened to true
+     exit repeat
+    end if
+    delay 0.05
+   end repeat
+   if opened is not true then error "Native debugger menu did not open"
+   set freshMatches to menu items of menu 1 of item 1 of parents whose name is "Enable Main Process Debugger"
+   if (count of freshMatches) is not 1 then error "Unique open debugger capability changed"
+   set exactItem to item 1 of freshMatches
+   if enabled of exactItem is not true then error "Native main-debugger capability is disabled"
+   set mark to value of attribute "AXMenuItemMarkChar" of exactItem
+   set isChecked to mark is not missing value and mark is not ""
+   if isChecked is desiredEnabled then error "Inspector ownership changed"
+   if "AXPress" is not in (name of actions of exactItem) then error "Native debugger press capability unavailable"
+   perform action "AXPress" of exactItem
+   repeat 40 times
+    set parents to menu bar items of menu bar 1 whose name is parentName
+    if (count of parents) is not 1 then error "Native debugger parent changed"
+    set freshMatches to menu items of menu 1 of item 1 of parents whose name is "Enable Main Process Debugger"
+    if (count of freshMatches) is not 1 then error "Native debugger checkbox changed"
+    set mark to value of attribute "AXMenuItemMarkChar" of item 1 of freshMatches
+    set isChecked to mark is not missing value and mark is not ""
+    if isChecked is desiredEnabled then
+     if desiredEnabled then return "owned-main-debugger-click-acknowledged"
+     return "owned-main-debugger-closed-acknowledged"
+    end if
+    delay 0.05
+   end repeat
+   error "Native debugger checkbox did not acknowledge requested state"
+  end tell
+ end tell
+end run`;
+function setInspectorMenu(pid, enabled, run) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) throw Error("Exact owned Desktop PID required.");
+  const result = run("/usr/bin/osascript", ["-e", claudeInspectorMenuScript, String(pid), enabled ? "enable" : "disable"], { encoding: "utf8", timeout: 3e4, maxBuffer: 16384 });
+  if (result.error || result.status !== 0 || result.stdout.trim() !== (enabled ? "owned-main-debugger-click-acknowledged" : "owned-main-debugger-closed-acknowledged")) throw Error("Approved native main-debugger menu activation unavailable; no signal or fallback used.");
+  return { state: enabled ? "owned-native-debugger-menu-acknowledged" : "owned-native-debugger-menu-disabled", pid };
+}
+function enableClaudeInspectorMenu(pid, run = spawnSync) {
+  return setInspectorMenu(pid, true, run);
+}
+function disableClaudeInspectorMenu(pid, run = spawnSync) {
+  return setInspectorMenu(pid, false, run);
+}
+
+// src/lib/claude-pack-activation.ts
+import * as fs from "fs";
+import * as path from "path";
+import { createHash, randomBytes, randomUUID } from "crypto";
+import { spawnSync as spawnSync2 } from "child_process";
+import { fileURLToPath } from "url";
+import { createServer } from "net";
+var digest = (data) => createHash("sha256").update(data).digest("hex");
+function owned(file) {
+  const s = fs.lstatSync(file);
+  if (!s.isFile() || s.isSymbolicLink() || s.nlink !== 1 || s.uid !== process.getuid?.() || s.mode & 18 || s.size > 1048576 || fs.realpathSync(file) !== file) throw Error("Exact owned bounded activation record required.");
+  return fs.readFileSync(file, "utf8");
+}
+function put(file, text, exclusive = false) {
+  if (exclusive) {
+    const fd = fs.openSync(file, "wx", 384);
+    try {
+      fs.writeFileSync(fd, text);
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } else {
+    const temporary = file + "." + randomUUID() + ".tmp";
+    put(temporary, text, true);
+    fs.renameSync(temporary, file);
+  }
+  const d = fs.openSync(path.dirname(file), "r");
+  try {
+    fs.fsyncSync(d);
+  } finally {
+    fs.closeSync(d);
+  }
+}
+function json(file) {
+  return JSON.parse(owned(file));
+}
+function append(file, row) {
+  const fd = fs.openSync(file, "a", 384);
+  try {
+    fs.writeFileSync(fd, JSON.stringify(row) + "\n");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function cloud(root, params) {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const adapter = [path.resolve(here, "../agent-packs/topolo-agent-pack"), path.resolve(here, "../../agent-packs/topolo-agent-pack")].find(fs.existsSync);
+  if (!adapter) throw Error("Bundled activation helper unavailable.");
+  const frozen = materializeClaudeHookAdapter(root, adapter), python = qualifyClaudePython();
+  const script = `import sys,json,pathlib,hashlib
+p=json.loads(sys.stdin.read(65537))
+assert hashlib.sha256(pathlib.Path(sys.executable).read_bytes()).hexdigest()==p['python']['sha256']
+for name,digest in p['files'].items():
+ assert hashlib.sha256(pathlib.Path(name).read_bytes()).hexdigest()==digest
+sys.path.insert(0,p['source'])
+from topolo_agent_pack.claude_activation import observe
+r=observe(p['root'],**p['params'])
+print(json.dumps(r))`;
+  const result = spawnSync2(python.executable, ["-I", "-B", "-c", script], { encoding: "utf8", input: JSON.stringify({ root, source: frozen.source, files: frozen.files, python, params }), timeout: 18e4, maxBuffer: 1048576 });
+  if (result.error || result.status !== 0) throw Error("Cloud activation/closure proof failed; preserve native ownership.");
+  return JSON.parse(result.stdout);
+}
+function observer(pid, profile, members, journal, warm = false) {
+  return `(async()=>{if(process.pid!==${pid})throw Error('Desktop PID changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json'),caps=(${discoverClaudeNativeCapabilities.toString()})(load,process.resourcesPath);const check=()=>{caps.assertCurrent();(${verifyClaudeDesktopProfileNative.toString()})(${JSON.stringify(profile)},process.pid,load('electron').app,caps.manager,process.env);};check();const fs=load('node:fs');const checkpoint=row=>{const fd=fs.openSync(${JSON.stringify(journal)},'a',384);try{fs.writeSync(fd,JSON.stringify(row)+'\\n');fs.fsyncSync(fd);}finally{fs.closeSync(fd);}};return (${observeClaudeFrontdoors.toString()})(caps.manager,${JSON.stringify(members)},check,${warm},checkpoint);})()`;
+}
+function checkResult(result, members) {
+  if (result?.state !== "installed-frontdoors-verified" || result.nativeInputsSent !== false || result.members?.length !== 3 || result.members.some((r, i) => ["key", "sessionId", "cwd", "title", "model", "effort", "permissionMode"].some((k) => r[k] !== members[i][k]) || !r.pinned || !/^[-a-f0-9]{36}$/.test(r.cliSessionId))) throw Error("Exact installed native front-door acknowledgement differs.");
+}
+function sameNativeConnection(left, right) {
+  const keys = ["identity", "pid", "runtime", "secretPath", "socket"];
+  return left && Object.keys(left).sort().join() === keys.join() && keys.every((k) => left[k] === right[k]);
+}
+function installedBindingMatches(binding, connection, pid, members) {
+  const channels = { engineering: "engineering", "operator-01": "operations", cicd: "cicd" };
+  return sameNativeConnection(binding.nativeConnection, connection) && binding.desktopPid === pid && binding.roles?.length === 3 && binding.roles.every((r, i) => Object.keys(r).sort().join() === "channel,cwd,sessionId" && r.channel === channels[members[i].key.split("/").at(-1)] && r.cwd === members[i].cwd);
+}
+function immutable(root, pack, policy) {
+  if (["startup-operation.json", "native-operation.json"].some((n) => fs.existsSync(path.join(root, "claude", n)))) throw Error("Unresolved native startup retains custody.");
+  const profile = readClaudeDesktopProfile(root);
+  if (!profile || profile.profile.pack !== pack) throw Error("Owned signed-in Desktop profile required.");
+  const p = json(policy);
+  if (p.pack !== pack || p.installationConsent?.profile !== "full-access" || profile.profile.consentDigest !== digest(JSON.stringify(p.installationConsent))) throw Error("Current activation consent differs.");
+  return { profile, policy: p };
+}
+async function finalizeClaudePack(options, evaluate = evaluateClaudeMain, prove = cloud, finishInspector = closeClaudeInspector, bind = bindClaudeFrontdoorHooks) {
+  const root = fs.realpathSync(options.store), release = await lockClaudeLibrary(root);
+  try {
+    const { profile } = immutable(root, options.pack, options.policy);
+    if (profile.pid !== options.pid) throw Error("Current native profile PID differs.");
+    if (!/^[a-f0-9-]{36}$/.test(options.startupOperation) || !/^[a-f0-9-]{36}$/.test(options.qualificationTask)) throw Error("Exact startup and qualification identities required.");
+    const file = path.join(root, "claude/activation.json"), pending = path.join(root, "claude/activation-operation.json");
+    const prior = fs.existsSync(pending) ? json(pending) : null;
+    if (fs.existsSync(file) && !prior) {
+      const { receipt: receipt2 } = validateActivation(root, options.pack, options.policy);
+      if (receipt2.startupOperation !== options.startupOperation || receipt2.qualificationTask !== options.qualificationTask || receipt2.pid !== options.pid) throw Error("Existing activation belongs to another operation.");
+      const proof2 = prove(root, { qualification_task: options.qualificationTask, start_service: true, native_proof: true });
+      checkResult(proof2.native, receipt2.members);
+      return { state: "claude-pack-activated", alreadyActivated: true, cloudReady: true, nativeInputsSent: false, coordinators: 3 };
+    }
+    if (prior && (prior.startupOperation !== options.startupOperation || prior.qualificationTask !== options.qualificationTask)) throw Error("Another activation operation retains custody.");
+    const startup = path.join(root, "claude/journals", options.startupOperation + ".jsonl"), text = owned(startup), rows = text.trimEnd().split("\n").map((r) => JSON.parse(r)), plan = rows[0];
+    if (!text.endsWith("\n") || plan.kind !== "startup-plan" || plan.operationId !== options.startupOperation || plan.libraryRoot !== root || plan.members?.length !== 3 || !rows.some((r) => r.kind === "frontdoor-hooks-prepared") || plan.previousCoordinators?.length && !rows.some((r) => r.kind === "previous-coordinators-retired" && JSON.stringify(r.retired) === JSON.stringify(plan.previousCoordinators.map((r2) => r2.sessionId)))) throw Error("Completed original startup acknowledgement required.");
+    const statePath = path.join(root, "claude/state.json"), state = json(statePath), members = plan.members;
+    const selected = state.agents.filter((r) => r.pack === options.pack);
+    if (selected.length !== 3 || selected.some((r, i) => r.key !== members[i].key || r.desktopSessionId !== members[i].sessionId || r.sourceRevision !== plan.sourceRevision || r.workspace !== members[i].cwd)) throw Error("Original prepared coordinator identity differs.");
+    for (const [f, hash] of Object.entries(plan.context)) {
+      if (f === statePath && prior) continue;
+      if (digest(owned(f)) !== hash) throw Error("Original startup context changed.");
+    }
+    const connection = readClaudeTaskConnection(path.join(root, "claude/desktop-task-connection.json"), options.pid), binding = json(path.join(root, "work/claude-frontdoors.json"));
+    if (!installedBindingMatches(binding, connection, options.pid, members)) throw Error("Current installed front-door binding differs.");
+    const controlJournal = path.join(root, "claude/journals", options.startupOperation + ".activation.jsonl");
+    if (!fs.existsSync(controlJournal)) put(controlJournal, JSON.stringify({ kind: "activation-native-observation", startupOperation: options.startupOperation }) + "\n", true);
+    const boundMembers = members.map((m, i) => ({ ...m, cliSessionId: binding.roles[i].sessionId }));
+    const observed = await evaluate(options.endpoint, observer(options.pid, profile.profile, boundMembers, controlJournal, true));
+    checkResult(observed, members);
+    if (observed.members.some((m, i) => m.cliSessionId !== binding.roles[i].sessionId)) throw Error("Native SDK and installed hook identity differ.");
+    const proof = prove(root, { qualification_task: options.qualificationTask, start_service: true });
+    if (proof.activated !== true || proof.service?.desktopPid !== options.pid || proof.qualificationTaskId !== options.qualificationTask) throw Error("Live cloud qualification differs.");
+    const next = structuredClone(state), changes = [];
+    for (let i = 0; i < selected.length; i++) {
+      const before = selected[i], native = observed.members[i], record = next.agents.find((r) => r.key === before.key);
+      const key = members[i].cwd.replace(/[^a-zA-Z0-9]/g, "-");
+      if (key.length > 200) throw Error("Native SDK path codec exceeds qualified bounds.");
+      const transcript = path.join(profile.profile.codeConfig, "projects", key, native.cliSessionId + ".jsonl");
+      owned(transcript);
+      const identity = path.join(root, "claude/identities", digest(before.key) + ".json"), oldIdentity = owned(identity);
+      if (!prior && JSON.stringify(JSON.parse(oldIdentity)) !== JSON.stringify(before)) throw Error("Prepared identity and state differ.");
+      Object.assign(record, { importState: "desktop-adopted", cliSessionId: native.cliSessionId, transcript });
+      changes.push({ file: identity, before: oldIdentity, after: JSON.stringify(record) + "\n" });
+    }
+    changes.push({ file: statePath, before: owned(statePath), after: JSON.stringify(next) + "\n" });
+    const active = { operationId: options.startupOperation, pack: options.pack, keys: members.map((m) => m.key), sourceRevision: plan.sourceRevision };
+    const activePath = path.join(root, "claude/active.json");
+    changes.push({ file: activePath, before: fs.existsSync(activePath) ? owned(activePath) : null, after: JSON.stringify(active) + "\n" });
+    const receipt = { format: "topolo-claude-pack-activation-v1", root, pack: options.pack, startupOperation: options.startupOperation, startupDigest: digest(text), sourceRevision: plan.sourceRevision, policyDigest: digest(owned(options.policy)), members: observed.members, qualificationTask: options.qualificationTask, cloud: proof.binding, profile: profile.profile, pid: options.pid, connection, cloudReady: true, nativeInputsSent: false, menuAutomationConsent: { approved: options.allowNativeDebuggerMenu === true, principalId: JSON.parse(owned(options.policy)).installationConsent.principalId, scope: "owned-claude-main-debugger-checkbox-only" } };
+    const operation = prior ?? { format: "topolo-claude-activation-operation-v1", startupOperation: options.startupOperation, qualificationTask: options.qualificationTask, state: "prepared", changes, receipt };
+    if (prior && JSON.stringify(prior.receipt) !== JSON.stringify(receipt)) throw Error("Pending activation proof differs; reconcile without adoption.");
+    if (!prior) put(pending, JSON.stringify(operation) + "\n", true);
+    for (const change of operation.changes) {
+      const current = fs.existsSync(change.file) ? owned(change.file) : null;
+      if (current !== change.before && current !== change.after) throw Error("Activation metadata changed outside its journal.");
+      if (current !== change.after) put(change.file, change.after);
+    }
+    const control = await evaluate(options.endpoint, nativeClaudeDesktopControlExpression(options.pid, root, connection, connection.secretPath, controlJournal, { existing: connection, coordinators: members, frontdoors: observed.members }));
+    if (!["native-desktop-task-control-installed", "native-desktop-task-control-reused"].includes(control.state)) throw Error("Qualified closed native control was not acknowledged.");
+    const hookInput = path.join(root, "claude/journals", options.startupOperation + ".activation-frontdoors.json");
+    bind(root, options.pid, observed.members.map((m) => ({ key: m.key, cwd: m.cwd, sessionId: m.cliSessionId })), hookInput, void 0, connection, fs.existsSync(hookInput));
+    for (const [file2, hash] of Object.entries(plan.context)) if (file2 !== statePath && digest(owned(file2)) !== hash) throw Error("Selected role context changed during hook migration.");
+    put(file, JSON.stringify(receipt) + "\n");
+    fs.unlinkSync(pending);
+    return { state: "claude-pack-activated", pack: options.pack, coordinators: 3, cloudReady: true, nativeInputsSent: false, qualificationTask: options.qualificationTask };
+  } finally {
+    try {
+      const p = readClaudeDesktopProfile(root);
+      if (p?.pid === options.pid) await finishInspector(options.endpoint, options.pid, p.profile, evaluate);
+    } finally {
+      await release();
+    }
+  }
+}
+async function upgradeClaudeControl(options, evaluate = evaluateClaudeMain, finishInspector = closeClaudeInspector) {
+  const root = fs.realpathSync(options.store);
+  let release;
+  try {
+    release = await lockClaudeLibrary(root, true);
+    const { profile } = immutable(root, options.pack, options.policy);
+    if (profile.pid !== options.pid || !/^[a-f0-9-]{36}$/.test(options.startupOperation)) throw Error("Exact current profile and original startup required.");
+    if (["activation-operation.json", "launch-operation.json"].some((n) => fs.existsSync(path.join(root, "claude", n)))) throw Error("Unresolved activation or launch retains custody.");
+    const startup = path.join(root, "claude/journals", options.startupOperation + ".jsonl"), text = owned(startup), rows = text.trimEnd().split("\n").map((r) => JSON.parse(r)), plan = rows[0];
+    if (!text.endsWith("\n") || plan.kind !== "startup-plan" || plan.operationId !== options.startupOperation || plan.libraryRoot !== root || plan.installationConsent?.pack !== options.pack || plan.members?.length !== 3 || !rows.some((r) => r.kind === "frontdoor-hooks-prepared") || plan.previousCoordinators?.length && !rows.some((r) => r.kind === "previous-coordinators-retired" && JSON.stringify(r.retired) === JSON.stringify(plan.previousCoordinators.map((m) => m.sessionId)))) throw Error("Completed exact original startup required.");
+    const statePath = path.join(root, "claude/state.json"), state = json(statePath), selected = state.agents.filter((m) => m.pack === options.pack), members = plan.members;
+    if (selected.length !== 3 || selected.some((m, i) => m.key !== members[i].key || m.desktopSessionId !== members[i].sessionId || m.workspace !== members[i].cwd || m.sourceRevision !== plan.sourceRevision)) throw Error("Original coordinator roster changed.");
+    const adopted = fs.existsSync(path.join(root, "claude/activation.json")) ? validateActivation(root, options.pack, options.policy).receipt : null;
+    if (adopted && (adopted.startupOperation !== options.startupOperation || adopted.startupDigest !== digest(text))) throw Error("Activated startup ownership differs.");
+    for (const [file, hash] of Object.entries(plan.context)) if (!(adopted && file === statePath) && digest(owned(file)) !== hash) throw Error("Original startup context changed.");
+    const connection = readClaudeTaskConnection(path.join(root, "claude/desktop-task-connection.json"), options.pid), binding = json(path.join(root, "work/claude-frontdoors.json"));
+    if (!installedBindingMatches(binding, connection, options.pid, members)) throw Error("Installed native front-door binding differs.");
+    const operationId = randomUUID(), journal = path.join(root, "claude/journals", operationId + ".control-upgrade.jsonl");
+    put(journal, JSON.stringify({ kind: "owned-control-upgrade", operationId, startupOperation: options.startupOperation, startupDigest: digest(text), policyDigest: digest(owned(options.policy)), connection, members, nativeInputsSent: false }) + "\n", true);
+    const observed = await evaluate(options.endpoint, observer(options.pid, profile.profile, members.map((m, i) => ({ ...m, cliSessionId: binding.roles[i].sessionId })), journal));
+    checkResult(observed, members);
+    if (observed.members.some((m, i) => m.cliSessionId !== binding.roles[i].sessionId)) throw Error("Native SDK and installed binding differ.");
+    const result = await evaluate(options.endpoint, nativeClaudeDesktopControlExpression(options.pid, root, connection, connection.secretPath, journal, { existing: connection, coordinators: members, frontdoors: observed.members }));
+    if (!["native-desktop-task-control-installed", "native-desktop-task-control-reused"].includes(result?.state)) throw Error("Owned native control upgrade was not acknowledged.");
+    append(journal, { kind: "owned-control-upgrade-verified", operationId, nativeInputsSent: false });
+    return { state: "claude-control-upgraded", startupOperation: options.startupOperation, pid: options.pid, coordinators: 3, nativeInputsSent: false };
+  } finally {
+    try {
+      const profile = readClaudeDesktopProfile(root);
+      if (profile?.pid === options.pid) await finishInspector(options.endpoint, options.pid, profile.profile, evaluate);
+    } finally {
+      if (release) await release();
+    }
+  }
+}
+function validateActivation(root, pack, policy, continueLaunch = false) {
+  const { profile } = immutable(root, pack, policy), receipt = json(path.join(root, "claude/activation.json"));
+  if (fs.existsSync(path.join(root, "claude/activation-operation.json")) || !continueLaunch && fs.existsSync(path.join(root, "claude/launch-operation.json"))) throw Error("Unresolved activation or launch retains custody.");
+  if (receipt.format !== "topolo-claude-pack-activation-v1" || receipt.root !== root || receipt.pack !== pack || receipt.policyDigest !== digest(owned(policy)) || JSON.stringify(receipt.profile) !== JSON.stringify(profile.profile)) throw Error("Activated pack/profile/consent changed.");
+  const state = json(path.join(root, "claude/state.json")), active = json(path.join(root, "claude/active.json"));
+  if (active.pack !== pack || active.operationId !== receipt.startupOperation || JSON.stringify(active.keys) !== JSON.stringify(receipt.members.map((m) => m.key))) throw Error("Verified active coordinator roster changed.");
+  for (const m of receipt.members) {
+    const r = state.agents.filter((r2) => r2.key === m.key);
+    if (r.length !== 1 || r[0].importState !== "desktop-adopted" || r[0].desktopSessionId !== m.sessionId || r[0].cliSessionId !== m.cliSessionId || r[0].workspace !== m.cwd || r[0].sourceRevision !== receipt.sourceRevision) throw Error("Activated coordinator identity changed.");
+  }
+  return { profile, receipt };
+}
+async function port(preferred = 0) {
+  const server = createServer();
+  await new Promise((done, fail) => {
+    server.once("error", fail);
+    server.listen(preferred, "127.0.0.1", done);
+  });
+  const selected = server.address().port;
+  await new Promise((done) => server.close(() => done()));
+  return selected;
+}
+async function resolveClaudeInspectorEndpoint(port2) {
+  let last;
+  for (let n = 0; n < 100; n++) {
+    let response;
+    try {
+      response = await fetch("http://127.0.0.1:" + port2 + "/json/list", { signal: AbortSignal.timeout(500) });
+    } catch (error) {
+      last = error;
+      await new Promise((r) => setTimeout(r, 100));
+      continue;
+    }
+    if (!response.ok) throw Error("Native inspector discovery was refused.");
+    const text = await response.text();
+    if (Buffer.byteLength(text) > 16384) throw Error("Native inspector discovery exceeded bounds.");
+    const rows = JSON.parse(text);
+    if (!Array.isArray(rows) || rows.length !== 1 || typeof rows[0].webSocketDebuggerUrl !== "string") throw Error("Ambiguous native inspector endpoint.");
+    const u = new URL(rows[0].webSocketDebuggerUrl);
+    if (u.hostname !== "127.0.0.1" || Number(u.port) !== port2 || u.protocol !== "ws:") throw Error("Native inspector left loopback boundary.");
+    return u.href;
+  }
+  throw Error("Owned temporary native inspector unavailable: " + String(last));
+}
+async function closeClaudeInspector(url, pid, profile, evaluate, disable = disableClaudeInspectorMenu) {
+  const ack = await evaluate(url, `(()=>{if(process.pid!==${pid})throw Error('Inspector owner changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json'),app=load('electron').app;if(app.getPath('userData')!==${JSON.stringify(profile.userData)})throw Error('Inspector profile differs');return{closing:true};})()`);
+  if (ack?.closing !== true) throw Error("Native inspector closure acknowledgement differs.");
+  const menu = disable(pid);
+  if (menu.state !== "owned-native-debugger-menu-disabled" || menu.pid !== pid) throw Error("Owned native debugger checkbox closure was not acknowledged.");
+  await new Promise((r) => setTimeout(r, 100));
+  try {
+    await fetch(new URL("/json/list", url.replace(/^ws:/, "http:")), { signal: AbortSignal.timeout(500) });
+  } catch {
+    return;
+  }
+  throw Error("Temporary inspector closure was not verified.");
+}
+async function launchActivatedClaudePack(options, deps = {}) {
+  const root = fs.realpathSync(options.store), release = await lockClaudeLibrary(root), prove = deps.prove ?? cloud, launch = deps.launch ?? launchClaudeDesktopProfile, evaluate = deps.evaluate ?? evaluateClaudeMain;
+  let inspection;
+  let pendingInspection;
+  try {
+    const continuing = options.continueLaunch !== void 0;
+    const { profile, receipt } = validateActivation(root, options.pack, options.policy, continuing);
+    const args = { root, pack: options.pack, policy: options.policy, userData: profile.profile.userData, codeConfig: profile.profile.codeConfig, app: profile.profile.app };
+    const before = launch({ ...args, apply: false });
+    if (continuing && before.pid === receipt.pid) throw Error("Pending cold launch cannot adopt the previous owner.");
+    if (before.pid === receipt.pid) {
+      const binding = json(path.join(root, "work/claude-frontdoors.json"));
+      if (!installedBindingMatches(binding, receipt.connection, receipt.pid, receipt.members) || binding.roles.some((m, i) => m.sessionId !== receipt.members[i].cliSessionId)) throw Error("Warm coordinator binding differs.");
+      const proof2 = prove(root, { warm_connection: receipt.connection });
+      if (proof2.warmOwner !== true || proof2.nativeInputsSent !== false || proof2.workerCustodyPreserved !== true) throw Error("Warm ownership proof differs.");
+      if (proof2.service?.desktopPid !== receipt.pid || JSON.stringify(proof2.binding) !== JSON.stringify(receipt.cloud)) throw Error("Current owning dispatcher differs.");
+      return { state: "claude-pack-ready", nativeReady: true, cloudReady: true, coordinators: 3, nativeInputsSent: false, pid: receipt.pid };
+    }
+    if (receipt.menuAutomationConsent?.approved !== true || receipt.menuAutomationConsent.scope !== "owned-claude-main-debugger-checkbox-only" || receipt.menuAutomationConsent.principalId !== json(options.policy).installationConsent.principalId) throw Error("Explicit installation-owner main-debugger menu consent required for cold restore.");
+    try {
+      process.kill(receipt.pid, 0);
+      throw Error("Previous native owner remains alive.");
+    } catch (error) {
+      if (error.code !== "ESRCH") throw error;
+    }
+    if (continuing && !/^[a-f0-9-]{36}$/.test(options.continueLaunch)) throw Error("Exact pending cold launch identity required.");
+    const operationId = options.continueLaunch ?? randomUUID(), journal = path.join(root, "claude/journals", operationId + ".launch.jsonl"), secretPath = path.join(root, "claude/journals", operationId + ".desktop-secret.json");
+    const marker = path.join(root, "claude/launch-operation.json"), previous = json(path.join(root, "work/claude-frontdoors.json"));
+    if (continuing) {
+      if (!options.endpoint || !Number.isSafeInteger(options.pid) || options.pid !== before.pid) throw Error("Exact already launched profile PID and approved endpoint required.");
+      validateInspectorEndpoint(options.endpoint);
+      inspection = { url: options.endpoint, pid: options.pid, profile: profile.profile };
+    }
+    if (continuing) {
+      const pending = json(marker), text = owned(journal), rows = text.trimEnd().split("\n").map((row) => JSON.parse(row)), first = rows[0], installs = rows.filter((r) => r.kind === "native-desktop-task-control-installed"), installed2 = installs[0];
+      if (installed2) {
+        const setup = rows.slice(0, rows.indexOf(installed2) + 1), activity = rows.slice(setup.length);
+        const workerKinds = ["worker-workspace-trust-attempt", "worker-workspace-trust-verified", "worker-create-attempt", "worker-create-verified", "worker-task-send-attempt", "worker-task-send-acknowledged", "worker-archive-attempt", "worker-archive-verified"];
+        const pid2 = options.pid, url2 = options.endpoint, descriptor2 = { ...receipt.connection, pid: pid2, identity: digest(JSON.stringify({ root, pack: options.pack, operationId })), socket: path.join("/tmp", "topolo-claude-task-" + operationId + ".sock"), secretPath };
+        const allowed = ["closed-native-rebind", "closed-native-rebind-continuation", "frontdoor-connect-only-attempt", "native-python-capability-qualified", "native-desktop-task-control-installed"];
+        const created = setup.filter((r) => r.kind === "native-desktop-task-control-installed"), connects = setup.filter((r) => r.kind === "frontdoor-connect-only-attempt"), continuations = setup.filter((r) => r.kind === "closed-native-rebind-continuation");
+        const input2 = path.join(root, "claude/journals", operationId + ".frontdoors.json"), bound = json(input2);
+        if (Object.keys(pending).sort().join() !== "journal,operationId,previousPid,state" || pending.operationId !== operationId || pending.state !== "may-have-effects" || pending.previousPid !== receipt.pid || pending.journal !== journal || !text.endsWith("\n") || first.kind !== "closed-native-rebind" || first.operationId !== operationId || first.previousPid !== receipt.pid || JSON.stringify(first.members) !== JSON.stringify(receipt.members) || setup.some((r) => !allowed.includes(r.kind)) || activity.some((r) => !workerKinds.includes(r.kind)) || installs.length !== 1 || created.length !== 1 || setup.filter((r) => r.kind === "native-python-capability-qualified").length !== 1 || continuations.length > 1 || continuations.some((r) => r.operationId !== operationId || r.pid !== pid2 || r.nativeInputsSent !== false || r.originalJournalSHA256 !== digest(JSON.stringify(first) + "\n")) || new Set(connects.map((r) => r.sessionId)).size !== connects.length || connects.some((r) => !receipt.members.some((m) => m.sessionId === r.sessionId && m.cliSessionId === r.cliSessionId)) || ["identity", "pid", "runtime", "secretPath", "socket"].some((k) => installed2[k] !== descriptor2[k]) || !sameNativeConnection(readClaudeTaskConnection(path.join(root, "claude/desktop-task-connection.json"), receipt.pid), receipt.connection) || !installedBindingMatches(previous, descriptor2, pid2, receipt.members) || previous.roles.some((r, i) => r.sessionId !== receipt.members[i].cliSessionId) || bound.desktopPid !== pid2 || !sameNativeConnection(bound.nativeConnection, descriptor2) || JSON.stringify(bound.roles) !== JSON.stringify(receipt.members.map((m) => ({ key: m.key, cwd: m.cwd, sessionId: m.cliSessionId }))) || Object.keys(json(secretPath)).join() !== "token" || !/^[a-f0-9]{64}$/.test(json(secretPath).token)) throw Error("Pending post-control launch custody differs; do not replay.");
+        let proof2 = prove(root, { successor_connection: descriptor2 });
+        if (proof2.existingSuccessor !== true) {
+          if (activity.length) throw Error("Worker audit activity requires the exact authenticated successor; preserve its custody.");
+          prove(root, { previous: { ...previous, desktopPid: receipt.pid, nativeConnection: receipt.connection }, connection: descriptor2, wait_retired_service: true });
+          proof2 = prove(root, { start_service: true, native_proof: true, require_native_idle: true });
+        } else if (proof2.serviceStarted !== false || proof2.workerCustodyPreserved !== true || proof2.nativeInputsSent !== false) throw Error("Successor reconciliation must preserve live worker custody.");
+        checkResult(proof2.native, receipt.members);
+        if (proof2.service?.desktopPid !== pid2 || JSON.stringify(proof2.binding) !== JSON.stringify(receipt.cloud) || proof2.native.members.some((m, i) => m.cliSessionId !== receipt.members[i].cliSessionId)) throw Error("Successor dispatcher differs.");
+        const actual2 = await evaluate(url2, `(()=>{if(process.pid!==${pid2})throw Error('Native PID changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');return{state:'native-profile-verified',pid:process.pid,userData:load('electron').app.getPath('userData'),codeConfig:process.env.CLAUDE_CONFIG_DIR};})()`);
+        acknowledgeClaudeDesktopProfile(root, readClaudeDesktopProfile(root), actual2);
+        put(path.join(root, "claude/desktop-task-connection.json"), JSON.stringify(descriptor2) + "\n");
+        await (deps.close ?? closeClaudeInspector)(url2, pid2, profile.profile, evaluate);
+        inspection = void 0;
+        append(journal, { kind: "closed-native-rebind-verified", pid: pid2, nativeInputsSent: false, completedExistingControl: true, originalJournalSHA256: digest(text) });
+        put(path.join(root, "claude/activation.json"), JSON.stringify({ ...receipt, pid: pid2, connection: descriptor2 }) + "\n");
+        fs.unlinkSync(marker);
+        return { state: "claude-pack-ready", nativeReady: true, cloudReady: true, coordinators: 3, nativeInputsSent: false, pid: pid2 };
+      }
+    }
+    if (!sameNativeConnection(previous.nativeConnection, receipt.connection)) throw Error("Previous native connection ownership differs.");
+    prove(root, { previous, wait_retired_service: true });
+    let pid, url;
+    if (continuing) {
+      pid = options.pid;
+      url = options.endpoint;
+      const pending = json(marker), text = owned(journal), rows = text.trimEnd().split("\n").map((row) => JSON.parse(row)), first = rows[0];
+      if (Object.keys(pending).sort().join() !== "journal,operationId,previousPid,state" || pending.operationId !== operationId || pending.state !== "may-have-effects" || pending.previousPid !== receipt.pid || pending.journal !== journal || !text.endsWith("\n") || rows.length !== 1 || first.kind !== "closed-native-rebind" || first.operationId !== operationId || first.previousPid !== receipt.pid || JSON.stringify(first.members) !== JSON.stringify(receipt.members) || fs.existsSync(secretPath) || fs.existsSync(path.join(root, "claude/journals", operationId + ".frontdoors.json")) || !sameNativeConnection(readClaudeTaskConnection(path.join(root, "claude/desktop-task-connection.json"), receipt.pid), receipt.connection)) throw Error("Pending launch progressed beyond the exact pre-control phase; preserve its custody.");
+      append(journal, { kind: "closed-native-rebind-continuation", operationId, pid, originalJournalSHA256: digest(text), nativeInputsSent: false });
+    } else {
+      const selected = await (deps.port ?? port)(9229);
+      put(marker, JSON.stringify({ operationId, state: "may-have-effects", previousPid: receipt.pid, journal }) + "\n", true);
+      put(journal, JSON.stringify({ kind: "closed-native-rebind", operationId, members: receipt.members, previousPid: receipt.pid }) + "\n", true);
+      if (!before.pid) launch({ ...args, apply: true });
+      let current = launch({ ...args, apply: false });
+      for (let n = 0; !current.pid && n < 100; n++) {
+        await new Promise((r) => setTimeout(r, 100));
+        current = launch({ ...args, apply: false });
+      }
+      if (!Number.isSafeInteger(current.pid) || current.pid === receipt.pid) throw Error("Exact successor profile process missing.");
+      pid = current.pid;
+      pendingInspection = { port: selected, pid, profile: profile.profile };
+      (deps.activateInspector ?? enableClaudeInspectorMenu)(pid);
+      url = await (deps.endpoint ?? resolveClaudeInspectorEndpoint)(selected);
+      inspection = { url, pid, profile: profile.profile };
+      pendingInspection = void 0;
+    }
+    const native = await evaluate(url, observer(pid, profile.profile, receipt.members, journal, true));
+    checkResult(native, receipt.members);
+    const descriptor = { ...receipt.connection, pid, identity: digest(JSON.stringify({ root, pack: options.pack, operationId })), socket: path.join("/tmp", "topolo-claude-task-" + operationId + ".sock"), secretPath };
+    prove(root, { previous, connection: descriptor });
+    put(secretPath, JSON.stringify({ token: randomBytes(32).toString("hex") }) + "\n", true);
+    const installed = await evaluate(url, nativeClaudeDesktopControlExpression(pid, root, descriptor, secretPath, journal, { coordinators: receipt.members, frontdoors: receipt.members }));
+    if (installed.state !== "native-desktop-task-control-installed") throw Error("Successor closed control is unacknowledged.");
+    const input = path.join(root, "claude/journals", operationId + ".frontdoors.json");
+    (deps.bind ?? bindClaudeFrontdoorHooks)(root, pid, receipt.members.map((m) => ({ key: m.key, cwd: m.cwd, sessionId: m.cliSessionId })), input, void 0, descriptor);
+    const proof = prove(root, { start_service: true, native_proof: true });
+    checkResult(proof.native, receipt.members);
+    if (proof.service?.desktopPid !== pid || JSON.stringify(proof.binding) !== JSON.stringify(receipt.cloud) || proof.native.members.some((m, i) => m.cliSessionId !== receipt.members[i].cliSessionId)) throw Error("Successor dispatcher differs.");
+    const next = { ...receipt, pid, connection: descriptor };
+    put(path.join(root, "claude/desktop-task-connection.json"), JSON.stringify(descriptor) + "\n");
+    const actual = await evaluate(url, `(()=>{if(process.pid!==${pid})throw Error('Native PID changed');const load=process.getBuiltinModule('module').createRequire(process.resourcesPath+'/app.asar/package.json');return{state:'native-profile-verified',pid:process.pid,userData:load('electron').app.getPath('userData'),codeConfig:process.env.CLAUDE_CONFIG_DIR};})()`);
+    acknowledgeClaudeDesktopProfile(root, readClaudeDesktopProfile(root), actual);
+    await (deps.close ?? closeClaudeInspector)(url, pid, profile.profile, evaluate);
+    inspection = void 0;
+    append(journal, { kind: "closed-native-rebind-verified", pid, nativeInputsSent: false });
+    put(path.join(root, "claude/activation.json"), JSON.stringify(next) + "\n");
+    fs.unlinkSync(marker);
+    return { state: "claude-pack-ready", nativeReady: true, cloudReady: true, coordinators: 3, nativeInputsSent: false, pid };
+  } finally {
+    try {
+      if (pendingInspection) {
+        const url = await (deps.endpoint ?? resolveClaudeInspectorEndpoint)(pendingInspection.port);
+        inspection = { url, pid: pendingInspection.pid, profile: pendingInspection.profile };
+      }
+      if (inspection) await (deps.close ?? closeClaudeInspector)(inspection.url, inspection.pid, inspection.profile, evaluate);
+    } finally {
+      await release();
+    }
+  }
+}
+export {
+  closeClaudeInspector,
+  finalizeClaudePack,
+  launchActivatedClaudePack,
+  resolveClaudeInspectorEndpoint,
+  upgradeClaudeControl
+};

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

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import {
+  CLAUDE_NATIVE_QUALIFIER,
+  bindClaudeFrontdoorHooks,
+  claudeLaneExpression,
+  claudeTaskConnectionCoordinators,
+  completeClaudeStartup,
+  configureClaudePack,
+  configureClaudeStartup,
+  ensureClaudeCoordinators,
+  evaluateClaudeMain,
+  lockClaudeLibrary,
+  materializeClaudeHookAdapter,
+  materializeClaudeWorkerGuard,
+  nativeClaudeDesktopControlExpression,
+  nativeClaudeSettingsExpression,
+  nativePackExpression,
+  operateClaudeApprovals,
+  operateClaudeLane,
+  operateClaudeLaneControl,
+  operateClaudeSmoke,
+  prepareClaudeDynamicLane,
+  prepareClaudeNativePlan,
+  prepareClaudePrivateHelperConnection,
+  prepareClaudeStartup,
+  privateClaudeHelperEnvironment,
+  qualifyClaudePython,
+  readClaudePreviousCoordinatorLibrary,
+  readClaudeReadinessContinuation,
+  readClaudeTaskConnection,
+  reconcileClaudeStartupAbsence,
+  recoverClaudeStartup,
+  requestClaudeApprovalControl,
+  requireClaudePrivateQueryEffectQualified,
+  retireClaudeCoordinators,
+  runClaudeLaneHelper,
+  runClaudeSmokeHelper,
+  snapshotClaudeMarkdown,
+  snapshotClaudeWorkerSource,
+  validateInspectorEndpoint,
+  verifyClaudeOrganizationPolicy,
+  verifyClaudePlanContext,
+  verifyClaudePreviousCoordinatorCustody,
+  verifyClaudeReadinessContinuation
+} from "./chunk-UY5LEU5C.js";
+import "./chunk-NYDIAYVY.js";
+export {
+  CLAUDE_NATIVE_QUALIFIER,
+  bindClaudeFrontdoorHooks,
+  claudeLaneExpression,
+  claudeTaskConnectionCoordinators,
+  completeClaudeStartup,
+  configureClaudePack,
+  configureClaudeStartup,
+  ensureClaudeCoordinators,
+  evaluateClaudeMain,
+  lockClaudeLibrary,
+  materializeClaudeHookAdapter,
+  materializeClaudeWorkerGuard,
+  nativeClaudeDesktopControlExpression,
+  nativeClaudeSettingsExpression,
+  nativePackExpression,
+  operateClaudeApprovals,
+  operateClaudeLane,
+  operateClaudeLaneControl,
+  operateClaudeSmoke,
+  prepareClaudeDynamicLane,
+  prepareClaudeNativePlan,
+  prepareClaudePrivateHelperConnection,
+  prepareClaudeStartup,
+  privateClaudeHelperEnvironment,
+  qualifyClaudePython,
+  readClaudePreviousCoordinatorLibrary,
+  readClaudeReadinessContinuation,
+  readClaudeTaskConnection,
+  reconcileClaudeStartupAbsence,
+  recoverClaudeStartup,
+  requestClaudeApprovalControl,
+  requireClaudePrivateQueryEffectQualified,
+  retireClaudeCoordinators,
+  runClaudeLaneHelper,
+  runClaudeSmokeHelper,
+  snapshotClaudeMarkdown,
+  snapshotClaudeWorkerSource,
+  validateInspectorEndpoint,
+  verifyClaudeOrganizationPolicy,
+  verifyClaudePlanContext,
+  verifyClaudePreviousCoordinatorCustody,
+  verifyClaudeReadinessContinuation
+};