@staix/agent-hub 0.4.0 → 0.6.0

package/src/cli/main.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env bun
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 import { ControlClient, readControl } from "../hub/control-client.ts";
 import { loadConfig } from "../hub/daemon.ts";
 import { projectContext } from "../hub/project.ts";
@@ -17,6 +18,12 @@ import { nextStep, parseList, pluginState, type InstalledPlugin, type Marketplac
 import { CLASSES } from "../hub/board.ts";
 import { VERSION } from "../version.ts";
 import { createInterface } from "node:readline/promises";
+import { assertLifecycleAvailable, readOperation } from "../hub/recovery-store.ts";
+import { childEnv } from "../hub/child-process.ts";
+import { abortRecovery, createOperation, publicOperation, registeredProjects, runRecovery, type RecoveryOperation } from "./upgrade.ts";
+import { makeRecoveryDriver, makeUpgradePlan, preserveSource } from "./upgrade-runtime.ts";
+import { recordTerminalLaunch } from "./terminal-recovery.ts";
+import { ensureMlx, inspectMlx, stopMlx } from "../models/mlx.ts";
 
 const USAGE = `agent-hub ${VERSION}: Claude Code, Codex and Kimi as peers in one project directory
 
@@ -29,9 +36,14 @@ const USAGE = `agent-hub ${VERSION}: Claude Code, Codex and Kimi as peers in one
   ahub setup [--yes]            install or update the Claude Code channel plugin from this package, then run doctor
   ahub init                     write .agenthub/config.json and the CLAUDE.md / AGENTS.md marker blocks
   ahub up [--unattended]        start the daemon for this directory
+  ahub upgrade --to <version> [--dry-run] [--yes]   review and upgrade running projects
+  ahub restart [--dry-run] [--yes]                 recover this project's runtime
+  ahub recovery status|resume|abort <operation-id> inspect, resume or cancel a preflight
   ahub claude [args...]         launch Claude Code with the hub channel   [--unattended]
   ahub codex [args...]          start the Codex adapter and attach the TUI [--unattended]
   ahub kimi [--model <alias>]   start Kimi headless under ACP
+  ahub pi [--mode headless|tui] [--backend auto|dgx|mlx] [--session-id <id>] [--session-file <path>]  start Pi
+  ahub models setup|status|start|stop  manage the pinned local MLX runtime
   ahub local [--route <id> | --model <id>]
                                start the hub-native worker on the self-hosted models (routing.toml)
   ahub say [@peer ...] <text>   send as the console user (no @peer = broadcast); delivered at once,
@@ -65,13 +77,13 @@ const [cmd = "help", ...args] = argv;
 let selected: { root: string; stateDir: string };
 try {
   if (selector) {
-    const registry = new Registry();
-    try {
-      const known = registry.get(selector);
+    const projects = registeredProjects();
+    {
+      const known = projects.find((p) => p.id === selector);
       const context = known ?? projectContext(selector, {});
-      const registered = known ?? registry.list().find((p) => p.root === context.root);
+      const registered = known ?? projects.find((p) => p.root === context.root);
       selected = registered ?? context;
-    } finally { registry.close(); }
+    }
   } else selected = projectContext(process.cwd());
 } catch (error) { fail((error as Error).message); }
 const cwd = selected.root;
@@ -95,11 +107,39 @@ async function healthy(): Promise<boolean> {
 }
 
 function exec(bin: string, argv: string[]): never {
-  const res = spawnSync(bin, argv, { cwd, stdio: "inherit", env: { ...process.env, AGENTHUB_STATE_DIR: stateDir, AGENTHUB_PROJECT_DIR: cwd } });
+  const res = spawnSync(bin, argv, { cwd, stdio: "inherit", env: { ...childEnv(), AGENTHUB_STATE_DIR: stateDir, AGENTHUB_PROJECT_DIR: cwd } });
+  if (res.error) fail(`cannot run ${bin}: ${res.error.message}`);
+  process.exit(res.status ?? 1);
+}
+
+function execWithEnv(bin: string, argv: string[], extra: NodeJS.ProcessEnv): never {
+  const env: NodeJS.ProcessEnv = { ...extra, AGENTHUB_STATE_DIR: stateDir, AGENTHUB_PROJECT_DIR: cwd };
+  delete env.AGENTHUB_RECOVERY_OPERATION;
+  delete env.AGENTHUB_UNATTENDED;
+  const res = spawnSync(bin, argv, { cwd, stdio: "inherit", env });
   if (res.error) fail(`cannot run ${bin}: ${res.error.message}`);
   process.exit(res.status ?? 1);
 }
 
+function piFlags(): { mode: "headless" | "tui"; backend?: "auto" | "dgx" | "mlx"; model?: string; sessionId?: string; sessionFile?: string } {
+  for (const flag of ["--mode", "--backend", "--model", "--session-id", "--session-file"]) {
+    const index = args.indexOf(flag);
+    if (index >= 0 && (!args[index + 1] || args[index + 1]!.startsWith("--"))) fail(`${flag} needs a value`);
+  }
+  const mode = (args.includes("--mode") ? args[args.indexOf("--mode") + 1] : "headless") as string;
+  const backend = (args.includes("--backend") ? args[args.indexOf("--backend") + 1] : undefined) as string | undefined;
+  const model = args.includes("--model") ? args[args.indexOf("--model") + 1] : undefined;
+  const sessionId = args.includes("--session-id") ? args[args.indexOf("--session-id") + 1] : undefined;
+  const sessionFile = args.includes("--session-file") ? args[args.indexOf("--session-file") + 1] : undefined;
+  const valueFlags = new Set(["--mode", "--backend", "--model", "--session-id", "--session-file"]);
+  for (let i = 0; i < args.length; i++) {
+    if (!valueFlags.has(args[i]!)) fail(`unknown Pi option: ${args[i]}`);
+    i++;
+  }
+  if (!["headless", "tui"].includes(mode) || (backend !== undefined && !["auto", "dgx", "mlx"].includes(backend)) || (sessionId && sessionFile)) fail("usage: ahub pi [--mode headless|tui] [--backend auto|dgx|mlx] [--model <alias>] [--session-id <id> | --session-file <path>]");
+  return { mode: mode as "headless" | "tui", ...(backend ? { backend: backend as "auto" | "dgx" | "mlx" } : {}), ...(model ? { model } : {}), ...(sessionId ? { sessionId } : {}), ...(sessionFile ? { sessionFile } : {}) };
+}
+
 async function projectRows() {
   const registry = new Registry();
   try { return await Promise.all(registry.list().map(async (project) => ({ ...project, ...await inspectProject(project) }))); }
@@ -166,7 +206,56 @@ async function hold(t: "pause" | "resume"): Promise<void> {
   console.log(`${args[0]} is ${res.state}`);
 }
 
+function spawnRecovery(operation: RecoveryOperation): void {
+  const child = spawn(process.execPath, [join(operation.sourceRoot, "src/cli/main.js"), "recovery-run", operation.id], {
+    cwd, detached: true, stdio: "ignore", env: { ...process.env, AGENTHUB_RECOVERY_OPERATION: operation.id },
+  });
+  child.on("error", () => console.error(`runner launch failed; use ahub recovery resume ${operation.id}`));
+  child.unref();
+  console.log(`Recovery operation ${operation.id} scheduled.\nahub recovery status ${operation.id}`);
+}
+
+async function upgrade(kind: "restart" | "upgrade"): Promise<void> {
+  const { one, rest } = takeFlags(args, ["--to"], []);
+  if (rest.some((a) => !["--dry-run", "--yes"].includes(a)) || (kind === "restart" && one["--to"])) fail("usage: ahub upgrade --to <version> [--dry-run] [--yes] | ahub restart [--dry-run] [--yes]");
+  if (kind === "upgrade" && !one["--to"]) fail("upgrade requires --to <exact-version>");
+  if (kind === "upgrade" && selector) fail("upgrade changes the shared package/plugin; omit --project to review all affected running projects");
+  const plan = await makeUpgradePlan(kind, one["--to"] ?? VERSION, kind === "restart" ? cwd : undefined);
+  console.log(JSON.stringify(plan, null, 2));
+  if (args.includes("--dry-run")) return;
+  if (plan.blockers.length || plan.projects.some((p) => p.blockers.length)) fail("plan has blockers; no runtime was changed");
+  assertLifecycleAvailable();
+  if (!args.includes("--yes")) {
+    if (!process.stdin.isTTY) fail("review --dry-run and use --yes in non-interactive sessions");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      if (!/^(y|yes)$/i.test((await rl.question("Apply this project list and restore its sessions? [y/N] ")).trim())) return;
+    } finally { rl.close(); }
+  }
+  const current = await makeUpgradePlan(kind, plan.version, kind === "restart" ? cwd : undefined);
+  if (current.fingerprint !== plan.fingerprint) fail("plan changed during review; run the command again");
+  const sourceRoot = preserveSource(plan);
+  const operation = createOperation(plan, sourceRoot);
+  spawnRecovery(operation);
+}
+
 const commands: Record<string, () => Promise<void> | void> = {
+  upgrade: () => upgrade("upgrade"),
+  restart: () => upgrade("restart"),
+  recovery: async () => {
+    const [action, id] = args;
+    if (args.length !== 2 || !id || !["status", "resume", "abort"].includes(action ?? "")) fail("usage: ahub recovery status|resume|abort <operation-id>");
+    const operation = readOperation<RecoveryOperation>(id);
+    if (action === "status") console.log(JSON.stringify(publicOperation(operation), null, 2));
+    else if (action === "abort") { await abortRecovery(id, makeRecoveryDriver()); console.log("preflight cancelled; no committed transition was rolled back"); }
+    else if (["completed", "cancelled"].includes(operation.phase)) console.log(`recovery is already ${operation.phase}`);
+    else spawnRecovery(operation);
+  },
+  "recovery-run": async () => {
+    if (args.length !== 1 || process.env.AGENTHUB_RECOVERY_OPERATION !== args[0]) fail("recovery-run is an internal command");
+    const result = await runRecovery(args[0]!, makeRecoveryDriver());
+    if (result.phase !== "completed") process.exitCode = 1;
+  },
   help: () => console.log(USAGE),
   "--version": () => console.log(VERSION),
   version: () => console.log(VERSION),
@@ -214,6 +303,7 @@ const commands: Record<string, () => Promise<void> | void> = {
   },
 
   setup: async () => {
+    assertLifecycleAvailable();
     const root = join(import.meta.dir, "..", "..");
     const state = () => {
       const out = (argv: string[]) => spawnSync("claude", argv, { encoding: "utf8" }).stdout ?? "";
@@ -239,6 +329,7 @@ const commands: Record<string, () => Promise<void> | void> = {
   },
 
   init: () => {
+    assertLifecycleAvailable();
     const changed = init(cwd);
     registeredProject();
     console.log(changed.length ? changed.map((p) => `wrote ${p}`).join("\n") : "already up to date");
@@ -258,7 +349,13 @@ const commands: Record<string, () => Promise<void> | void> = {
     console.log(`ahub up (ws://127.0.0.1:${status.controlPort}), state in ${stateDir}`);
   },
 
-  claude: () => {
+  claude: async () => {
+    assertLifecycleAvailable();
+    const control = readControl(stateDir);
+    if (control?.instanceId) {
+      process.env.AGENTHUB_INSTANCE_ID = control.instanceId;
+      await recordTerminalLaunch("claude", cwd, stateDir, control.instanceId);
+    }
     // `--settings` outranks project and user settings, so the tee has to wrap whichever status line would have won:
     // project local, then project, then user.
     let original: { command?: string; refreshInterval?: number; padding?: number } | undefined;
@@ -275,11 +372,14 @@ const commands: Record<string, () => Promise<void> | void> = {
   },
 
   codex: async () => {
+    assertLifecycleAvailable();
     const launch0 = buildLaunch("codex", args, { unattended: unattendedEnv, proxyUrl: "pending" }); // refuse bad flags before starting anything
     const hub = await connect();
-    const res = await hub.request({ t: "start", peer: "codex" });
+    const res = await hub.request({ t: "start", peer: "codex", operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
     hub.close();
     if (!res.ok) fail(res.error);
+    const control = readControl(stateDir);
+    if (control?.instanceId) await recordTerminalLaunch("codex", cwd, stateDir, control.instanceId);
     const launch = buildLaunch("codex", args, { unattended: unattendedEnv, proxyUrl: res.proxyUrl, codexBin: loadConfig(cwd).codex_bin });
     if (launch0.warning) console.error(launch0.warning);
     exec(launch.cmd, launch.args);
@@ -289,21 +389,58 @@ const commands: Record<string, () => Promise<void> | void> = {
     const i = args.indexOf("--model");
     const model = i === -1 ? undefined : args[i + 1] ?? fail("--model needs an alias");
     const hub = await connect();
-    const res = await hub.request({ t: "start", peer: "kimi", args: { model } });
+    const res = await hub.request({ t: "start", peer: "kimi", args: { model }, operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
     hub.close();
     if (!res.ok) fail(res.error);
     console.log(res.already ? "kimi is already attached" : 'kimi attached (headless). Talk to it with: ahub say @kimi "..."');
   },
 
+  pi: async () => {
+    const options = piFlags();
+    const hub = await connect();
+    const res = await hub.request({ t: "start", peer: "pi", args: options, operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
+    hub.close();
+    if (!res.ok) fail(res.error);
+    if (options.mode === "tui") {
+      const launch = res.launch;
+      if (!launch || typeof launch.cmd !== "string" || !Array.isArray(launch.args) || !launch.args.every((a: unknown) => typeof a === "string") || !launch.env || typeof launch.env !== "object") fail("Pi TUI launch metadata was not verified");
+      const launchEnv = { ...(launch.env as NodeJS.ProcessEnv) };
+      delete launchEnv.AGENTHUB_RECOVERY_OPERATION;
+      delete launchEnv.AGENTHUB_UNATTENDED;
+      const control = readControl(stateDir);
+      if (control?.instanceId) await recordTerminalLaunch("pi", cwd, stateDir, control.instanceId);
+      return execWithEnv(launch.cmd, launch.args, launchEnv);
+    }
+    console.log(res.already ? "pi is already attached" : 'pi attached (headless). Talk to it with: ahub say @pi "..."');
+  },
+
   local: async () => {
     const opt = (flag: string) => (args.includes(flag) ? args[args.indexOf(flag) + 1] ?? fail(`${flag} needs a value`) : undefined);
     const hub = await connect();
-    const res = await hub.request({ t: "start", peer: "local", args: { route: opt("--route"), model: opt("--model") } });
+    const res = await hub.request({ t: "start", peer: "local", args: { route: opt("--route"), model: opt("--model") }, operationId: process.env.AGENTHUB_RECOVERY_OPERATION });
     hub.close();
     if (!res.ok) fail(res.error);
     console.log(res.already ? "local is already attached" : `local attached on ${res.model}. Give it work with: ahub say @local "..."`);
   },
 
+  models: async () => {
+    const action = args[0] ?? "status";
+    const configured = loadConfig(cwd).mlx;
+    const runtimeDir = configured.runtimeDir ? resolve(cwd, configured.runtimeDir) : join(homedir(), ".agenthub", "runtimes", "mlx");
+    const modelPath = configured.modelPath ? resolve(cwd, configured.modelPath) : join(homedir(), ".agenthub", "models", "qwen3-8b-mlx");
+    const mlxOptions = { ...configured, runtimeDir, modelPath };
+    if (action === "status") return console.log(JSON.stringify(await inspectMlx(mlxOptions), null, 2));
+    if (action === "start") { const handle = await ensureMlx(mlxOptions); return console.log(JSON.stringify(handle.status(), null, 2)); }
+    if (action === "stop") { await stopMlx(mlxOptions); return console.log("MLX stopped"); }
+    if (action !== "setup") fail("usage: ahub models setup|status|start|stop");
+    const python = join(runtimeDir, "bin", "python");
+    const run = (argv: string[]) => { const result = spawnSync(argv[0]!, argv.slice(1), { cwd, stdio: "inherit" }); if (result.status !== 0) fail(`models setup failed: ${argv.join(" ")}`); };
+    if (!existsSync(python)) run(["uv", "venv", "--python", "3.12", runtimeDir]);
+    run(["uv", "pip", "install", "--python", python, "mlx-lm==0.31.3"]);
+    run([python, "-c", `from huggingface_hub import snapshot_download; snapshot_download(repo_id='Qwen/Qwen3-8B-MLX-4bit', revision='383413e909f3bc5303ce195ebbdf0339c5a1a2a3', local_dir=${JSON.stringify(modelPath)}, token=False)`]);
+    console.log(`MLX runtime and pinned model prepared at ${runtimeDir}`);
+  },
+
   say: async () => {
     const lead = args.findIndex((a) => !/^@[a-z][a-z0-9-]*$/.test(a)); // only leading @tokens are recipients
     const to = args.slice(0, lead === -1 ? args.length : lead).map((a) => a.slice(1));
@@ -435,6 +572,8 @@ const commands: Record<string, () => Promise<void> | void> = {
     console.log(`hub pid ${status.pid}, control 127.0.0.1:${status.controlPort}, ${status.cwd}`);
     const peers = Object.entries(status.peers as Record<string, { state: string; queued: number }>);
     for (const [id, p] of peers) console.log(`  ${id.padEnd(8)} ${p.state.padEnd(8)} queued ${p.queued}${(p as any).paused ? `  (${(p as any).paused})` : ""}${(p as any).servedBy ? `  last call: ${(p as any).servedBy}` : ""}`);
+    const models = (status as any).models?.backends as any[] | undefined;
+    if (models?.length) for (const backend of models) console.log(`  model    ${backend.kind ?? "unknown"}/${backend.alias ?? "unknown"} ${backend.state ?? "unknown"} active ${backend.active ?? 0}${backend.requestedModel ? ` requested ${backend.requestedModel}` : ""}${backend.actualModel ? ` actual ${backend.actualModel}` : ""}${backend.provider ? ` provider ${backend.provider}` : ""}`);
     if (status.switchyard) console.log(`  switchyard: ${status.switchyard}`);
     const counts = Object.entries(status.tasks ?? {}).map(([s, n]) => `${n} ${s}`).join(", ");
     if (counts) console.log(`  tasks: ${counts} (ahub board)`);
@@ -480,6 +619,9 @@ const commands: Record<string, () => Promise<void> | void> = {
     row(!!omni.apiKey(), "omniroute key", omni.apiKey() ? "present" : "missing: set OMNIROUTE_API_KEY or omniroute.api_key_file in .agenthub/config.json");
     const sy = spawnSync(process.env.AGENTHUB_SWITCHYARD_BIN ?? "switchyard-server", ["--version"], { encoding: "utf8" });
     row(sy.status === 0 ? true : undefined, "switchyard", sy.status === 0 ? sy.stdout.trim() : "not installed: ahub local uses fixed_model on OmniRoute (cargo install --locked switchyard-server)");
+    const mlxConfig = loadConfig(cwd).mlx;
+    const mlx = await inspectMlx({ ...mlxConfig, runtimeDir: mlxConfig.runtimeDir ? resolve(cwd, mlxConfig.runtimeDir) : undefined, modelPath: mlxConfig.modelPath ? resolve(cwd, mlxConfig.modelPath) : undefined });
+    row(mlx.state === "ready" || mlx.state === "stopped", "pi mlx", `${mlx.state}${mlx.model ? ` (${mlx.model})` : ""}${mlx.lastError ? `: ${mlx.lastError}` : ""}`);
 
     const memory = new MemoryClient();
     const mem = await memory.health();

package/src/cli/recovery-package.ts

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { hubHome } from "../hub/project.ts";
+
+export type CommandResult = { code: number; stdout: string; stderr: string };
+export type RunCommand = (args: string[], options?: { cwd?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number }) => Promise<CommandResult>;
+export const runCommand: RunCommand = (args, options = {}) => new Promise((resolve, reject) => {
+  const child = spawn(args[0]!, args.slice(1), { cwd: options.cwd, env: options.env, stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "", stderr = "", exceeded = false;
+  const append = (old: string, value: unknown) => {
+    const next = old + String(value);
+    if (next.length > 2_000_000) { exceeded = true; child.kill("SIGTERM"); }
+    return next.slice(-2_000_000);
+  };
+  child.stdout.on("data", (v) => { stdout = append(stdout, v); });
+  child.stderr.on("data", (v) => { stderr = append(stderr, v); });
+  let timedOut = false;
+  const timer = setTimeout(() => { timedOut = true; child.kill("SIGTERM"); }, options.timeoutMs ?? 60_000);
+  const hardTimer = setTimeout(() => child.kill("SIGKILL"), (options.timeoutMs ?? 60_000) + 3000);
+  child.on("error", (e) => { clearTimeout(timer); clearTimeout(hardTimer); reject(e); });
+  child.on("close", (code) => {
+    clearTimeout(timer); clearTimeout(hardTimer);
+    if (timedOut || exceeded) reject(new Error(`command ${args[0]} ${timedOut ? "timed out" : "exceeded output limit"}; inspect state before retrying`));
+    else resolve({ code: code ?? 1, stdout, stderr });
+  });
+});
+
+export function exactVersion(version: string): string {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) throw new Error("--to requires an exact package version");
+  return version;
+}
+
+export function packageDigest(root: string): string {
+  const hash = createHash("sha256");
+  const visit = (directory: string, prefix = "") => {
+    for (const item of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+      if (item.isSymbolicLink()) throw new Error("runtime package must not contain symlinks");
+      const name = `${prefix}${item.name}`;
+      if (item.isDirectory()) visit(join(directory, item.name), `${name}/`);
+      else { hash.update(name); hash.update("\0"); hash.update(readFileSync(join(directory, item.name))); hash.update("\0"); }
+    }
+  };
+  // Only runtime assets; never copy or hash a checkout's private state or dependencies.
+  for (const name of ["src", "plugins", "templates", ".claude-plugin"]) visit(join(root, name), `${name}/`);
+  hash.update(readFileSync(join(root, "package.json")));
+  return hash.digest("hex");
+}
+
+export function verifyPackage(root: string, version: string): string {
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const plugin = JSON.parse(readFileSync(join(root, "plugins/agent-hub/.claude-plugin/plugin.json"), "utf8"));
+  if (pkg.name !== "@staix/agent-hub" || pkg.version !== version || plugin.version !== version ||
+      !existsSync(join(root, "src/cli/main.js"))) throw new Error("staged package identity/version mismatch");
+  return packageDigest(root);
+}
+
+export async function registryRelease(version: string, run: RunCommand = runCommand): Promise<{ version: string; integrity: string }> {
+  exactVersion(version);
+  const result = await run(["npm", "view", `@staix/agent-hub@${version}`, "version", "dist.integrity", "--json"], { timeoutMs: 30_000 });
+  if (result.code !== 0) throw new Error(`registry metadata unavailable for @staix/agent-hub@${version}`);
+  const data = JSON.parse(result.stdout);
+  if (data.version !== version || typeof data["dist.integrity"] !== "string" || !data["dist.integrity"].startsWith("sha512-")) {
+    throw new Error("registry returned an unexpected release identity");
+  }
+  return { version, integrity: data["dist.integrity"] };
+}
+
+/** Stage outside the mutable global install; retain successful versions for recovery. */
+export async function stageRelease(version: string, integrity: string, run: RunCommand = runCommand, home = hubHome()): Promise<{ root: string; digest: string }> {
+  exactVersion(version);
+  const base = join(home, "releases");
+  const destination = join(base, version);
+  const root = join(destination, "node_modules/@staix/agent-hub");
+  if (existsSync(destination)) {
+    const saved = JSON.parse(readFileSync(join(destination, "verified.json"), "utf8"));
+    const digest = verifyPackage(root, version);
+    if (saved.integrity !== integrity || saved.digest !== digest) throw new Error("cached release changed; refusing it");
+    return { root, digest };
+  }
+  mkdirSync(base, { recursive: true, mode: 0o700 });
+  const temporary = join(base, `.stage-${randomUUID()}`);
+  mkdirSync(temporary, { mode: 0o700 });
+  try {
+    writeFileSync(join(temporary, "package.json"), JSON.stringify({ private: true, dependencies: { "@staix/agent-hub": version } }));
+    const install = await run([process.execPath, "install", "--ignore-scripts", "--cwd", temporary], { timeoutMs: 180_000 });
+    if (install.code !== 0) throw new Error("package staging failed; installed runtime was not changed");
+    const staged = join(temporary, "node_modules/@staix/agent-hub");
+    const digest = verifyPackage(staged, version);
+    // Bun's lock records the registry integrity actually used, not a later metadata query.
+    const lock = JSON.parse(readFileSync(join(temporary, "bun.lock"), "utf8").replace(/,\s*([}\]])/g, "$1"));
+    const row = lock.packages?.["@staix/agent-hub"];
+    if (!Array.isArray(row) || !row.includes(integrity)) throw new Error("staged package integrity differs from the reviewed release");
+    writeFileSync(join(temporary, "verified.json"), JSON.stringify({ integrity, digest }), { mode: 0o600 });
+    renameSync(temporary, destination);
+    return { root, digest };
+  } finally { rmSync(temporary, { recursive: true, force: true }); }
+}

package/src/cli/statusline-tee.ts

@@ -4,13 +4,14 @@
 // user's own status line command: it records the limits for the hub's budget coordinator and then runs the original
 // command with the same input, so the status line looks exactly as before. It must never fail the render.
 import { spawnSync } from "node:child_process";
-import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 const input = await Bun.stdin.text();
 let own = "";
 try {
-  const limits = JSON.parse(input).rate_limits;
+  const parsed = JSON.parse(input);
+  const limits = parsed.rate_limits;
   const pct = (w: any) => (typeof w?.used_percentage === "number" ? `${Math.round(w.used_percentage)}%` : "-");
   if (limits) own = `agent-hub  5h ${pct(limits.five_hour)}  wk ${pct(limits.seven_day)}`;
   const dir = process.env.AGENTHUB_STATE_DIR;
@@ -20,6 +21,14 @@ try {
     writeFileSync(`${file}.tmp`, JSON.stringify({ at: Date.now(), rate_limits: limits }));
     renameSync(`${file}.tmp`, file);
   }
+  const sessionId = typeof parsed.session_id === "string" ? parsed.session_id : typeof parsed.sessionId === "string" ? parsed.sessionId : "";
+  if (sessionId && dir) {
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, "claude-session.json");
+    writeFileSync(`${file}.tmp`, JSON.stringify({ at: Date.now(), sessionId, ...(process.env.AGENTHUB_INSTANCE_ID ? { instanceId: process.env.AGENTHUB_INSTANCE_ID } : {}), ...(process.env.AGENTHUB_LAUNCH_ID ? { launchId: process.env.AGENTHUB_LAUNCH_ID } : {}) }), { mode: 0o600 });
+    chmodSync(`${file}.tmp`, 0o600);
+    renameSync(`${file}.tmp`, file);
+  }
 } catch {
   // not JSON, or the state dir is gone: the status line still has to render
 }