midsummer-sol 0.2.1 → 0.2.2

package/sol.js

@@ -3312,6 +3312,141 @@ function clearMergeConflicts(solDir2) {
 var configPath = (solDir2) => join6(solDir2, "sol.json"), semanticPath = (solDir2) => join6(solDir2, "SEMANTIC"), mergeConflictsPath = (solDir2) => join6(solDir2, "MERGE_CONFLICTS");
 var init_test_gate = () => {};
 
+// src/bin/mcp-http.ts
+var exports_mcp_http = {};
+__export(exports_mcp_http, {
+  serveMcpHttp: () => serveMcpHttp,
+  resolveMcpToken: () => resolveMcpToken,
+  parseStandaloneHttp: () => parseStandaloneHttp
+});
+import { randomUUID, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { createServer } from "node:http";
+function tokenMatches(provided, expected) {
+  const a = Buffer.from(provided);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length)
+    return false;
+  return timingSafeEqual3(a, b);
+}
+function bearer(req) {
+  const h = req.headers["authorization"];
+  if (typeof h !== "string")
+    return;
+  const m = /^Bearer\s+(.+)$/i.exec(h.trim());
+  return m ? m[1].trim() : undefined;
+}
+function writeJson(res, status, body) {
+  const s = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(s);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const c of req)
+    chunks.push(c);
+  if (chunks.length === 0)
+    return;
+  const raw = Buffer.concat(chunks).toString("utf8");
+  if (!raw.trim())
+    return;
+  return JSON.parse(raw);
+}
+async function serveMcpHttp(buildServer, opts) {
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  const { isInitializeRequest } = await import("@modelcontextprotocol/sdk/types.js");
+  const port = opts.port ?? 8765;
+  const host = opts.host ?? "127.0.0.1";
+  const transports = new Map;
+  const http = createServer(async (req, res) => {
+    try {
+      const tok = bearer(req);
+      if (!tok || !tokenMatches(tok, opts.token)) {
+        res.setHeader("WWW-Authenticate", "Bearer");
+        writeJson(res, 401, { jsonrpc: "2.0", error: { code: -32001, message: "unauthorized: a valid Authorization: Bearer token is required" }, id: null });
+        return;
+      }
+      const url = (req.url ?? "").split("?")[0];
+      if (url !== MCP_PATH) {
+        writeJson(res, 404, { jsonrpc: "2.0", error: { code: -32601, message: `not found — the MCP endpoint is ${MCP_PATH}` }, id: null });
+        return;
+      }
+      const sessionId = req.headers["mcp-session-id"];
+      const sid = typeof sessionId === "string" ? sessionId : undefined;
+      if (req.method === "POST") {
+        const body = await readBody(req);
+        let transport = sid ? transports.get(sid) : undefined;
+        if (!transport) {
+          if (sid || !isInitializeRequest(body)) {
+            writeJson(res, 400, { jsonrpc: "2.0", error: { code: -32000, message: "no valid session — send an initialize request first" }, id: null });
+            return;
+          }
+          transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id) => void transports.set(id, transport)
+          });
+          transport.onclose = () => {
+            if (transport.sessionId)
+              transports.delete(transport.sessionId);
+          };
+          const server = await buildServer();
+          await server.connect(transport);
+        }
+        await transport.handleRequest(req, res, body);
+        return;
+      }
+      if (req.method === "GET" || req.method === "DELETE") {
+        const transport = sid ? transports.get(sid) : undefined;
+        if (!transport) {
+          writeJson(res, 400, { jsonrpc: "2.0", error: { code: -32000, message: "unknown or missing Mcp-Session-Id" }, id: null });
+          return;
+        }
+        await transport.handleRequest(req, res);
+        return;
+      }
+      writeJson(res, 405, { jsonrpc: "2.0", error: { code: -32000, message: "method not allowed" }, id: null });
+    } catch (e) {
+      if (!res.headersSent) {
+        writeJson(res, 500, { jsonrpc: "2.0", error: { code: -32603, message: "internal error: " + (e instanceof Error ? e.message : String(e)) }, id: null });
+      } else {
+        try {
+          res.end();
+        } catch {}
+      }
+    }
+  });
+  await new Promise((resolve2, reject) => {
+    http.once("error", reject);
+    http.listen(port, host, () => {
+      http.off("error", reject);
+      process.stderr.write(`${opts.label} MCP (HTTP) listening on http://${host}:${port}${MCP_PATH} — Authorization: Bearer required
+`);
+      resolve2();
+    });
+  });
+  await new Promise(() => {});
+}
+function resolveMcpToken(flagToken) {
+  const t = (flagToken ?? process.env.SOL_MCP_TOKEN ?? "").trim();
+  return t.length ? t : undefined;
+}
+function parseStandaloneHttp(argv, label = "sol") {
+  if (!argv.includes("--http"))
+    return;
+  const val = (name) => {
+    const i = argv.indexOf(name);
+    return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
+  };
+  const token = resolveMcpToken(val("--token"));
+  if (!token) {
+    process.stderr.write("refusing to start an OPEN HTTP MCP — set SOL_MCP_TOKEN (or --token <T>). every request must send `Authorization: Bearer <token>`.\n");
+    process.exit(1);
+  }
+  const portRaw = val("--port");
+  return { token, port: portRaw ? Number(portRaw) : undefined, host: val("--host"), label };
+}
+var MCP_PATH = "/mcp";
+var init_mcp_http = () => {};
+
 // src/secret/store.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
 import { createHash as createHash4 } from "node:crypto";
@@ -4468,9 +4603,11 @@ function resolveAll(world) {
   return world.manifest.order.map((e) => resolveOne(world, e));
 }
 function audienceFor(world, env, entryAud) {
-  if (entryAud && entryAud.length)
-    return entryAud;
-  return world.files[env]?.audience ?? [];
+  const base = entryAud && entryAud.length ? entryAud : world.files[env]?.audience ?? [];
+  const runtime = world.manifest.runtime[env];
+  if (runtime && !base.includes(runtime))
+    return [...base, runtime];
+  return base;
 }
 function ensureEnvDir(solDir2) {
   mkdirSync6(envDir(solDir2), { recursive: true });
@@ -4561,7 +4698,14 @@ function validateWorld(solDir2, world, opts = {}) {
         const actual = new Set(recipientsOf(box));
         const expected = new Set(resolvedAud.accountIds);
         const extra = [...actual].filter((a) => !expected.has(a));
-        const missing = [...expected].filter((a) => !actual.has(a));
+        let missing = [...expected].filter((a) => !actual.has(a));
+        const runtimeHandle2 = world.manifest.runtime[r.env];
+        const runtimeAccts = new Set((runtimeHandle2 ? world.gate.handles[runtimeHandle2] ?? [] : []).map((rec) => rec.accountId));
+        const missingRuntime = missing.filter((a) => runtimeAccts.has(a));
+        missing = missing.filter((a) => !runtimeAccts.has(a));
+        if (missingRuntime.length) {
+          issues.push({ severity: "warn", check: "audience-integrity", message: `${r.env}/${s.name}: the runtime recipient [${missingRuntime.join(", ")}] joined the env @audience after this value was sealed — it can't inject this secret yet. reseal it (\`sol secret set ${s.name} --env ${r.env}\`) to include the runtime.` });
+        }
         if (extra.length || missing.length) {
           issues.push({ severity: "error", check: "audience-integrity", message: `${r.env}/${s.name}: sealed recipients drift from the audience (missing: [${missing.join(", ")}], extra: [${extra.join(", ")}]) — reseal with \`sol secret set\` or \`sol secret audience\`` });
         }
@@ -7429,7 +7573,9 @@ function secretInject(ctx, args) {
     ctx.die("usage: sol secret inject --env E -- <cmd> [args...]");
   const cmd = args.slice(dashdash + 1);
   const world = loadWorld(ctx.solDir);
-  const self = ctx.loadSelfIdentity();
+  const runtimeRoot = process.env.SOL_RUNTIME_RECOVERY_CODE;
+  const self = runtimeRoot ? runtimeSelfFromRoot(env, runtimeRoot) : ctx.loadSelfIdentity();
+  const recipientActor = self?.accountId ?? ctx.actor;
   const injected = {};
   let revealedCount = 0;
   for (const s of resolveOne(world, env).secrets) {
@@ -7446,7 +7592,7 @@ function secretInject(ctx, args) {
     revealedCount++;
   }
   if (!revealedCount)
-    ctx.die(`no secrets in ${env} are readable by ${ctx.actor} — are you a recipient? (set SOL_RECOVERY_CODE)`);
+    ctx.die(`no secrets in ${env} are readable by ${recipientActor} — are you a recipient? (set SOL_RECOVERY_CODE, or SOL_RUNTIME_RECOVERY_CODE when injecting from the runtime)`);
   process.stderr.write(`sol: injecting ${revealedCount} secret(s) into the subprocess env: ${Object.keys(injected).join(", ")}
 `);
   const res = spawnSync2(cmd[0], cmd.slice(1), { stdio: "inherit", env: { ...process.env, ...injected } });
@@ -7563,6 +7709,11 @@ async function runtimeProvision(ctx, args) {
   const { gate } = await audienceAdd(audCtx, world.gate, prov.handle, prov.accountId, prov.x25519Pub);
   writeAudienceDoc(ctx.solDir, gate);
   journal2(ctx, id, { op: "audience-add", handle: prov.handle, members: memberSnapshot(gate, prov.handle), recipientAtOp: true, prevAud, newAud: (gate.handles[prov.handle] ?? []).map((r) => r.accountId), at: Date.now() });
+  const envFile = world.files[env];
+  if (envFile && !(envFile.audience ?? []).includes(prov.handle)) {
+    envFile.audience = [...envFile.audience ?? [], prov.handle];
+    writeEnvFile(ctx.solDir, envFile);
+  }
   world.manifest.runtime[env] = prov.handle;
   writeManifest(ctx.solDir, world.manifest);
   regenerateSchema(ctx.solDir, loadWorld(ctx.solDir));
@@ -7866,16 +8017,9 @@ __export(exports_sol_secret_mcp, {
 });
 import { existsSync as existsSync16 } from "node:fs";
 import { join as join16 } from "node:path";
-async function startSecretMcp(opts = {}) {
+async function buildSecretServer(solDir2) {
   const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
-  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
   const { CallToolRequestSchema, ListToolsRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
-  const solDir2 = opts.solDir || process.env.SOL_DIR || join16(process.cwd(), ".sol");
-  if (!existsSync16(solDir2)) {
-    process.stderr.write(`sol-secret-mcp: no .sol at ${solDir2} — run \`sol init\` first (or set SOL_DIR)
-`);
-    process.exit(1);
-  }
   const dirUrl = (process.env.SOL_REMOTE || "https://sol.midsummer.new").replace(/\/+$/, "");
   async function fetchKey2(account) {
     const { fetchKey: f } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
@@ -7905,11 +8049,28 @@ async function startSecretMcp(opts = {}) {
     const r = await callMcpTool(ctx, req.params.name, req.params.arguments ?? {});
     return { content: [{ type: "text", text: r.text }], isError: r.isError };
   });
+  return server;
+}
+async function startSecretMcp(opts = {}) {
+  const solDir2 = opts.solDir || process.env.SOL_DIR || join16(process.cwd(), ".sol");
+  if (!existsSync16(solDir2)) {
+    process.stderr.write(`sol-secret-mcp: no .sol at ${solDir2} — run \`sol init\` first (or set SOL_DIR)
+`);
+    process.exit(1);
+  }
+  if (opts.http) {
+    const { serveMcpHttp: serveMcpHttp2 } = await Promise.resolve().then(() => (init_mcp_http(), exports_mcp_http));
+    await serveMcpHttp2(() => buildSecretServer(solDir2), opts.http);
+    return;
+  }
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const server = await buildSecretServer(solDir2);
   await server.connect(new StdioServerTransport);
 }
 var init_sol_secret_mcp = __esm(() => {
   init_mcp_tools();
   init_identity_store();
+  init_mcp_http();
   if (false) {}
 });
 
@@ -8020,85 +8181,6 @@ var init_workspace = __esm(() => {
   init_async_repo();
 });
 
-// src/bin/sol-mcp.ts
-var exports_sol_mcp = {};
-__export(exports_sol_mcp, {
-  startWorkspaceMcp: () => startWorkspaceMcp
-});
-import { mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join17 } from "node:path";
-async function handle(ws, name, a) {
-  switch (name) {
-    case "sol_write":
-      await ws.write(a.path, a.content);
-      return text(`wrote ${a.path} (${a.content.length} chars)`);
-    case "sol_read": {
-      const c = await ws.read(a.path);
-      return c === undefined ? text(`(absent: ${a.path})`) : text(c);
-    }
-    case "sol_edit":
-      await ws.edit(a.path, a.old_str, a.new_str, { all: a.all });
-      return text(`edited ${a.path}`);
-    case "sol_ls": {
-      const f = await ws.ls(a.prefix);
-      return text(f.length ? f.join(`
-`) : "(no files yet)");
-    }
-    case "sol_move":
-      await ws.move(a.from, a.to);
-      return text(`moved ${a.from} -> ${a.to}`);
-    case "sol_rm":
-      await ws.remove(a.path);
-      return text(`removed ${a.path}`);
-    case "sol_commit":
-    case "sol_checkpoint": {
-      const h = await ws.commit(a.message);
-      return text(`commit ${h.slice(0, 14)} — ${a.message}`);
-    }
-    case "sol_history": {
-      const ops = await ws.history();
-      return text(ops.map((o) => `${o.seq} ${o.type} ${o.path || ""}${o.message ? " : " + o.message : ""}`).join(`
-`) || "(empty)");
-    }
-    default:
-      throw new Error("unknown tool: " + name);
-  }
-}
-async function startWorkspaceMcp(opts = {}) {
-  const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
-  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-  const { CallToolRequestSchema, ListToolsRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
-  const solDir2 = opts.solDir || process.env.SOL_DIR || join17(process.cwd(), ".sol");
-  mkdirSync10(solDir2, { recursive: true });
-  const ws = new SolWorkspace(new FileStore(solDir2), new FileOpLog(solDir2), process.env.SOL_ACTOR || "agent");
-  const server = new Server({ name: "sol", version: "0.1.0" }, { capabilities: { tools: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-  server.setRequestHandler(CallToolRequestSchema, async (req) => {
-    try {
-      return await handle(ws, req.params.name, req.params.arguments ?? {});
-    } catch (e) {
-      return { content: [{ type: "text", text: "sol error: " + (e?.message ?? e) }], isError: true };
-    }
-  });
-  await server.connect(new StdioServerTransport);
-}
-var tools, text = (s) => ({ content: [{ type: "text", text: s }] });
-var init_sol_mcp = __esm(() => {
-  init_file_store();
-  init_workspace();
-  tools = [
-    { name: "sol_write", description: "Create or overwrite a text file in the sol workspace. Authoring goes here — not to a disk.", inputSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
-    { name: "sol_read", description: "Read a text file from the sol workspace.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
-    { name: "sol_edit", description: "Replace a unique snippet in a file (set all=true to replace every occurrence).", inputSchema: { type: "object", properties: { path: { type: "string" }, old_str: { type: "string" }, new_str: { type: "string" }, all: { type: "boolean" } }, required: ["path", "old_str", "new_str"] } },
-    { name: "sol_ls", description: "List tracked files, optionally scoped to a directory prefix.", inputSchema: { type: "object", properties: { prefix: { type: "string" } } } },
-    { name: "sol_move", description: "Move or rename a file.", inputSchema: { type: "object", properties: { from: { type: "string" }, to: { type: "string" } }, required: ["from", "to"] } },
-    { name: "sol_rm", description: "Delete (untrack) a file.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
-    { name: "sol_commit", description: "Record a commit (a shareable milestone) over the current state.", inputSchema: { type: "object", properties: { message: { type: "string" } }, required: ["message"] } },
-    { name: "sol_history", description: "Show the authoring history (the op-log).", inputSchema: { type: "object", properties: {} } }
-  ];
-  if (false) {}
-});
-
 // src/bin/dispatch.ts
 var exports_dispatch = {};
 __export(exports_dispatch, {
@@ -8106,9 +8188,9 @@ __export(exports_dispatch, {
   dispatch: () => dispatch
 });
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync11, mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync17, rmSync as rmSync2, unlinkSync as unlinkSync7, watch, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync17, rmSync as rmSync2, unlinkSync as unlinkSync7, watch, writeFileSync as writeFileSync15 } from "node:fs";
 import { homedir as homedir2, hostname, platform as platform2, tmpdir } from "node:os";
-import { basename, dirname as dirname4, join as join18, resolve as resolve4, sep as sep2 } from "node:path";
+import { basename, dirname as dirname4, join as join17, resolve as resolve4, sep as sep2 } from "node:path";
 function globCovers(pattern, path) {
   let re = "";
   for (let i = 0;i < pattern.length; i++) {
@@ -8182,6 +8264,24 @@ function authHost() {
   } catch {}
   return "https://auth.midsummer.new";
 }
+async function resolveMcpHttp(a, label) {
+  if (!a.includes("--http"))
+    return;
+  const flagVal = (name) => {
+    const i = a.indexOf(name);
+    return i >= 0 && i + 1 < a.length ? a[i + 1] : undefined;
+  };
+  const { resolveMcpToken: resolveMcpToken2 } = await Promise.resolve().then(() => (init_mcp_http(), exports_mcp_http));
+  const token = resolveMcpToken2(flagVal("--token"));
+  if (!token) {
+    die("refusing to start an OPEN HTTP MCP — set a bearer token via SOL_MCP_TOKEN (or --token <T>). every request must send `Authorization: Bearer <token>`.");
+  }
+  const portRaw = flagVal("--port");
+  const port = portRaw ? Number(portRaw) : undefined;
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    die(`invalid --port: ${portRaw}`);
+  return { token, port, host: flagVal("--host"), label: label ?? (a.includes("--secret") || a.includes("--secrets") ? "sol-secrets" : "sol") };
+}
 function resolveRemote(solDir2) {
   const cfg = loadRemote(solDir2);
   if (!cfg)
@@ -8734,13 +8834,19 @@ SOL_RECOVERY_CODE (which only unlocks SIGNED gate edits, never a value op).
 
 register:
   claude mcp add sol-secrets -- sol secret mcp        # the INSTALLED binary serves it (no separate bin on PATH)`,
-    mcp: `sol mcp [--secret]   serve a sol MCP server over stdio
+    mcp: `sol mcp [--secret] [--http [--port N] [--host H] [--token T]]   serve a sol MCP server
 
   sol mcp              the file/VCS AUTHORING server (sol_write/read/edit/ls/move/rm/commit/history) — an agent
                        authors directly into the op-log + content store, no working copy.
   sol mcp --secret     the AGENT-SAFE SECRET-MANAGER server (== \`sol secret mcp\`) — 14 value-free env/secret tools.
 
-register: \`claude mcp add sol -- sol mcp\` | \`claude mcp add sol-secrets -- sol mcp --secret\``,
+transport: stdio is the DEFAULT (local pipe). \`--http\` serves the SAME tool surface over the MCP Streamable HTTP
+transport — the enabler for hosting it on a remote. an HTTP MCP is a NETWORK endpoint, so it requires a bearer
+token: set SOL_MCP_TOKEN (or pass --token <T>) and every request must send \`Authorization: Bearer <token>\` (else
+401). it serves on http://127.0.0.1:8765/mcp by default; override with --host / --port.
+
+register: \`claude mcp add sol -- sol mcp\` | \`claude mcp add sol-secrets -- sol mcp --secret\`
+http:     \`SOL_MCP_TOKEN=… sol mcp --http --port 8765\`  (then point an HTTP MCP client at http://HOST:PORT/mcp)`,
     resolve: `sol resolve <sol://env/NAME[#field]>   resolve a sol:// reference to its value (CLIENT-SIDE, recipient-gated)
 
   sol resolve sol://production/STRIPE_KEY
@@ -8781,7 +8887,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
   try {
     switch (cmd) {
       case "init": {
-        const here = join18(procCwd, ".sol");
+        const here = join17(procCwd, ".sol");
         if (existsSync17(here))
           die("already a sol repo: " + procCwd);
         if (repoRoot && repoRoot !== procCwd && !args.includes("--force")) {
@@ -8789,7 +8895,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
   -> just commit into it: \`sol commit ...\` works from here (sol walks up to find the repo)
   -> to nest a NEW repo here anyway: \`sol init --force\``);
         }
-        mkdirSync11(here, { recursive: true });
+        mkdirSync10(here, { recursive: true });
         new FileStore(here);
         console.log(`initialized empty sol repo in ${here}`);
         break;
@@ -8994,7 +9100,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
         let n = 0;
         for (const f of files) {
           const rf = repoRel(f);
-          if (!existsSync17(join18(cwd, rf))) {
+          if (!existsSync17(join17(cwd, rf))) {
             console.error("skip (not on disk): " + f);
             continue;
           }
@@ -9023,14 +9129,14 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
         if (!message)
           die('commit needs a message: sol commit "what you did"  (scoped: sol commit -m "msg" file1 file2)');
         const parentHead = await repo.head();
-        const mergeHeadPath = join18(solDir, "MERGE_HEAD");
+        const mergeHeadPath = join17(solDir, "MERGE_HEAD");
         const parent2 = existsSync17(mergeHeadPath) ? readFileSync17(mergeHeadPath, "utf8").trim() || undefined : undefined;
         let changed = 0;
         let commitRoot = parentHead;
         if (paths.length) {
           for (const p of paths) {
             const rp = repoRel(p);
-            if (existsSync17(join18(cwd, rp))) {
+            if (existsSync17(join17(cwd, rp))) {
               if (await snapshotFile(repo, rp))
                 changed++;
             } else if ((await repo.list()).includes(rp)) {
@@ -9375,7 +9481,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
         const path = args[0] || die("rm needs a path");
         let onDisk = false;
         try {
-          unlinkSync7(join18(cwd, path));
+          unlinkSync7(join17(cwd, path));
           onDisk = true;
         } catch {}
         if (onDisk) {
@@ -9603,16 +9709,16 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
           if (op.prov)
             walk(op.prov);
         }
-        const objDir = join18(solDir, "objects");
+        const objDir = join17(solDir, "objects");
         let removed = 0;
         for (const name of readdirSync8(objDir)) {
           if (name.endsWith(".tmp") || !reachable.has(name)) {
-            unlinkSync7(join18(objDir, name));
+            unlinkSync7(join17(objDir, name));
             removed++;
           }
         }
         console.log(`gc: kept ${reachable.size} object(s), removed ${removed} unreachable`);
-        if (existsSync17(join18(solDir, "env", "seal"))) {
+        if (existsSync17(join17(solDir, "env", "seal"))) {
           const { gcStaleStanzas: gcStaleStanzas2 } = await Promise.resolve().then(() => (init_secret(), exports_secret));
           const st = gcStaleStanzas2(solDir);
           if (st.removed)
@@ -9627,7 +9733,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
             console.log(p);
           break;
         }
-        const f = join18(cwd, ".solignore");
+        const f = join17(cwd, ".solignore");
         const lead = existsSync17(f) && !readFileSync17(f, "utf8").endsWith(`
 `) ? `
 ` : "";
@@ -9744,10 +9850,10 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
           let removed = 0;
           {
             const res = await scrubHistory2(solDir, ops, targets);
-            writeFileSync15(join18(solDir, "ops.jsonl"), res.ops.map((o) => JSON.stringify(o)).join(`
+            writeFileSync15(join17(solDir, "ops.jsonl"), res.ops.map((o) => JSON.stringify(o)).join(`
 `) + (res.ops.length ? `
 ` : ""));
-            writeFileSync15(join18(solDir, "HEAD"), JSON.stringify({ head: res.newHead, seq: res.newSeq, logTip: res.newLogTip }));
+            writeFileSync15(join17(solDir, "HEAD"), JSON.stringify({ head: res.newHead, seq: res.newSeq, logTip: res.newLogTip }));
             if (existsSync17(refsPath())) {
               const refs = JSON.parse(readFileSync17(refsPath(), "utf8"));
               for (const b of Object.values(refs.branches)) {
@@ -9907,7 +10013,7 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
         if (content === SEALED && !args.includes("--hide-names"))
           die("already sealed: " + path);
         if (content === undefined) {
-          const abs = join18(cwd, path);
+          const abs = join17(cwd, path);
           if (!existsSync17(abs))
             die("no such file: " + path);
           content = readFileSync17(abs, "utf8");
@@ -9998,6 +10104,21 @@ refused for a non-recipient (host/agent-blind). a missing or malformed reference
           audienceAccounts.push({ accountId: spec.accountId, fingerprint: resolved.fingerprint, keyEpoch: resolved.entry.keyEpoch });
           crossAccount.push(spec.accountId);
         }
+        const bareSelfSeal = !rawRecipients.length && !policyApplied && !Object.keys(recipientPubKeys).length && !escrowSlots.length;
+        if (bareSelfSeal) {
+          const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_identity_store(), exports_identity_store));
+          const stored = loadIdentity2();
+          if (stored) {
+            const { pubFingerprint: pubFingerprint2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+            recipientPubKeys[stored.accountId] = stored.x25519Pub;
+            audienceAccounts.push({ accountId: stored.accountId, fingerprint: pubFingerprint2(stored.x25519Pub), keyEpoch: stored.keyEpoch });
+            localRecipients.add(actor);
+          } else if (!wantJson) {
+            console.error(`WARNING: no identity (~/.sol/identity.json) — sealing "${path}" with a LOCAL-ONLY symmetric key.`);
+            console.error(`  this box will NOT decrypt on another machine even with your recovery code (the key lives only in this repo's .sol keyring).`);
+            console.error(`  run \`sol keys init\` first for a PORTABLE self-seal (decryptable with your recovery code on any of your devices).`);
+          }
+        }
         const client = new SealedClient2(repo, ring);
         const wantHideName = args.includes("--hide-names") || hideNamesFromPolicy;
         const wantHideExistence = args.includes("--hide-existence") || hideExistenceFromPolicy;
@@ -10128,6 +10249,8 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           break;
         }
         console.log(`sealed ${path} to ${recipients.join(", ")} — content is now host-blind ciphertext (the keystore stays local)`);
+        if (bareSelfSeal && audienceAccounts.length)
+          console.log(`  PORTABLE self-seal: also wrapped to your own identity (@${audienceAccounts[0].accountId}) — it decrypts with your recovery code on any of your machines.`);
         if (hiddenSlot)
           console.log(`  name hidden (L2): the host now sees an opaque slot \x00slot\x00${hiddenSlot}, never "${path.split("/").pop()}" — recipients rebuild the real name locally.`);
         if (policyApplied)
@@ -10398,7 +10521,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
         const result = merge2({ store: store2 }, other.base, ours, other.head);
         if (result.conflicts.length) {
           materializeTree(store2, result.head);
-          writeFileSync15(join18(solDir, "MERGE_HEAD"), other.head);
+          writeFileSync15(join17(solDir, "MERGE_HEAD"), other.head);
           saveMergeConflicts(solDir, result.conflicts);
           console.log(`merge ${name} -> ${result.conflicts.length} conflict(s), left in your working tree (uncommitted):`);
           for (const c of result.conflicts)
@@ -10545,7 +10668,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           }
           if (!tokens)
             die("timed out waiting for approval");
-          mkdirSync11(dirname4(CRED_PATH), { recursive: true });
+          mkdirSync10(dirname4(CRED_PATH), { recursive: true });
           writeFileSync15(CRED_PATH, JSON.stringify({ webUrl, ...tokens }, null, 2), { mode: 384 });
           const c = tokenClaims(tokens.accessToken);
           console.log(`
@@ -10589,7 +10712,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           console.log(id.handle ? `signed in as @${id.handle}  ${id.email ?? ""}`.trimEnd() : `signed in${id.email ? ` as ${id.email}` : ""} — no handle yet (\`sol auth set-handle <name>\`)`);
         } else if (sub === "set-handle") {
           const want = args[1] || die("usage: sol auth set-handle <name>");
-          const handle2 = want.toLowerCase();
+          const handle = want.toLowerCase();
           const token = process.env.SOL_TOKEN || await loadStoredToken();
           if (!token)
             authExpired();
@@ -10599,7 +10722,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
             if (meRes.ok)
               hadHandle = Boolean((await meRes.json()).handle);
           } catch {}
-          const res = await fetch(`${authHost()}/api/auth/handle`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ handle: handle2 }) });
+          const res = await fetch(`${authHost()}/api/auth/handle`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ handle }) });
           if (res.status === 401)
             authExpired();
           if (!res.ok) {
@@ -10677,10 +10800,10 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           const peer = openPeer2(localSrc);
           const peerHead = await peer.log.head();
           const dest = resolve4(procCwd, args[1] || (args[0].replace(/\/+$/, "").split("/").pop() || "clone") + "-clone");
-          const ddir = join18(dest, ".sol");
+          const ddir = join17(dest, ".sol");
           if (existsSync17(ddir))
             die("already a sol repo: " + dest);
-          mkdirSync11(ddir, { recursive: true });
+          mkdirSync10(ddir, { recursive: true });
           const peerOps = await peer.log.history();
           const res = await converge2({ store: new FileStore(ddir), log: new FileOpLog(ddir) }, { nodes: await peerNodes2(peer, peerHead, peerOps), ops: peerOps, incomingHead: peerHead, actor });
           const dstore = new Store;
@@ -10690,7 +10813,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           const files = (res.head ? listAll(dstore, res.head) : []).filter((f) => !f.split("/").some(isReservedKey2));
           for (const f of files)
             materializeInto(dstore, res.head, dest, f);
-          writeFileSync15(join18(ddir, "refs.json"), JSON.stringify({ current: "main", branches: { main: { head: res.head, base: res.head, remote: res.head } }, tags: {} }, null, 2));
+          writeFileSync15(join17(ddir, "refs.json"), JSON.stringify({ current: "main", branches: { main: { head: res.head, base: res.head, remote: res.head } }, tags: {} }, null, 2));
           writeWorkingIndexAt(ddir, dest, files);
           console.log(`cloned local peer ${args[0]} -> ${dest} (${(await peer.log.history()).length} ops, ${files.length} files)`);
           break;
@@ -10699,12 +10822,12 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
         const repoName = rest[0] || die("usage: sol clone [<url>] <owner>/<repo> [dir]");
         const token = process.env.SOL_TOKEN || die("set SOL_TOKEN to the backend bearer token");
         const target = resolve4(cwd, rest[1] || repoName.split("/").pop() || repoName);
-        const fdir = join18(target, ".sol");
+        const fdir = join17(target, ".sol");
         if (existsSync17(fdir))
           die("already a sol repo: " + target);
         const cfg = { url, repo: repoName };
         const bundle = await remoteExport(cfg, token);
-        mkdirSync11(fdir, { recursive: true });
+        mkdirSync10(fdir, { recursive: true });
         await writeBundle(fdir, bundle, 0);
         saveRemote(fdir, cfg);
         await pullEnvState(fdir, cfg, token);
@@ -10717,8 +10840,8 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           cloneBranches[name] = { head: h, base: h, remote: h };
         if (!cloneBranches[onBranch])
           cloneBranches[onBranch] = { head: checkoutHead, base: checkoutHead, remote: checkoutHead };
-        writeFileSync15(join18(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
-        writeFileSync15(join18(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: bundle.seq, logTip: bundle.tip }));
+        writeFileSync15(join17(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
+        writeFileSync15(join17(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: bundle.seq, logTip: bundle.tip }));
         const store2 = new Store;
         for (const node of bundle.nodes)
           store2.put(node);
@@ -10974,9 +11097,9 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
           for (const c of result.conflicts) {
             const blob = fileAt(store2, result.head, c.path);
             if (blob)
-              writeFileSync15(join18(cwd, c.path), blob.encoding === "base64" ? Buffer.from(blob.content, "base64") : blob.content);
+              writeFileSync15(join17(cwd, c.path), blob.encoding === "base64" ? Buffer.from(blob.content, "base64") : blob.content);
           }
-          writeFileSync15(join18(solDir, "MERGE_HEAD"), remoteHead2);
+          writeFileSync15(join17(solDir, "MERGE_HEAD"), remoteHead2);
           saveMergeConflicts(solDir, result.conflicts);
           console.log(`pulled + merged WITH ${result.conflicts.length} conflict(s), left uncommitted in your working tree:`);
           for (const c of result.conflicts)
@@ -11007,7 +11130,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
         const newRepo = frest[1] || die("usage: sol fork [<url>] <parent-repo> <new-repo> [dir]");
         const token = process.env.SOL_TOKEN || authExpired();
         const target = resolve4(cwd, frest[2] || newRepo);
-        const fdir = join18(target, ".sol");
+        const fdir = join17(target, ".sol");
         if (existsSync17(fdir))
           die("already a sol repo: " + target);
         const parentCfg = { url, repo: parent };
@@ -11024,7 +11147,7 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
         }
         await forkMeta(newCfg, token, parent);
         const canon = await remoteExport(newCfg, token);
-        mkdirSync11(fdir, { recursive: true });
+        mkdirSync10(fdir, { recursive: true });
         await writeBundle(fdir, canon, 0);
         const srvRefs = canon.refs ?? { branches: { main: canon.head ?? "" }, production: "main" };
         const checkout = canon.checkout ?? { branch: srvRefs.production || "main", head: srvRefs.branches[srvRefs.production] ?? canon.head };
@@ -11033,8 +11156,8 @@ WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal
         const cloneBranches = {};
         for (const [name, h] of Object.entries(srvRefs.branches))
           cloneBranches[name] = { head: h, base: h, remote: h };
-        writeFileSync15(join18(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
-        writeFileSync15(join18(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: canon.seq, logTip: canon.tip }));
+        writeFileSync15(join17(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
+        writeFileSync15(join17(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: canon.seq, logTip: canon.tip }));
         saveRemote(fdir, newCfg);
         const store2 = new Store;
         for (const node of canon.nodes)
@@ -11299,7 +11422,7 @@ ${mrSummary2(pr)}`);
           die("usage: sol run [--keep <path>] [--isolate] <command...>");
         const { capture: capture3, hydrate: hydrate3, isolateCommand: isolateCommand2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
         const head = await repo.head();
-        const dir = mkdtempSync(join18(tmpdir(), "sol-run-"));
+        const dir = mkdtempSync(join17(tmpdir(), "sol-run-"));
         try {
           const hn = hydrate3(loadStore(), head, dir);
           console.log(`hydrated ${hn} file(s) -> sandbox${isolate ? " (isolated: no network, writes confined to the sandbox)" : ""}`);
@@ -11332,7 +11455,7 @@ ${mrSummary2(pr)}`);
               materialize(synced, nh, f);
             for (const f of deleted) {
               try {
-                unlinkSync7(join18(cwd, f));
+                unlinkSync7(join17(cwd, f));
               } catch {}
             }
             console.log(`captured ${written.length} written, ${deleted.length} deleted file(s):`);
@@ -11354,10 +11477,10 @@ ${mrSummary2(pr)}`);
         if (sub === "import") {
           const gitPath = resolve4(cwd, args[1] || die("usage: sol git import <git-repo> [dir]"));
           const target = resolve4(cwd, args[2] || basename(gitPath));
-          const fdir = join18(target, ".sol");
+          const fdir = join17(target, ".sol");
           if (existsSync17(fdir))
             die("already a sol repo: " + target);
-          mkdirSync11(fdir, { recursive: true });
+          mkdirSync10(fdir, { recursive: true });
           const { commits, branches, head, current } = await importGitRepo2(gitPath, fdir);
           const refsBranches = {};
           for (const b of branches)
@@ -11365,13 +11488,13 @@ ${mrSummary2(pr)}`);
           if (!refsBranches[current])
             refsBranches[current] = { head, base: head };
           refsBranches[current].head = head;
-          writeFileSync15(join18(fdir, "refs.json"), JSON.stringify({ current, branches: refsBranches, tags: {} }, null, 2));
+          writeFileSync15(join17(fdir, "refs.json"), JSON.stringify({ current, branches: refsBranches, tags: {} }, null, 2));
           const store2 = new Store;
-          for (const name of readdirSync8(join18(fdir, "objects"))) {
+          for (const name of readdirSync8(join17(fdir, "objects"))) {
             if (name.endsWith(".tmp"))
               continue;
             try {
-              store2.put(decodeObject(readFileSync17(join18(fdir, "objects", name))));
+              store2.put(decodeObject(readFileSync17(join17(fdir, "objects", name))));
             } catch {}
           }
           const onDisk = hydrate3(store2, head, target);
@@ -11403,9 +11526,9 @@ ${mrSummary2(pr)}`);
           die("already inside a view — create views from the parent repo (its `.sol` owns the shared store + op-log).");
         const name = args.find((a) => !a.startsWith("-")) || die("usage: sol view <name> [dir]");
         const rest = args.filter((a) => !a.startsWith("-"));
-        const defaultDir = join18(dirname4(cwd), `${basename(cwd)}-${name}`);
+        const defaultDir = join17(dirname4(cwd), `${basename(cwd)}-${name}`);
         const viewDir = rest[1] ? resolve4(procCwd, rest[1]) : defaultDir;
-        if (existsSync17(join18(viewDir, ".sol")))
+        if (existsSync17(join17(viewDir, ".sol")))
           die("already a sol repo/view: " + viewDir);
         const branch = `view/${name}`;
         const startHead = await log.head() ?? emptyRoot(loadStore());
@@ -11496,12 +11619,13 @@ ${mrSummary2(pr)}`);
         break;
       }
       case "mcp": {
+        const http = await resolveMcpHttp(args);
         if (args.includes("--secret") || args.includes("--secrets")) {
           const { startSecretMcp: startSecretMcp2 } = await Promise.resolve().then(() => (init_sol_secret_mcp(), exports_sol_secret_mcp));
-          await startSecretMcp2({ solDir });
+          await startSecretMcp2({ solDir, http });
         } else {
-          const { startWorkspaceMcp: startWorkspaceMcp2 } = await Promise.resolve().then(() => (init_sol_mcp(), exports_sol_mcp));
-          await startWorkspaceMcp2({ solDir });
+          const { startWorkspaceMcp } = await Promise.resolve().then(() => (init_sol_mcp(), exports_sol_mcp));
+          await startWorkspaceMcp({ solDir, http });
         }
         break;
       }
@@ -11509,8 +11633,9 @@ ${mrSummary2(pr)}`);
       case "secret":
       case "resolve": {
         if (cmd === "secret" && args[0] === "mcp") {
+          const http = await resolveMcpHttp(args.slice(1), "sol-secrets");
           const { startSecretMcp: startSecretMcp2 } = await Promise.resolve().then(() => (init_sol_secret_mcp(), exports_sol_secret_mcp));
-          await startSecretMcp2({ solDir });
+          await startSecretMcp2({ solDir, http });
           break;
         }
         if (!existsSync17(solDir))
@@ -11686,29 +11811,3939 @@ var init_dispatch = __esm(() => {
   init_remote();
   init_lib();
   init_test_gate();
-  CRED_PATH = join18(homedir2(), ".sol", "credentials");
+  CRED_PATH = join17(homedir2(), ".sol", "credentials");
   DEFAULT_REMOTE_URL = (process.env.SOL_REMOTE || "https://sol.midsummer.new").replace(/\/+$/, "");
   ATTEST_KEY = process.env.SOL_ATTEST_KEY || undefined;
 });
 
-// src/bin/sol.ts
-import { readFileSync as readFileSync18 } from "fs";
-function cliVersion2() {
-  if (typeof __SOL_COMPILED_VERSION__ === "string" && __SOL_COMPILED_VERSION__)
-    return __SOL_COMPILED_VERSION__;
+// src/bin/mcp-vcs-tools.ts
+function sanitizeEgress2(text) {
+  const saved = [];
+  const protectedText = text.replace(SOL_ID_RE, (m) => {
+    const token = `[[solid:${saved.length}]]`;
+    saved.push(m);
+    return token;
+  });
+  const cleaned = sanitizer2.sanitize(protectedText).sanitized;
+  return cleaned.replace(/\[\[solid:(\d+)\]\]/g, (_, i) => saved[Number(i)] ?? "");
+}
+async function runSol(argv) {
+  const { runCli: runCli2 } = await Promise.resolve().then(() => (init_dispatch(), exports_dispatch));
+  const lines2 = [];
+  const origLog = console.log;
+  const origErr = console.error;
+  const origExit = process.exit;
+  process.exitCode = 0;
+  console.log = (...a) => void lines2.push(a.map((x) => typeof x === "string" ? x : String(x)).join(" "));
+  console.error = (...a) => void lines2.push(a.map((x) => typeof x === "string" ? x : String(x)).join(" "));
+  process.exit = (code) => {
+    throw new CliExit(code ?? 0);
+  };
   try {
-    return JSON.parse(readFileSync18(new URL("./package.json", import.meta.url), "utf8")).version || "dev";
-  } catch {
-    return "dev";
+    await runCli2(argv);
+    const code = typeof process.exitCode === "number" ? process.exitCode : 0;
+    return { out: lines2.join(`
+`), exitCode: code };
+  } catch (e) {
+    if (e instanceof CliExit)
+      return { out: lines2.join(`
+`), exitCode: e.code || 1 };
+    throw e;
+  } finally {
+    console.log = origLog;
+    console.error = origErr;
+    process.exit = origExit;
+    process.exitCode = 0;
   }
 }
-async function main() {
-  const argv = process.argv.slice(2);
-  if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
-    console.log(`sol ${cliVersion2()}`);
+function buildArgv(name, a) {
+  const str = (k) => typeof a[k] === "string" && a[k] !== "" ? a[k] : undefined;
+  const flag2 = (k) => a[k] === true || a[k] === "true";
+  switch (name) {
+    case "sol_status":
+      return ["status", "--json"];
+    case "sol_log":
+      return flag2("all") ? ["log", "--all", "--json"] : ["log", "--json"];
+    case "sol_diff": {
+      const v = ["diff"];
+      if (str("a"))
+        v.push(str("a"));
+      if (str("b"))
+        v.push(str("b"));
+      v.push("--json");
+      return v;
+    }
+    case "sol_blame":
+      return ["blame", str("path"), "--json"];
+    case "sol_branch": {
+      if (!str("name"))
+        return ["branches"];
+      const v = ["branch", str("name")];
+      if (str("at"))
+        v.push(str("at"));
+      return v;
+    }
+    case "sol_checkout":
+      return ["switch", str("branch")];
+    case "sol_merge":
+      return ["merge", str("branch"), "--json"];
+    case "sol_view": {
+      const v = ["view", str("name")];
+      if (str("dir"))
+        v.push(str("dir"));
+      return v;
+    }
+    case "sol_views":
+      return ["views", "--json"];
+    case "sol_pull":
+      return str("from") ? ["pull", str("from")] : ["pull"];
+    case "sol_push": {
+      const v = ["push"];
+      if (flag2("create"))
+        v.push("--create");
+      if (flag2("public"))
+        v.push("--public");
+      if (str("repo"))
+        v.push(str("repo"));
+      v.push("--json");
+      return v;
+    }
+    case "sol_clone": {
+      const v = ["clone", str("repo")];
+      if (str("dir"))
+        v.push(str("dir"));
+      return v;
+    }
+    case "sol_hide": {
+      const v = ["hide", str("pattern")];
+      if (str("role"))
+        v.push("--role", str("role"));
+      if (str("team"))
+        v.push("--team", str("team"));
+      if (str("users"))
+        v.push("--users", str("users"));
+      if (flag2("hide_names"))
+        v.push("--hide-names");
+      if (flag2("hide_existence"))
+        v.push("--hide-existence");
+      v.push("--json");
+      return v;
+    }
+    case "sol_seal": {
+      const v = ["seal"];
+      if (str("path"))
+        v.push(str("path"));
+      if (flag2("reapply"))
+        v.push("--reapply");
+      v.push("--json");
+      return v;
+    }
+    case "sol_sealed":
+      return ["sealed", "--json"];
+    default:
+      throw new Error("unknown VCS tool: " + name);
+  }
+}
+async function callVcsTool(name, args = {}) {
+  let argv;
+  try {
+    argv = buildArgv(name, args);
+  } catch (e) {
+    return { text: sanitizeEgress2("sol: " + (e instanceof Error ? e.message : String(e))), isError: true };
+  }
+  try {
+    const { out, exitCode } = await runSol(argv);
+    return { text: sanitizeEgress2(out || "(ok)"), isError: exitCode !== 0 };
+  } catch (e) {
+    return { text: sanitizeEgress2("sol: " + (e instanceof Error ? e.message : String(e))), isError: true };
+  }
+}
+var VCS_TOOLS, sanitizer2, SOL_ID_RE, CliExit;
+var init_mcp_vcs_tools = __esm(() => {
+  init_sanitizer();
+  VCS_TOOLS = [
+    { name: "sol_status", description: "Working-tree status as JSON: branch, head, the explicit state enum (CLEAN|DIRTY|CONFLICTED|SEMANTIC|EMPTY), per-path changes, and conflicts. The agent keys on `state` directly — no text scraping.", inputSchema: { type: "object", properties: {} } },
+    { name: "sol_log", description: "Commit history. Branch-scoped by default; set all=true for the AUTHORITATIVE full op-log (every write/seal/checkpoint/undo). Structured JSON with seq, id, author, message, root, parents, provenance.", inputSchema: { type: "object", properties: { all: { type: "boolean", description: "true = the full op-log lineage, not just the branch DAG" } } } },
+    { name: "sol_diff", description: "Diff as JSON. No args = working tree vs HEAD. One ref = working tree vs that ref. Two refs = tree vs tree. One path = that file vs HEAD. Host-blind: a non-recipient gets sealed/hidden rows, never decrypted content.", inputSchema: { type: "object", properties: { a: { type: "string", description: "a ref (branch/commit) or a path" }, b: { type: "string", description: "a second ref for a tree-vs-tree diff" } } } },
+    { name: "sol_blame", description: "Per-line authorship for a file as JSON: who authored each line, at which commit, when. Provenance-bound (trusted/forged detection).", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+    { name: "sol_branch", description: "List branches (no name) or create one. `name` creates a branch; optional `at` starts it at a branch/tag/commit (default: current head).", inputSchema: { type: "object", properties: { name: { type: "string", description: "omit to list; provide to create" }, at: { type: "string", description: "optional start ref (branch/tag/commit hash)" } }, required: [] } },
+    { name: "sol_checkout", description: "Switch the working tree to a branch (the `sol switch` verb). Refuses on a dirty tree — commit first. Use sol_branch to create a branch before checking it out.", inputSchema: { type: "object", properties: { branch: { type: "string" } }, required: ["branch"] } },
+    { name: "sol_merge", description: "Merge another branch into the current one (lossless converge). A clean merge advances + commits; line conflicts land in the working tree with markers (resolve, then sol_commit). Reports a SEMANTIC flag if the post-merge check fails.", inputSchema: { type: "object", properties: { branch: { type: "string" } }, required: ["branch"] } },
+    { name: "sol_view", description: "Create a CLONE-FREE agent view: a new working dir with its own branch + index that SHARES this repo's content store (zero object duplication). The agent edits + commits there, then converges back with sol_pull. `dir` is optional (defaults to a sibling).", inputSchema: { type: "object", properties: { name: { type: "string" }, dir: { type: "string", description: "optional target dir (default: a sibling <repo>-<name>)" } }, required: ["name"] } },
+    { name: "sol_views", description: "Enumerate every view of this repo as JSON: name, dir, branch, head, author, active/stale, and the shared-object count (one store on disk).", inputSchema: { type: "object", properties: {} } },
+    { name: "sol_pull", description: "Converge from the configured remote, OR from a local peer/view on disk when `from` is a directory path (offline multi-agent merge). Refuses over a dirty tree or unresolved conflicts. Conflicts land in the working tree with markers.", inputSchema: { type: "object", properties: { from: { type: "string", description: "optional: another repo's directory to converge from (offline). Omit to pull the configured remote." } } } },
+    { name: "sol_push", description: "Push the current branch to the configured remote (converging — never FF-rejected). With no remote set, `repo` (owner/name) configures the hosted Sol then pushes. `create`/`public` opt into repo creation + public access in one step.", inputSchema: { type: "object", properties: { repo: { type: "string", description: "owner/name — configures + creates the remote when none is set" }, create: { type: "boolean" }, public: { type: "boolean" } } } },
+    { name: "sol_clone", description: "Clone a repo into a new directory. `repo` = owner/name (hosted backend, needs SOL_TOKEN) OR a local directory path (offline local-peer clone, no network). `dir` is the optional destination.", inputSchema: { type: "object", properties: { repo: { type: "string", description: "owner/name (hosted) or a local .sol directory path (offline)" }, dir: { type: "string", description: "optional destination dir" } }, required: ["repo"] } },
+    { name: "sol_hide", description: "Add/update a VisibilityPolicy RULE binding a glob to an AUDIENCE (who may DECRYPT). Host-visible METADATA only — no keys, no plaintext. `list` shows rules + covered paths; `remove` drops a rule. The actual hiding is the lockboxes sol_seal mints.", inputSchema: { type: "object", properties: { pattern: { type: "string", description: 'a glob over tree paths, or "list" / "remove <pattern>"' }, role: { type: "string", description: "write|admin — hide from anyone below that role" }, team: { type: "string" }, users: { type: "string", description: "comma-separated account list" }, hide_names: { type: "boolean" }, hide_existence: { type: "boolean" } }, required: ["pattern"] } },
+    { name: "sol_seal", description: "Mint/refresh the per-file lockboxes that enforce the hide rules (the host-blind encryption step). Operates on audiences + lockboxes, NEVER plaintext — the agent never sees a sealed value. `reapply=true` re-wraps after an ACL change. Returns a value-free JSON summary.", inputSchema: { type: "object", properties: { path: { type: "string", description: "optional: seal one path (default: every pending path)" }, reapply: { type: "boolean", description: "re-resolve + re-wrap after an audience change" } } } },
+    { name: "sol_sealed", description: "Report the sealed/hidden state as JSON: which paths are sealed, to which audience, and whether THIS identity can decrypt them. Identifiers + readiness only — never a plaintext value.", inputSchema: { type: "object", properties: {} } }
+  ];
+  sanitizer2 = new VaultSanitizer;
+  SOL_ID_RE = /\bh_[0-9a-f]{64}\b|\b(?:[0-9a-f]{4}-){7}[0-9a-f]{4}\b/g;
+  CliExit = class CliExit extends Error {
+    code;
+    constructor(code) {
+      super(`sol exited ${code}`);
+      this.code = code;
+    }
+  };
+});
+
+// src/bin/sol-mcp.ts
+var exports_sol_mcp = {};
+__export(exports_sol_mcp, {
+  startWorkspaceMcp: () => startWorkspaceMcp
+});
+import { mkdirSync as mkdirSync11 } from "node:fs";
+import { dirname as dirname5, join as join18 } from "node:path";
+async function handle(ws, name, a) {
+  switch (name) {
+    case "sol_write":
+      await ws.write(a.path, a.content);
+      return text(`wrote ${a.path} (${a.content.length} chars)`);
+    case "sol_read": {
+      const c = await ws.read(a.path);
+      return c === undefined ? text(`(absent: ${a.path})`) : text(c);
+    }
+    case "sol_edit":
+      await ws.edit(a.path, a.old_str, a.new_str, { all: a.all });
+      return text(`edited ${a.path}`);
+    case "sol_ls": {
+      const f = await ws.ls(a.prefix);
+      return text(f.length ? f.join(`
+`) : "(no files yet)");
+    }
+    case "sol_move":
+      await ws.move(a.from, a.to);
+      return text(`moved ${a.from} -> ${a.to}`);
+    case "sol_rm":
+      await ws.remove(a.path);
+      return text(`removed ${a.path}`);
+    case "sol_commit":
+    case "sol_checkpoint": {
+      const h = await ws.commit(a.message);
+      return text(`commit ${h.slice(0, 14)} — ${a.message}`);
+    }
+    case "sol_history": {
+      const ops = await ws.history();
+      return text(ops.map((o) => `${o.seq} ${o.type} ${o.path || ""}${o.message ? " : " + o.message : ""}`).join(`
+`) || "(empty)");
+    }
+    default:
+      throw new Error("unknown tool: " + name);
+  }
+}
+async function buildWorkspaceServer(solDir2) {
+  const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
+  const { CallToolRequestSchema, ListToolsRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
+  mkdirSync11(solDir2, { recursive: true });
+  const repoRoot2 = dirname5(solDir2);
+  if (process.cwd() !== repoRoot2) {
+    try {
+      process.chdir(repoRoot2);
+    } catch {}
+  }
+  const ws = new SolWorkspace(new FileStore(solDir2), new FileOpLog(solDir2), process.env.SOL_ACTOR || "agent");
+  const server = new Server({ name: "sol", version: "0.1.0" }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (VCS_TOOL_NAMES.has(req.params.name)) {
+      const r = await callVcsTool(req.params.name, req.params.arguments ?? {});
+      return { content: [{ type: "text", text: r.text }], isError: r.isError };
+    }
+    try {
+      return await handle(ws, req.params.name, req.params.arguments ?? {});
+    } catch (e) {
+      return { content: [{ type: "text", text: "sol error: " + (e?.message ?? e) }], isError: true };
+    }
+  });
+  return server;
+}
+async function startWorkspaceMcp(opts = {}) {
+  const solDir2 = opts.solDir || process.env.SOL_DIR || join18(process.cwd(), ".sol");
+  if (opts.http) {
+    const { serveMcpHttp: serveMcpHttp2 } = await Promise.resolve().then(() => (init_mcp_http(), exports_mcp_http));
+    await serveMcpHttp2(() => buildWorkspaceServer(solDir2), opts.http);
     return;
   }
-  const { runCli: runCli2 } = await Promise.resolve().then(() => (init_dispatch(), exports_dispatch));
-  await runCli2(argv);
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const server = await buildWorkspaceServer(solDir2);
+  await server.connect(new StdioServerTransport);
+}
+var authoringTools, VCS_TOOL_NAMES, tools, text = (s) => ({ content: [{ type: "text", text: s }] });
+var init_sol_mcp = __esm(() => {
+  init_file_store();
+  init_workspace();
+  init_mcp_http();
+  init_mcp_vcs_tools();
+  authoringTools = [
+    { name: "sol_write", description: "Create or overwrite a text file in the sol workspace. Authoring goes here — not to a disk.", inputSchema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
+    { name: "sol_read", description: "Read a text file from the sol workspace.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+    { name: "sol_edit", description: "Replace a unique snippet in a file (set all=true to replace every occurrence).", inputSchema: { type: "object", properties: { path: { type: "string" }, old_str: { type: "string" }, new_str: { type: "string" }, all: { type: "boolean" } }, required: ["path", "old_str", "new_str"] } },
+    { name: "sol_ls", description: "List tracked files, optionally scoped to a directory prefix.", inputSchema: { type: "object", properties: { prefix: { type: "string" } } } },
+    { name: "sol_move", description: "Move or rename a file.", inputSchema: { type: "object", properties: { from: { type: "string" }, to: { type: "string" } }, required: ["from", "to"] } },
+    { name: "sol_rm", description: "Delete (untrack) a file.", inputSchema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
+    { name: "sol_commit", description: "Record a commit (a shareable milestone) over the current state.", inputSchema: { type: "object", properties: { message: { type: "string" } }, required: ["message"] } },
+    { name: "sol_history", description: "Show the authoring history (the op-log).", inputSchema: { type: "object", properties: {} } }
+  ];
+  VCS_TOOL_NAMES = new Set(VCS_TOOLS.map((t) => t.name));
+  tools = [...authoringTools, ...VCS_TOOLS];
+  if (false) {}
+});
+
+// src/bin/dispatch.ts
+var exports_dispatch2 = {};
+__export(exports_dispatch2, {
+  runCli: () => runCli2,
+  dispatch: () => dispatch2
+});
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync18, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync2, readdirSync as readdirSync9, readFileSync as readFileSync18, rmSync as rmSync3, unlinkSync as unlinkSync8, watch as watch2, writeFileSync as writeFileSync16 } from "node:fs";
+import { homedir as homedir3, hostname as hostname2, platform as platform3, tmpdir as tmpdir2 } from "node:os";
+import { basename as basename2, dirname as dirname6, join as join19, resolve as resolve5, sep as sep3 } from "node:path";
+function globCovers2(pattern, path) {
+  let re = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        i++;
+        if (pattern[i + 1] === "/")
+          i++;
+        re += ".*";
+      } else
+        re += "[^/]*";
+    } else if (c === "?")
+      re += "[^/]";
+    else
+      re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`).test(path);
+}
+function tokenClaims2(token) {
+  try {
+    return JSON.parse(Buffer.from(token.split(".")[1] ?? "", "base64url").toString());
+  } catch {
+    return {};
+  }
+}
+async function loadStoredToken2() {
+  if (!existsSync18(CRED_PATH2))
+    return;
+  let creds;
+  try {
+    creds = JSON.parse(readFileSync18(CRED_PATH2, "utf8"));
+  } catch {
+    return;
+  }
+  if (!creds.accessToken)
+    return;
+  const exp = tokenClaims2(creds.accessToken).exp;
+  if (typeof exp === "number" && exp * 1000 > Date.now() + 30000)
+    return creds.accessToken;
+  if (creds.refreshToken && creds.webUrl) {
+    try {
+      const res = await fetch(`${creds.webUrl}/api/auth/refresh`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ refreshToken: creds.refreshToken }) });
+      if (res.ok) {
+        const r = await res.json();
+        if (r.accessToken) {
+          writeFileSync16(CRED_PATH2, JSON.stringify({ ...creds, accessToken: r.accessToken, refreshToken: r.refreshToken ?? creds.refreshToken }, null, 2), { mode: 384 });
+          return r.accessToken;
+        }
+      }
+    } catch {}
+  }
+  return creds.accessToken;
+}
+function authExpired2() {
+  return die("session expired — run `sol auth login` (or set SOL_TOKEN)");
+}
+function identityFromToken2(token) {
+  const c = tokenClaims2(token);
+  if (!c.handle && !c.email && !c.userId && !c.sub)
+    return;
+  return { handle: c.handle, email: c.email, userId: c.userId ?? c.sub };
+}
+function authHost2() {
+  if (process.env.SOL_AUTH)
+    return process.env.SOL_AUTH.replace(/\/+$/, "");
+  try {
+    const w = JSON.parse(readFileSync18(CRED_PATH2, "utf8")).webUrl;
+    if (w)
+      return w.replace(/\/+$/, "");
+  } catch {}
+  return "https://auth.midsummer.new";
+}
+async function resolveMcpHttp2(a, label) {
+  if (!a.includes("--http"))
+    return;
+  const flagVal = (name) => {
+    const i = a.indexOf(name);
+    return i >= 0 && i + 1 < a.length ? a[i + 1] : undefined;
+  };
+  const { resolveMcpToken: resolveMcpToken2 } = await Promise.resolve().then(() => (init_mcp_http(), exports_mcp_http));
+  const token = resolveMcpToken2(flagVal("--token"));
+  if (!token) {
+    die("refusing to start an OPEN HTTP MCP — set a bearer token via SOL_MCP_TOKEN (or --token <T>). every request must send `Authorization: Bearer <token>`.");
+  }
+  const portRaw = flagVal("--port");
+  const port = portRaw ? Number(portRaw) : undefined;
+  if (port !== undefined && (!Number.isInteger(port) || port < 1 || port > 65535))
+    die(`invalid --port: ${portRaw}`);
+  return { token, port, host: flagVal("--host"), label: label ?? (a.includes("--secret") || a.includes("--secrets") ? "sol-secrets" : "sol") };
+}
+function resolveRemote2(solDir2) {
+  const cfg = loadRemote(solDir2);
+  if (!cfg)
+    return;
+  return cfg.url ? cfg : { ...cfg, url: DEFAULT_REMOTE_URL2 };
+}
+async function pushEnvState2(solDirPath, cfg, token) {
+  const { readEnvStateBundle: readEnvStateBundle2 } = await Promise.resolve().then(() => (init_anchor(), exports_anchor));
+  const bundle = readEnvStateBundle2(solDirPath);
+  if (!bundle)
+    return;
+  try {
+    const res = await remoteEnvPush(cfg, token, bundle);
+    if (res.reason === "registered") {
+      console.log(`env anchor: registered env owner ${res.record.owner.genesisFingerprint ?? res.record.owner.creatorFingerprint ?? "(none)"} on the remote (TOFU)`);
+    }
+  } catch (e) {
+    console.error(`
+ENV ANCHOR REJECTED by the remote: ${e?.message ?? String(e)}
+  the trust-bearing env-state did NOT sync. run \`sol env verify --remote\` to see the owner/head divergence.`);
+    process.exitCode = 1;
+  }
+}
+async function pullEnvState2(solDirPath, cfg, token) {
+  try {
+    const { bundle } = await remoteEnvPull(cfg, token);
+    if (!bundle || !bundle.journal?.length && !bundle.creatorPin)
+      return;
+    const { writeEnvStateBundle: writeEnvStateBundle2, ensureEnvDir: ensureEnvDir2 } = await Promise.resolve().then(() => (init_secret(), exports_secret));
+    ensureEnvDir2(solDirPath);
+    writeEnvStateBundle2(solDirPath, bundle);
+  } catch {}
+}
+async function surfaceEnvDivergence2(solDirPath, cfg, token) {
+  try {
+    const { remoteEnvAnchor: remoteEnvAnchor2 } = await Promise.resolve().then(() => (init_remote(), exports_remote));
+    const { record } = await remoteEnvAnchor2(cfg, token);
+    if (!record)
+      return;
+    const { readEnvStateBundle: readEnvStateBundle2 } = await Promise.resolve().then(() => (init_anchor(), exports_anchor));
+    const { verifyLocalAgainstRemote: verifyLocalAgainstRemote2 } = await Promise.resolve().then(() => (init_env_state(), exports_env_state));
+    const local = readEnvStateBundle2(solDirPath);
+    if (!local)
+      return;
+    const verdict = verifyLocalAgainstRemote2(local, record);
+    for (const i of verdict.issues)
+      console.error(`${i.severity === "error" ? "ENV ANCHOR ERROR" : "env anchor warn"} [${i.check}] ${i.message}`);
+    if (!verdict.ok)
+      process.exitCode = 1;
+  } catch {}
+}
+function cliVersion2() {
+  if (typeof __SOL_COMPILED_VERSION__ === "string" && __SOL_COMPILED_VERSION__)
+    return __SOL_COMPILED_VERSION__;
+  try {
+    return JSON.parse(readFileSync18(new URL("./package.json", import.meta.url), "utf8")).version || "dev";
+  } catch {
+    return "dev";
+  }
+}
+function reportSemanticGate2(outcome, json = false) {
+  if (!outcome.configured || outcome.ok)
+    return;
+  if (json) {
+    console.log(JSON.stringify({ semantic: { ok: false, check: outcome.command, exitCode: outcome.exitCode, output: outcome.output } }));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`
+SEMANTIC conflict — the merge auto-converged with NO line conflicts, but the check FAILED (\`${outcome.command}\`, exit ${outcome.exitCode}).`);
+  console.log("  the merge stays committed (convergence is lossless); review it and land a follow-up commit.");
+  console.log("  inspect: `sol status --json` (state: SEMANTIC) | re-run: `sol check`");
+  if (outcome.output)
+    console.log(`  --- check output (tail) ---
+` + outcome.output.split(`
+`).map((l) => "  " + l).join(`
+`));
+  process.exitCode = 1;
+}
+async function dispatch2(argv) {
+  if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
+    console.log(`sol ${cliVersion2()}`);
+    return;
+  }
+  const args = argv.slice(1);
+  const wantsHelp = args.includes("--help") || args.includes("-h");
+  const SUBHELP = {
+    commit: `sol commit "<msg>"                commits the whole working tree; works as-is for a solo author.
+  sol commit -m "<msg>" <file>...   commit ONLY those paths (correct attribution for concurrent agents)
+
+  (once OTHER authors have committed to this repo, a whole-tree commit is refused to avoid mis-attribution
+  — scope to files \`sol commit -m "<msg>" <files>\` or force with --whole-tree).
+
+flags:
+  -m <message>        message when scoping to files
+  --whole-tree        force a whole-tree commit even after OTHER authors are present (the guard above)
+  --force             commit even with unresolved <<<<<<< conflict markers
+
+examples:
+  sol commit "add login route"
+  sol commit -m "fix parser" src/parse.ts src/lex.ts`,
+    push: `sol push                          push the current branch to the configured remote (converging — never FF-rejected)
+  sol push <repo>                   if no remote is set, use the hosted Sol (${DEFAULT_REMOTE_URL2}) + this repo name, then push
+  sol push --create <repo>          same, explicit form (creates the repo on first push)
+  sol push --public <repo>          create + push + make it public in ONE step (else new repos are private)
+
+flags:
+  --create            explicit "creates the repo on first push" (the bare \`<repo>\` form does this too)
+  --public            after a successful create/push, set public access (same op as \`sol access public\`)
+
+notes:
+  a remote already configured? the <repo>/--create arg is ignored — \`sol push\` just syncs.
+  new repos are PRIVATE by default; \`--public\` is the one-step opt-in to share (or \`sol access public\` later).
+  set SOL_TOKEN (or \`sol auth login\`) first; the push registers the current branch's head on the remote.
+
+examples:
+  sol push                          # remote already configured
+  sol push alice/app                # one step: configure hosted remote + push (private)
+  sol push --create --public alice/app   # create + push + share, all at once`,
+    pull: `sol pull                          fetch + converge the current branch from the configured remote
+  sol pull <dir>                    OFFLINE: converge another local repo's .sol on disk into this one (multi-agent, no network)
+
+notes:
+  refuses to run over a dirty tree — commit or discard first. conflicts land in the working tree with markers.
+  refuses to run while UNRESOLVED <<<<<<< markers remain — resolve them and \`sol commit\`, then pull again.`,
+    hide: `sol hide <pattern> [--role write|admin] [--team <id>] [--users a,b] [--escrow] [--no-list] [--hide-names] [--hide-existence] [--strict]
+                                    add/update a VisibilityPolicy RULE — the HEADLINE verb. binds a glob over tree
+                                    paths to an AUDIENCE (who may DECRYPT). the rule is host-visible METADATA (no
+                                    keys, no plaintext); the actual hiding is the per-file lockboxes \`sol seal\` mints.
+  sol hide list                     show the policy rules + which CURRENT paths each one covers
+  sol hide remove <pattern>         drop a rule (does NOT auto-unseal existing content — re-seal to recall)
+
+audience (default --role write — "hide from anyone who is only \`read\`"):
+  --role <write|admin>    everyone whose repo role is >= that (resolved against the ACL grants, server-assisted)
+  --team <id>             a specific team
+  --users a,b,c           an explicit account list
+  --escrow                ALSO wrap to the org-escrow recovery slot (opt-in; loud — an admin can then recover)
+
+THE HIDING LADDER (each rung hides STRICTLY more; pick the weakest that meets the threat model):
+  (default)               DECRYPT-ONLY: host + collaborators see the PATH, not the bytes. content is sealed; the
+                          filename + the fact the file exists stay fully host-visible. the baseline \`sol seal\`.
+  --no-list               NO-LIST: collaborators can't LIST/fetch it (a server-side path-ACL), but the HOST still
+                          reads the plaintext path string. hidden from collaborators, VISIBLE TO HOST.
+  --hide-names            HIDE-NAMES (L2): the NAME is hidden from host AND collaborators. \`sol seal\` replaces the
+                          cleartext filename with an opaque \`\\0slot\\0<id>\` + seals the real name into the box. the
+                          host sees a slot exists at a known path, never the name. recipients rebuild it locally.
+  --hide-existence        HIDE-EXISTENCE (L3, IMPLIES --hide-names): the PATH is ABSENT from host + collaborators.
+                          \`sol seal\` moves the entry into its dir's ONE \`\\0hidden\` sealed sidecar. a non-recipient
+                          sees only a per-dir marker ("this dir has >=1 hidden child"), NEVER the name, the bytes, or
+                          even that THIS path exists. the strongest hiding (the fix-CVE-auth-bypass.ts / stargate case).
+  --strict                (with --hide-existence) REFUSE to existence-hide a path whose name is already BURNED in op
+                          history. default: proceed + WARN (the old name stays recoverable from history; hiding
+                          protects names written AFTER the upgrade). use --strict for a true zero-day filename. (D-STRUCT-5)
+
+after adding a rule, seal the covered paths to it: \`sol seal <path>\` (no recipients) consults the policy.
+host-blind: the server resolves WHO (accountIds + their PUBLIC keys) as metadata; the CLIENT mints every lockbox.
+
+examples:
+  sol hide "src/private/**"               # hide from \`read\` collaborators (default --role write)
+  sol hide "**/*.env" --role admin        # only admins+ may decrypt any .env
+  sol hide "secrets/**" --users alice,bob # an explicit audience
+  sol hide "vault/**" --no-list           # full opacity: read-collabs can't even list vault/
+  sol hide "src/fix-CVE-*.ts" --hide-names          # L2: the FILENAME is hidden from the host too
+  sol hide "features/stargate/**" --hide-existence  # L3: the path is ABSENT from host + collaborators
+  sol hide list`,
+    seal: `sol seal <path> [recipient...]    encrypt a file so the HOST only ever sees ciphertext (per-path privacy)
+
+  sol seal <path>                   NO recipients -> consult the VisibilityPolicy for <path> + seal to its audience
+  sol seal <dir> --seal-subtree     hide a DIRECTORY's CONTENTS: collapse it into ONE sealed node (the host sees
+                                      the dir NAME + one blob, never the child names/count). a recipient's pull
+                                      decrypts it back into a real directory; a non-recipient gets nothing within.
+  sol seal <path> --hide-names      hide the FILENAME too (L2): after sealing the content, replace the cleartext
+                                      entry with an opaque \`\\0slot\\0<id>\` slot + seal the real name into the box.
+                                      the host never sees the name; recipients rebuild it in their local view.
+  sol seal <path> --escrow          ALSO wrap the CEK to the org-escrow recovery slot (OPT-IN, default OFF, LOUD):
+                                      an org admin holding the escrow key CAN recover this content. surfaced loudly
+                                      in the output + \`sol sealed\` so "hidden from admins" is never silently false.
+  sol seal --reapply [<path>]       re-resolve the audience + re-wrap to the CURRENT policy (bumps epoch)
+
+  a bare \`sol seal <path>\` with no recipients looks up the policy rule covering <path> (\`sol hide\`) and wraps
+  the CEK to that audience's CURRENT members. an EXPLICIT recipient list still works (ad-hoc \`users\` audience).
+  \`--reapply\` re-resolves every policy-covered sealed path (or just <path>) against the live ACL + re-wraps,
+  bumping the box epoch. NO-RECALL caveat: a newly-added writer cannot read PAST sealed content until a reapply
+  re-wraps the CEK to them; a removed recipient is not retroactively recalled — for a LIVE secret, rotate it at
+  the source. (\`sol seal --reapply\` is printed loudly so the limit is never silent.)
+
+  the content becomes host-blind ciphertext committed into history; the keys stay LOCAL (~/.sol keystore).
+  you are always a recipient of your own seals. add other actors to share read access. \`sol cat\` decrypts
+  for a recipient; everyone else sees <<sealed>>.
+
+  a recipient may be a CROSS-ACCOUNT identity: \`alice\`, \`@alice\`, or \`alice@acct\`. for one with a PUBLISHED
+  identity key (\`sol keys publish\`) the CEK is wrapped to their X25519 PUBLIC key (host-blind cross-account
+  delivery); the client verifies their self-sig + TOFU-pins the fingerprint. an actor with NO published key
+  stays a legacy SYMMETRIC recipient. \`sol sealed\` shows each sealed path's audience.
+
+example:
+  sol seal secrets/.env alice bob   # alice, bob (and you) can read it; the server cannot
+  sol seal secrets/.env @alice      # cross-account: wrap to alice's published X25519 key (host stays blind)`,
+    sealed: `sol sealed                        list every sealed path with its AUDIENCE (recipient accounts + fingerprints + epoch)
+  sol sealed --json                 {count, sealed:[{path, epoch, accounts:[{accountId, fingerprint, keyEpoch}], local[], escrow[]}]}
+  sol sealed --check                DRIFT: per sealed path, does its CURRENT recipient set still match the policy
+                                      audience? after an ACL change (a reader promoted/removed), lists which sealed
+                                      paths are now OUT OF POLICY + suggests \`sol seal --reapply\`. compares RECIPIENT
+                                      IDENTIFIERS only (host-visible) — never content (calls the backend /policy/check).
+
+  the audience is recoverable from the box bytes (who holds a lockbox is host-visible); cross-account
+  fingerprints come from the local audience record written at seal time. an \`escrow\` slot is surfaced LOUDLY (an
+  org-escrow key-holder CAN recover that path — it is NOT hidden from admins). content stays host-blind.`,
+    open: `sol open <path>                   open a sealed path's plaintext (as a recipient — like \`sol cat\`)
+  sol open <path> --recovery [slot] ORG-ESCROW RECOVERY (D1, §7): recover a sealed path WITHOUT being a named
+                                      recipient, via the recovery SLOT the CEK was wrapped to (default org-escrow).
+  sol open <path> --recovery org-escrow --as <escrowAccountId>
+
+  for an escrow key-holder: set SOL_RECOVERY_CODE to the org-escrow recovery code and run with --recovery. the
+  escrow PRIVATE key is derived OFF-HOST from that code (the host never holds it); recovery reuses the existing
+  recovery primitive (openWithRecovery — no new crypto). only paths sealed WITH \`--escrow\` carry a recovery slot.`,
+    keys: `sol keys                          show your local identity (accountId, epoch, fingerprint)
+  sol keys init                     mint your X25519 identity keypair; print the recovery code ONCE
+  sol keys publish                  publish your PUBLIC key to the directory so others can seal to you
+  sol keys rotate                   mint a new key epoch + publish it (past seals stay on the old epoch)
+  sol keys verify <acct> <fpr>      out-of-band fingerprint check of a peer's published key (anti-MITM, TOFU)
+  sol keys export                   write an ENCRYPTED keystore backup bundle (to stdout)
+  sol keys import <bundle.json>     restore an identity from an encrypted backup bundle
+
+host-blind by construction: the directory holds PUBLIC keys only. your PRIVATE key is NEVER stored or sent —
+it re-derives from the recovery code you hold off-host, so device loss is survivable and the server stays blind.
+
+env:
+  SOL_RECOVERY_CODE        your recovery code — needed by publish/rotate/export (the private key derives from it)
+  SOL_KEYSTORE_PASSPHRASE  passphrase that encrypts an export/import bundle
+  SOL_ACCOUNT              override the accountId (self-host / tests); else taken from your login token
+
+examples:
+  sol keys init                     # mint + show the recovery code
+  SOL_RECOVERY_CODE="..." sol keys publish
+  sol keys verify alice 1a2b-3c4d-...   # confirm alice's key out-of-band before sealing to her`,
+    remote: `sol remote                        show the configured remote
+  sol remote <url> <repo>           set the remote (url + repo name)
+
+tip: \`sol push <repo>\` configures the hosted remote for you in one step.`,
+    branch: `sol branch                        list branches (* = current)
+  sol branch <name> [<ref>]         create a branch at <ref> (default: HEAD)`,
+    switch: `sol switch <branch>               switch branches (commits/keeps current work first; never loses it)`,
+    merge: `sol merge <branch>                3-way merge <branch> into the current branch
+  conflicts land in the working tree with <<<<<<< markers — resolve, then \`sol commit\`.`,
+    undo: `sol undo                          undo the LAST commit on the current branch (roll back a bad agent turn)
+
+  moves the branch head back to its parent and updates the working tree to match — NON-DESTRUCTIVELY:
+  the undone commit STAYS in the op-log (audit; \`sol log --all\` shows it), the hash chain stays
+  append-only + valid (\`sol fsck\` OK), and the move is recorded as a new op so it converges with peers
+  losslessly. refuses over a dirty tree — commit or discard first.
+
+  undo (head-move, last commit only) vs revert (an inverse commit of ANY commit, full history kept).
+
+flags:
+  --json            {undid, head, parent, filesChanged}`,
+    revert: `sol revert <ref>                  append a NEW commit that inverts the changes <ref> introduced (like git revert)
+
+  history is fully preserved — <ref> stays present; the inverse lands as a fresh commit on HEAD. computed
+  by a 3-way merge, so later concurrent edits are carried and genuine conflicts land with <<<<<<< markers
+  (resolve, then \`sol commit\`). refuses over a dirty tree.
+
+  <ref> is a branch/tag name, a commit hash-prefix, or an op seq number.
+
+flags:
+  --json            {reverted, head, filesChanged, committed}  (or {reverted, conflicts, committed:false})
+
+example:
+  sol revert 7                  # undo what commit seq 7 did, as a new commit on top`,
+    log: `sol log                           commit history for the current branch
+  sol log <branch|commit>           history scoped to a ref
+  sol log --all                     every op in the log (not just commits)
+  sol log --json                    array of {hash, by, message, seq, parents, prov} (agent-parseable)
+  sol log --all --json              the FULL op-log: {version, ops:[{seq, id, type, path, by, message, root, parents, prov}]}`,
+    diff: `sol diff                          working tree vs HEAD
+  sol diff <ref>                    working tree vs a branch/commit
+  sol diff <ref> <ref>              tree vs tree
+  sol diff <path>                   one file, working tree vs HEAD
+  sol diff --json                   array of {path, kind, conflicted} for the working diff`,
+    status: `sol status                        branch, head, and the working-tree changes (conflicts called out distinctly)
+  sol status --json                 structured state: {branch, head, headAuthor, seq, sessionActor, clean, changes, conflicts}`,
+    conflicts: `sol conflicts                     list paths with unresolved <<<<<<< conflict markers (+ a per-file hunk summary)
+  sol conflicts --json              {count, conflicts:[{path, hunks:[...], base, ours, theirs}]}
+                                    base/ours/theirs are the FULL 3-way sides (base = common ancestor) so an
+                                    agent can resolve programmatically — the in-file markers are only 2-way.`,
+    check: `sol check                         run the configured test-gate command against the working tree (on demand)
+  sol check --set "<cmd>"           set the gate command (e.g. \`sol check --set "bun test"\`), stored in .sol/sol.json
+  sol check --show                  print the configured command
+  sol check --clear                 remove it (the convergence gate goes inert)
+  sol check --json                  {configured, ok, command, exitCode, output}
+
+what it's for (TEST-GATED CONVERGENCE):
+  a line-based merge can auto-converge a tree that's SEMANTICALLY broken (two agents each add a line at
+  different positions -> both survive, ZERO line conflicts). after a converging merge (pull/merge/push) the
+  gate runs automatically: if the check FAILS, the merge STAYS committed (convergence is lossless) and a
+  distinct SEMANTIC conflict is flagged — \`sol status --json\` then reports state:"SEMANTIC". resolve with a
+  follow-up commit (which clears the flag). with no check configured the gate is inert (behavior unchanged).`,
+    restore: `sol restore [--from <ref>] [<path>...]   restore a file (or the whole tree) from a ref (default HEAD)`,
+    run: `sol run [--keep <path>]... [--isolate] <command...>
+  hydrate the current tree to a sandbox, run the command, capture produced files back into a commit.
+  --isolate confines the run (no network, writes stay in the sandbox).`,
+    promote: "sol promote [branch]   point the remote's production branch at <branch> (default: current branch)",
+    git: `sol git import <repo> [dir]       import a git repo's HEAD into a new Sol repo
+  sol git export <repo> [-b branch]  replay the Sol commit DAG as git history (+ provenance trailers), then \`git push\``,
+    mr: `sol mr open [--from <branch>] [--to <branch>] [--upstream <repo>] -t "title" [-m body]
+  sol mr list | show <id> | review <id> --approve|--request-changes|--comment [-m msg]
+  sol mr comment <id> -m msg [--path f --line N] | check <id> --run -- <cmd> | merge <id> [--force] | close <id>`,
+    fork: "sol fork [<url>] <parent-repo> <new-repo> [dir]   — your own copy (all branches + history + a parent link)",
+    forks: "sol forks   — list the forks of the current repo",
+    access: "sol access [show | public | private | add <userId> <read|write|admin> | remove <userId> | add-team <teamId> <read|write|admin> | remove-team <teamId>]\n  tip: to share a NEW repo in one step, `sol push --public <repo>` (create + push + public) instead of pushing then `sol access public`.",
+    share: "sol share   — there is no separate share command: a new repo goes public in one step with `sol push --public <repo>`,\n  or flip an existing one with `sol access public`. (new repos are private by default.)",
+    auth: "sol auth [login [<web-url>] | logout | status | whoami | set-handle <name> | pat [days]]",
+    clone: "sol clone [<url>] <owner>/<repo> [dir]   — default dir = <repo> (url defaults to the hosted Sol)",
+    view: `sol view <name> [dir]             create a clone-free AGENT VIEW (default dir ./<name>)
+
+  a view is a new working directory with its OWN working tree + branch + index, that SHARES this repo's
+  content store (.sol/objects) on disk — NO object/disk duplication (git's worktrees duplicate node_modules
+  /build = gigabytes; a view duplicates nothing — only its own tiny branch op-log). it starts at the
+  parent's current head on a new branch \`view/<name>\`. N agents each in their own view commit CONCURRENTLY
+  with zero clobber (each view's commit is independent over the one shared store), then converge losslessly.
+
+example:
+  sol view agent-a              # ./agent-a shares this repo's store; commit there, then \`sol pull <parent>\``,
+    views: `sol views                         list every view of this repo (name, dir, branch, head, author, active/stale)
+  sol views --json                  machine-readable {repo, sharedObjects, views[]}
+  sol views --prune                 drop registry entries whose working dir is gone
+  sol views --prune <name> [--delete]   prune one view (--delete also removes its working dir)`,
+    env: `sol env <subcommand>              .sol/env/ legibility + gate management
+
+  TRUST BOUNDARY: env READS are AGENT-SAFE / keyless — ls/show/schema/diff/validate/audit touch the SCHEMA + the
+  host-visible gate metadata, never a value, and need no key. the GATE-MANAGEMENT edits (audience add/rm, anchor)
+  are OPERATOR-AUTHENTICATED: they mutate committed state and must be cryptographically SIGNED, so they require
+  SOL_RECOVERY_CODE (a keyless agent is refused). reads legible to all; management writes proven.
+
+read subcommands (agent-safe, keyless):
+  sol env ls                        list envs (extends, config/secret counts, the runtime recipient handle)
+  sol env show <env>                the resolved (base ⊕ overlay) view — secrets render [sealed]/[unset], NEVER values
+  sol env schema [--write]          the de-valued cross-env schema (the agent's read surface); --write regenerates schema.lock
+  sol env diff <a> <b>              value-blind shape delta between two envs (name/type/audience/presence)
+  sol env validate [--agent <id>]   structural checks: fail-closed, drift, audience integrity, agent-blind, schema freshness
+  sol env validate --remote         ALSO consult the REMOTE anchor (FINDING A): flag a locally re-keyed/forked env HARD
+  sol env verify                    alias for \`validate --remote\` — the external owner-anchor cross-check
+  sol env audit <env>               journal-authentic who-can-decrypt + file-vs-journal drift (identifiers only)
+  sol env audience ls               list the gate (audience.toml) — public material only
+
+management subcommands (operator-authenticated — need SOL_RECOVERY_CODE; a keyless agent is refused):
+  sol env init [--envs a,b,c]       scaffold .sol/env/; an operator with SOL_RECOVERY_CODE also writes creator.pin (anchors genesis)
+  sol env anchor                    pin the current operator as creator (creator.pin) for an already-UNANCHORED repo
+  sol env audience add|rm           BUILD/manage the gate — SIGNED gate ops; see \`sol env audience --help\`
+
+every subcommand takes --json. (sol env <sub> --help for a focused page.)`,
+    "env diff": `sol env diff <a> <b> [--json]   value-blind shape delta between two envs
+
+reports name/type/audience/presence deltas (+ added, - removed, ~ changed) — NEVER value-equality. a config key
+whose VALUE differs between envs is "unchanged" here (the diff is value-blind by design).
+
+example:
+  sol env diff staging production`,
+    "env validate": `sol env validate [--agent <id>] [--remote] [--json]   structural, value-blind checks over .sol/env/
+
+checks: fail-closed grammar (no plaintext under a secret slot), cross-env drift, audience integrity (every aud
+resolves through audience.toml; sealed recipients == the audience), the agent is in NO audience, schema.lock fresh.
+  --agent <id>   assert <id> (or SOL_AGENT_ACCOUNT) appears in no secret audience (the locked CI invariant)
+  --remote       ALSO consult the REMOTE EXTERNAL ANCHOR — the remote-tracked env-owner identity + journal head.
+                 the LOCAL checks are self-referential (they verify .sol/env vs creator.pin + the signed journal,
+                 never the root-of-trust key against an externally-anchored owner), so a foreign key that rebuilt
+                 .sol/env (a RE-KEY, FINDING A) reports GREEN locally. --remote flags it HARD against the owner the
+                 remote pinned (TOFU on first push) — the root of trust a full-FS attacker cannot rewrite.`,
+    "env verify": `sol env verify [--agent <id>] [--json]   \`validate\` that ALWAYS consults the remote anchor (= \`validate --remote\`)
+
+flags a locally re-keyed or forked env (FINDING A) HARD against the remote-pinned owner identity + journal head.
+needs a configured remote + SOL_TOKEN (\`sol remote\` / \`sol auth login\`); offline it warns the anchor was not consulted.`,
+    "env show": `sol env show <env> [--json]   the resolved (base ⊕ overlay) view of one env — secrets render [sealed]/[unset], NEVER values`,
+    "env schema": `sol env schema [--write] [--json]   the de-valued, cross-env-unioned schema (the agent's read surface)
+
+  --write   regenerate + commit .sol/env/schema.lock from the current world
+config renders its plaintext value; a secret renders only its per-env STATE (sealed/unset) — value-free by construction.`,
+    "env ls": `sol env ls [--json]   list registered envs (extends, config/secret counts, the runtime recipient handle)
+
+the \`runtime=\` column is the real manifest.runtime[env] binding — the machine recipient that decrypts the env at
+deploy/boot. blank until you \`sol secret runtime provision --env <env>\` (which mints + records it).`,
+    "env audit": `sol env audit <env> [--json]   the journal-authentic who-can-decrypt + drift (identifiers only, never a value)
+
+  == \`sol secret audit --env <env>\` — same backing as the \`secret_audit\` MCP tool.
+  who-can-decrypt   per secret, the recipients its audience expands to through the gate REPLAYED from the SIGNED
+                    gate ops (NOT the hand-editable audience.toml) — so a file-poisoned gate cannot inflate it.
+  drift             handles whose audience.toml membership disagrees with the journal-authored set (a hand-added
+                    intruder / a swapped pubkey), plus the journal trust verdict.
+agent-safe: identifiers + the trust verdict only; no value, no key.`,
+    "env anchor": `sol env anchor [--json]   pin the CURRENT operator as the env creator (creator.pin) for an UNANCHORED repo
+
+\`sol env validate\` warns \`genesis-anchor: UNANCHORED\` when a repo has a journal-derived gate but NO creator pin
+(the pin was never written, or was lost) — a re-bootstrap by a foreign key then can't be told from the true
+creator. \`env anchor\` writes creator.pin as the current operator, CROSS-BOUND to the main op-log genesis (the
+external birth cert a full-FS attacker cannot rewrite). thereafter only this key may author the gate-bootstrap.
+
+operator-authenticated: requires SOL_RECOVERY_CODE (a keyless caller cannot anchor). REFUSES to re-pin over an
+existing creator.pin (re-pinning IS the re-bootstrap attack). \`sol env init\` already anchors at genesis when the
+creator runs it with a recovery code; \`anchor\` is the after-the-fact fix for a repo that wasn't.`,
+    "env init": `sol env init [--envs a,b,c]   scaffold .sol/env/ (manifest + base + per-env files + an empty audience.toml)
+
+default envs: development,staging,production. \`sol secret declare\` also creates the manifest on first use.
+when run by an OPERATOR (SOL_RECOVERY_CODE set), it ALSO writes creator.pin — pinning that operator as the genesis
+creator (anchoring the gate-bootstrap). a keyless init leaves the genesis UNANCHORED (fix later with \`sol env anchor\`).`,
+    "env audience": `sol env audience add <handle> <account> [--pubkey <sol1pk_…>]   add a recipient to THE GATE (audience.toml)
+  sol env audience rm <handle> [<account>]                       remove an account (or the whole handle)
+  sol env audience ls [<handle>]                                 list the gate (or one handle's recipients)
+
+a HANDLE is role:NAME | team:NAME | machine:NAME. the account's X25519 PUBLIC key is sourced, in order:
+  --pubkey <sol1pk_…>   an explicit key (offline / not-yet-published)
+  your local keystore   when <account> is YOUR OWN identity (no network)
+  the key directory     GET /keys/<account> (host-blind, public material only — they must \`sol keys publish\` first)
+
+this is the KEYSTONE: declare -> set -> seal -> reveal works WITHOUT hand-editing audience.toml.
+adding/removing here changes WHO a future \`sol secret set\` seals to; reseal existing values with \`sol secret audience\`.
+
+examples:
+  sol env audience add machine:runtime-prod machine:runtime-prod        # source my own published pubkey
+  sol env audience add team:payments alice@acme                          # fetch alice's key from the directory
+  sol env audience add role:deploy ci@acme --pubkey sol1pk_9af…          # pin an explicit key offline
+  sol env audience ls team:payments`,
+    secret: `sol secret <subcommand>           per-secret lifecycle. declare/ref/list/audit are AGENT-SAFE; set/reveal/inject/export touch values
+
+schema-side (agent-safe — touch the schema/gate metadata, never a value):
+  sol secret declare NAME --env E [--audience h1,h2] [--type T] [--hide-name]   add an UNSET slot (no value)
+  sol secret ref NAME --env E       print the sol:// handle for code/config (never a value)
+  sol secret list --env E           names + audience + set? (NEVER values)
+  sol secret config set K V --env E plaintext config (rejected if K is a declared secret)
+  sol secret audit --env E          journal-authentic who-can-decrypt + drift (== \`sol env audit E\`; identifiers only)
+
+value-bearing (recipient-gated / human side-channel — the agent holds no key):
+  sol secret set NAME --env E       seal a value from a SECURE SIDE-CHANNEL (no-echo TTY / --stdin / --fd) — NEVER argv
+  sol secret reveal NAME --env E    recipient-gated read; a non-recipient / the host / the agent is refused
+  sol secret inject --env E -- cmd  decrypt MY readable secrets into a SUBPROCESS env only (masked from this process)
+  sol secret export --env E         DEPLOY/BOOT producer: the runtime decrypts EVERY secret it's a recipient of to a
+                                    NAME=value map -> a SECURE SINK (--fd / non-TTY). inject (run a cmd) vs export
+                                    (materialize the map). see \`sol secret export --help\`.
+
+management (operator-authenticated — SIGNED gate ops; need SOL_RECOVERY_CODE):
+  sol secret audience add|rm NAME --env E <handle>   change a secret's audience + AUTO-RESEAL (recipient-only)
+  sol secret runtime provision --env E [--fd N]      mint + add the env's machine:runtime-<E> recipient; see \`--help\`
+  sol secret runtime ls | show --env E               the manifest runtime binding (agent-safe)
+
+agent (no value ever):
+  sol secret mcp                    serve the AGENT-SAFE secret MCP over stdio (== \`sol mcp --secret\`) — the 14
+                                    value-free env/secret tools; an agent declares/refs/lists/audits + triggers
+                                    deploys WITHOUT ever seeing a value. register: \`claude mcp add sol-secrets -- sol secret mcp\`
+
+(sol secret <sub> --help for a focused page.)`,
+    "secret set": `sol secret set NAME --env E       seal a value to the env audience, CLIENT-SIDE (agent-blind, host-blind)
+
+the value comes from a SECURE SIDE-CHANNEL, in priority order — NEVER from argv (which lands in ps/history/the
+agent's tool-call record):
+  --fd <n>     read from an inherited file descriptor (orchestrator path)
+  --stdin      read from piped stdin (CI path)
+  (TTY)        a no-echo prompt (human path)
+
+write-authz: declaring a slot is open, but OVERWRITING an already-sealed value requires you to be a CURRENT
+RECIPIENT of that secret — a non-recipient (incl. the agent) cannot clobber a value it can't read. a \`set\` on an
+undeclared name auto-declares the slot first.
+
+examples:
+  sol secret set STRIPE_KEY --env production                 # no-echo TTY prompt
+  printf %s "$VALUE" | sol secret set STRIPE_KEY --env production --stdin   # CI/pipe`,
+    "secret declare": `sol secret declare NAME --env E [--audience h1,h2] [--type T] [--hide-name]   add an UNSET secret slot
+
+AGENT-SAFE: touches the SCHEMA only, never a value. the slot is sealed-PENDING until \`sol secret set\` supplies a value.
+  --audience h1,h2   the seal audience handles (else the env file's @audience). resolve through audience.toml.
+  --type T           an advisory shape hint ("string" | "url" | …)
+  --hide-name        name-hiding opt-up: the real name lives only in the sealed body
+
+example:
+  sol secret declare DATABASE_URL --env staging --audience machine:runtime-staging --type url`,
+    "secret reveal": `sol secret reveal NAME --env E [--field F]   print a secret's value — RECIPIENT-ONLY
+
+refuses for a non-recipient, the host, and the agent (they hold no audience key — UNREADABLE by construction, not a
+policy flag). a corrupted/tampered leaf is reported as a DECRYPT failure, distinct from "not a recipient".
+  --field F   project a #field out of a multi-value (JSON) secret`,
+    "secret inject": `sol secret inject --env E -- <cmd> [args...]   run <cmd> with MY readable secrets in its env
+
+decrypts only the secrets I am a recipient of into the SUBPROCESS environment — they never touch this process's
+stdout and are never echoed. a non-recipient sees an empty injection (refused). name-hidden secrets are skipped
+(no env-var name to inject under).
+
+example:
+  SOL_RECOVERY_CODE=… sol secret inject --env production -- wrangler deploy`,
+    "secret audience": `sol secret audience add|rm NAME --env E <handle>   change ONE secret's audience + AUTO-RESEAL
+
+re-wraps the sealed value to the new audience. requires YOU to be a CURRENT RECIPIENT (you decrypt, then re-seal —
+the host holds no key); a non-recipient is refused. bumps the seal epoch.
+
+example:
+  sol secret audience add STRIPE_KEY --env production team:payments`,
+    "secret config": `sol secret config set KEY VAL --env E   set a PLAINTEXT config value
+
+rejected if KEY is a declared secret (use \`sol secret set\` for those). config is agent- and host-visible by design.`,
+    "secret list": `sol secret list --env E [--json]   names + audience + set? for an env — AGENT-SAFE, never values`,
+    "secret ref": `sol secret ref NAME --env E   print the sol:// handle for code/config (e.g. sol://production/STRIPE_KEY) — never a value`,
+    "secret export": `sol secret export --env E [--format dotenv|json] [--fd N]   DEPLOY/BOOT-time value producer (recipient-gated)
+
+re-derives the RUNTIME recipient's private key from its bootstrap root (SOL_RUNTIME_RECOVERY_CODE, the env-scoped
+seed seeded on the deploy box / read at boot) and decrypts EVERY secret in --env the runtime is a recipient of into
+a NAME=value map. this is the producer for the deploy secrets payload (Mode A) and the boot-time process env (Mode B).
+falls back to the CALLER's own identity when no runtime root is present (a human recipient running export locally).
+
+inject vs export:
+  inject   RUNS a command with the values in its SUBPROCESS env (ephemeral; never materialized to a file)
+  export   MATERIALIZES the NAME=value map to a sink the deploy/boot consumes (a secrets file / an inherited fd)
+
+SINK GATING (value-bearing — never a log/TTY):
+  --fd <n>     write the rendered map to an inherited file descriptor (the orchestrator/secrets-file path)
+  (non-TTY)    a piped/redirected stdout is allowed; an interactive TTY is REFUSED (so a value can't land onscreen)
+  --format     dotenv (NAME='value', default) | json (a compact object)
+
+the agent (in no audience, holding no runtime root) cannot run this to read a value.
+
+examples:
+  sol secret export --env production --fd 3 3>secrets.out          # deploy: materialize to a secrets file
+  SOL_RUNTIME_RECOVERY_CODE=… sol secret export --env production --format json --fd 3 3>env.json`,
+    "secret audit": `sol secret audit --env E [--json]   journal-authentic who-can-decrypt + drift (identifiers only)
+
+== \`sol env audit E\`. who-can-decrypt expands each secret's audience through the gate REPLAYED from the SIGNED gate
+ops (not the hand-editable audience.toml); drift names handles whose file membership disagrees with the journal-
+authored set, plus the journal trust verdict. agent-safe: identifiers + verdict only, never a value.`,
+    "secret runtime": `sol secret runtime provision --env E [--fd N] [--json]   PROVISION the env's machine recipient (machine:runtime-<E>)
+  sol secret runtime ls [--json]                          the manifest runtime binding per env (agent-safe)
+  sol secret runtime show --env E [--json]                one env's runtime binding + whether it's in the authentic gate
+
+PHASE B — the runtime is a RECIPIENT. \`provision\` mints the env's BOOTSTRAP ROOT (a recovery code — the runtime's
+standing decryptor), derives its X25519 identity, adds machine:runtime-<E> to the env audience as a SIGNED gate op,
+and records manifest.runtime[E]. it prints ONLY public material + the custody instruction; the ROOT goes to a
+SECURE SINK and is NEVER shown on a TTY or logged.
+
+operator-authenticated: \`provision\` is a signed gate op — needs SOL_RECOVERY_CODE (a keyless agent is refused).
+the ROOT sink (value-bearing):
+  --fd <n>     write the bootstrap root to an inherited fd (custody it write-only in your runtime secret store)
+  (non-TTY)    a piped/redirected stdout is allowed; an interactive TTY is REFUSED
+custody the root WRITE-ONLY (e.g. the CF Secrets Store binding env.SOL_RUNTIME_ROOT); the runtime reads it at boot
+to \`sol secret export\`. the agent/host never holds it.
+
+example:
+  SOL_RECOVERY_CODE=… sol secret runtime provision --env production --fd 3 3>runtime-root.secret`,
+    "secret mcp": `sol secret mcp   serve the AGENT-SAFE secret-manager MCP over stdio (identical to \`sol mcp --secret\`)
+
+exposes the 14 value-free env/secret tools (env_list/show/schema/diff/validate, secret_declare/ref/list/audit,
+secret_audience_ls/add/rm, deploy_trigger, secret_export_trigger) so an agent manages env + secrets across ALL
+environments WITHOUT ever seeing a value. set/reveal/inject/export are ABSENT by construction; every result passes
+the value-blind egress sanitizer. the server runs as the AGENT identity (keyless) unless an operator sets
+SOL_RECOVERY_CODE (which only unlocks SIGNED gate edits, never a value op).
+
+register:
+  claude mcp add sol-secrets -- sol secret mcp        # the INSTALLED binary serves it (no separate bin on PATH)`,
+    mcp: `sol mcp [--secret] [--http [--port N] [--host H] [--token T]]   serve a sol MCP server
+
+  sol mcp              the file/VCS AUTHORING server (sol_write/read/edit/ls/move/rm/commit/history) — an agent
+                       authors directly into the op-log + content store, no working copy.
+  sol mcp --secret     the AGENT-SAFE SECRET-MANAGER server (== \`sol secret mcp\`) — 14 value-free env/secret tools.
+
+transport: stdio is the DEFAULT (local pipe). \`--http\` serves the SAME tool surface over the MCP Streamable HTTP
+transport — the enabler for hosting it on a remote. an HTTP MCP is a NETWORK endpoint, so it requires a bearer
+token: set SOL_MCP_TOKEN (or pass --token <T>) and every request must send \`Authorization: Bearer <token>\` (else
+401). it serves on http://127.0.0.1:8765/mcp by default; override with --host / --port.
+
+register: \`claude mcp add sol -- sol mcp\` | \`claude mcp add sol-secrets -- sol mcp --secret\`
+http:     \`SOL_MCP_TOKEN=… sol mcp --http --port 8765\`  (then point an HTTP MCP client at http://HOST:PORT/mcp)`,
+    resolve: `sol resolve <sol://env/NAME[#field]>   resolve a sol:// reference to its value (CLIENT-SIDE, recipient-gated)
+
+  sol resolve sol://production/STRIPE_KEY
+  sol resolve sol://production/DATABASE_URL#password     # project a JSON sub-field
+  sol resolve sol://$ENV/DB --env production              # $ENV resolved from --env / SOL_ENV
+
+refused for a non-recipient (host/agent-blind). a missing or malformed reference is a usage error, not a crash.`
+  };
+  if (wantsHelp && argv[0]) {
+    const twoKey = argv[1] ? `${argv[0]} ${argv[1]}` : undefined;
+    const page = twoKey && SUBHELP[twoKey] || SUBHELP[argv[0]];
+    if (page) {
+      console.log(page);
+      return;
+    }
+  }
+  const cmd = argv[0] && wantsHelp ? "help" : argv[0];
+  if (!process.env.SOL_TOKEN && new Set(["clone", "push", "pull", "promote", "fork", "forks", "mr", "access", "keys", "hide", "seal"]).has(cmd ?? "")) {
+    const t = await loadStoredToken2();
+    if (t)
+      process.env.SOL_TOKEN = t;
+  }
+  if (new Set(["clone", "pull", "switch", "merge", "restore", "checkout", "fork", "view", "diff", "show", "blame", "log"]).has(cmd ?? "")) {
+    try {
+      const { loadSelfIdentity: loadSelfIdentity2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+      const { openContent: openContent2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+      const ring = existsSync18(solDir) ? loadKeyRing() : new (await Promise.resolve().then(() => (init_crypto(), exports_crypto))).KeyRing;
+      const self = loadSelfIdentity2();
+      setSealedDecryptor((boxStr) => {
+        const box = JSON.parse(boxStr);
+        const opened = openContent2(ring, box, actor, self);
+        return opened === "<<unreadable>>" ? undefined : opened;
+      });
+    } catch {}
+  }
+  const servesMcp = cmd === "mcp" || cmd === "secret" && args[0] === "mcp";
+  const release = !servesMcp && new Set(["add", "track", "commit", "checkpoint", "rm", "gc", "branch", "tag", "switch", "merge", "undo", "revert", "pull", "push", "restore", "checkout", "run", "seal", "view", "env", "secret"]).has(cmd) && existsSync18(solDir) ? acquireLock() : undefined;
+  try {
+    switch (cmd) {
+      case "init": {
+        const here = join19(procCwd, ".sol");
+        if (existsSync18(here))
+          die("already a sol repo: " + procCwd);
+        if (repoRoot && repoRoot !== procCwd && !args.includes("--force")) {
+          die(`already inside a Sol repo at ${repoRoot}
+  -> just commit into it: \`sol commit ...\` works from here (sol walks up to find the repo)
+  -> to nest a NEW repo here anyway: \`sol init --force\``);
+        }
+        mkdirSync12(here, { recursive: true });
+        new FileStore(here);
+        console.log(`initialized empty sol repo in ${here}`);
+        break;
+      }
+      case "keygen": {
+        const { generateKeypair: generateKeypair2 } = await Promise.resolve().then(() => (init_sign(), exports_sign));
+        const kp = generateKeypair2();
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({ seed: kp.seed, pub: kp.pub, fingerprint: kp.fingerprint }));
+          break;
+        }
+        console.log(`fingerprint:  ${kp.fingerprint}`);
+        console.log(`public key:   ${kp.pub}`);
+        console.log(`SOL_SIGNING_KEY=${kp.seed}`);
+        console.log(`
+# provision the agent with the seed above, then trust it (use the single fingerprint printed above):
+#   sol trust <agent-name> <fingerprint>`);
+        break;
+      }
+      case "keys": {
+        const { deriveIdentity: deriveIdentity2, generateRecoveryCode: generateRecoveryCode2, pubFingerprint: pubFingerprint2, signPubkey: signPubkey2, verifyPubkeySig: verifyPubkeySig2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+        const { exportBundle: exportBundle2, importBundle: importBundle2, loadIdentity: loadIdentity2, pinVerified: pinVerified2, saveIdentity: saveIdentity2 } = await Promise.resolve().then(() => (init_identity_store(), exports_identity_store));
+        const accountOf = async () => {
+          if (process.env.SOL_ACCOUNT)
+            return process.env.SOL_ACCOUNT;
+          const tok = process.env.SOL_TOKEN || await loadStoredToken2();
+          const h = tok ? identityFromToken2(tok)?.handle : undefined;
+          return h || die("no account identity — run `sol auth login` (or set SOL_ACCOUNT for self-host)");
+        };
+        const dirUrl = (process.env.SOL_REMOTE || DEFAULT_REMOTE_URL2).replace(/\/+$/, "");
+        const sub = args[0];
+        const wantJson = args.includes("--json");
+        if (sub === "init") {
+          if (loadIdentity2() && !args.includes("--force"))
+            die("identity already exists — `sol keys rotate` to roll the epoch, or `sol keys init --force` to replace");
+          const accountId = await accountOf();
+          const recoveryCode = generateRecoveryCode2();
+          const id = deriveIdentity2(accountId, recoveryCode, 1);
+          const fingerprint = pubFingerprint2(id.x25519Pub);
+          saveIdentity2({ accountId, x25519Pub: id.x25519Pub, edPub: id.edPub, keyEpoch: 1, fingerprint, createdAt: Date.now() });
+          if (wantJson) {
+            console.log(JSON.stringify({ accountId, keyEpoch: 1, fingerprint, recoveryCode }));
+            break;
+          }
+          console.log(`identity minted for @${accountId} (X25519, epoch 1) — host-blind: the private key is NEVER stored or sent.`);
+          console.log(`fingerprint:  ${fingerprint}`);
+          console.log(`
+  RECOVERY CODE (shown ONCE — write it down, it is the ONLY way to recover this key on a new device):
+`);
+          console.log(`    ${recoveryCode}
+`);
+          console.log(`next: \`sol keys publish\` to share your public key so others can seal to you.`);
+          break;
+        }
+        if (sub === "publish" || sub === "rotate") {
+          const stored2 = loadIdentity2() || die("no identity yet — run `sol keys init` first");
+          const accountId = stored2.accountId;
+          const recoveryCode = process.env.SOL_RECOVERY_CODE || die("set SOL_RECOVERY_CODE to your recovery code (the private key is re-derived from it; it is never stored)");
+          const keyEpoch = sub === "rotate" ? stored2.keyEpoch + 1 : stored2.keyEpoch;
+          const id = deriveIdentity2(accountId, recoveryCode, keyEpoch);
+          if (sub === "publish" && id.x25519Pub !== stored2.x25519Pub)
+            die("recovery code does not match this identity (derived a different key)");
+          const sig = signPubkey2(id);
+          const token = process.env.SOL_TOKEN || await loadStoredToken2() || authExpired2();
+          const res = await fetch(`${dirUrl}/keys`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ accountId, x25519Pub: id.x25519Pub, edPub: id.edPub, keyEpoch, sig }) });
+          if (!res.ok)
+            die(`publish failed: ${res.status} ${(await res.text().catch(() => "")).slice(0, 200)}`);
+          if (sub === "rotate")
+            saveIdentity2({ ...stored2, x25519Pub: id.x25519Pub, edPub: id.edPub, keyEpoch, fingerprint: pubFingerprint2(id.x25519Pub) });
+          if (wantJson) {
+            console.log(JSON.stringify({ accountId, keyEpoch, fingerprint: pubFingerprint2(id.x25519Pub), published: true }));
+            break;
+          }
+          console.log(`published @${accountId} pubkey (epoch ${keyEpoch}) to the directory — public key only; the host stays blind.`);
+          if (sub === "rotate")
+            console.log("  NOTE: past sealed content stays wrapped to the OLD epoch — `sol seal --reapply` re-wraps it (no-recall until then).");
+          break;
+        }
+        if (sub === "verify") {
+          const acct = args[1] || die("usage: sol keys verify <accountId> <fingerprint>");
+          const claimed = args[2] || die("usage: sol keys verify <accountId> <fingerprint>");
+          const res = await fetch(`${dirUrl}/keys/${encodeURIComponent(acct)}`);
+          if (res.status === 404)
+            die(`no published key for @${acct} (ask them to run \`sol keys publish\`)`);
+          if (!res.ok)
+            die(`directory lookup failed: ${res.status}`);
+          const entry = await res.json();
+          const fp = pubFingerprint2(entry.x25519Pub);
+          const sigOk = verifyPubkeySig2(entry);
+          const match = fp.replace(/-/g, "").toLowerCase() === claimed.replace(/[-:\s]/g, "").toLowerCase();
+          if (match && sigOk)
+            pinVerified2(acct, fp);
+          if (wantJson) {
+            console.log(JSON.stringify({ accountId: acct, fingerprint: fp, keyEpoch: entry.keyEpoch, selfSigned: sigOk, fingerprintMatch: match, verified: match && sigOk }));
+            break;
+          }
+          console.log(`@${acct} (epoch ${entry.keyEpoch})`);
+          console.log(`  directory fingerprint: ${fp}`);
+          console.log(`  self-signature:        ${sigOk ? "valid ✓" : "INVALID ✗ (possible MITM — do NOT trust)"}`);
+          console.log(`  your fingerprint:      ${match ? "MATCH ✓ (pinned, trust-on-first-use)" : "MISMATCH ✗ — the directory key differs from what you were told"}`);
+          if (!(match && sigOk))
+            process.exitCode = 1;
+          break;
+        }
+        if (sub === "export") {
+          const stored2 = loadIdentity2() || die("no identity to export — `sol keys init` first");
+          const recoveryCode = process.env.SOL_RECOVERY_CODE || die("set SOL_RECOVERY_CODE — the export wraps it under a passphrase (the private key is never stored in the clear)");
+          const passphrase = process.env.SOL_KEYSTORE_PASSPHRASE || die("set SOL_KEYSTORE_PASSPHRASE to encrypt the backup bundle");
+          const bundle = exportBundle2(stored2.accountId, stored2.keyEpoch, recoveryCode, passphrase);
+          console.log(JSON.stringify(bundle, null, 2));
+          break;
+        }
+        if (sub === "import") {
+          const passphrase = process.env.SOL_KEYSTORE_PASSPHRASE || die("set SOL_KEYSTORE_PASSPHRASE to decrypt the bundle");
+          const file = args[1] || die("usage: sol keys import <bundle.json>   (set SOL_KEYSTORE_PASSPHRASE)");
+          const bundle = JSON.parse(readFileSync18(file, "utf8"));
+          let recovered;
+          try {
+            recovered = importBundle2(bundle, passphrase);
+          } catch {
+            die("import failed — wrong passphrase or a tampered bundle");
+          }
+          const id = deriveIdentity2(recovered.accountId, recovered.recoveryCode, recovered.keyEpoch);
+          saveIdentity2({ accountId: recovered.accountId, x25519Pub: id.x25519Pub, edPub: id.edPub, keyEpoch: recovered.keyEpoch, fingerprint: pubFingerprint2(id.x25519Pub), createdAt: Date.now() });
+          console.log(`imported identity for @${recovered.accountId} (epoch ${recovered.keyEpoch}) — re-derived locally; the recovery code stays yours.`);
+          console.log(`  RECOVERY CODE (keep it safe):
+
+    ${recovered.recoveryCode}
+`);
+          break;
+        }
+        const stored = loadIdentity2();
+        if (!stored) {
+          console.log("no identity yet — `sol keys init` mints your X25519 identity keypair (host-blind).");
+          break;
+        }
+        if (wantJson) {
+          console.log(JSON.stringify({ accountId: stored.accountId, keyEpoch: stored.keyEpoch, fingerprint: stored.fingerprint, x25519Pub: stored.x25519Pub }));
+          break;
+        }
+        console.log(`identity: @${stored.accountId} (epoch ${stored.keyEpoch})`);
+        console.log(`  fingerprint: ${stored.fingerprint}`);
+        console.log(`  the private key is NOT stored — it re-derives from your recovery code (host stays blind).`);
+        break;
+      }
+      case "trust": {
+        if (!existsSync18(solDir))
+          die("not a sol repo — run `sol init` first");
+        const map = loadTrust();
+        if (args[0] === "--remove" || args[0] === "-r") {
+          const name2 = args[1] || die("trust --remove needs an actor name");
+          delete map[name2];
+          saveTrust(map);
+          console.log(`untrusted ${name2}`);
+          break;
+        }
+        const positional = args.filter((a) => !a.startsWith("-"));
+        if (!positional.length) {
+          if (args.includes("--json")) {
+            const trusted = Object.entries(map).map(([actor2, fingerprint2]) => ({ actor: actor2, fingerprint: fingerprint2 }));
+            console.log(JSON.stringify({ count: trusted.length, trusted, map }));
+          } else {
+            const names = Object.keys(map);
+            if (!names.length)
+              console.log("(no trusted actors yet — `sol trust <name> <fingerprint>`)");
+            for (const n of names)
+              console.log(`${n.padEnd(20)} ${map[n]}`);
+          }
+          break;
+        }
+        const name = positional[0];
+        const fp = positional[1] || die("trust needs: sol trust <actor-name> <fingerprint>");
+        const { fingerprintOf: fingerprintOf2, normalizeFingerprint: normalizeFingerprint2 } = await Promise.resolve().then(() => (init_sign(), exports_sign));
+        let fingerprint;
+        if (/sol1:/i.test(fp)) {
+          const norm = normalizeFingerprint2(fp);
+          if (!norm)
+            die(`malformed fingerprint "${fp}" — expected sol1: followed by exactly 16 hex chars (e.g. sol1:6944abd09081aeae). check for a doubled/duplicated value or stray characters.`);
+          fingerprint = norm;
+        } else {
+          try {
+            fingerprint = fingerprintOf2(fp);
+          } catch {
+            die(`"${fp}" is neither a sol1: fingerprint nor a valid public key — pass the fingerprint from \`sol keygen\` (sol1:…) or the recipient's public key.`);
+          }
+        }
+        map[name] = fingerprint;
+        saveTrust(map);
+        console.log(`trusted ${name} = ${fingerprint}`);
+        break;
+      }
+      case "track":
+      case "add": {
+        if (!existsSync18(solDir))
+          die("not a sol repo — run `sol init` first");
+        const files = args.filter((a) => a !== "." && !a.startsWith("-"));
+        if (!files.length) {
+          console.log('every change is auto-captured — just `sol commit`. Sol has no staging area, so there is nothing to "add".');
+          console.log("use `sol track <ignored-file>` only to force-track a normally-ignored path.");
+          break;
+        }
+        let n = 0;
+        for (const f of files) {
+          const rf = repoRel(f);
+          if (!existsSync18(join19(cwd, rf))) {
+            console.error("skip (not on disk): " + f);
+            continue;
+          }
+          addInclude(rf);
+          n++;
+        }
+        console.log(`will track ${n} path(s) on the next commit`);
+        break;
+      }
+      case "commit":
+      case "checkpoint": {
+        const { repo, log } = open();
+        let message = "";
+        const paths = [];
+        const wholeTreeOptIn = args.includes("--whole-tree");
+        const ca = args.filter((x) => x !== "--whole-tree" && x !== "--force");
+        const mi = ca.indexOf("-m");
+        if (mi >= 0) {
+          message = ca[mi + 1] ?? "";
+          for (let i = 0;i < ca.length; i++)
+            if (i !== mi && i !== mi + 1)
+              paths.push(ca[i]);
+        } else {
+          message = ca.join(" ");
+        }
+        if (!message)
+          die('commit needs a message: sol commit "what you did"  (scoped: sol commit -m "msg" file1 file2)');
+        const parentHead = await repo.head();
+        const mergeHeadPath = join19(solDir, "MERGE_HEAD");
+        const parent2 = existsSync18(mergeHeadPath) ? readFileSync18(mergeHeadPath, "utf8").trim() || undefined : undefined;
+        let changed = 0;
+        let commitRoot = parentHead;
+        if (paths.length) {
+          for (const p of paths) {
+            const rp = repoRel(p);
+            if (existsSync18(join19(cwd, rp))) {
+              if (await snapshotFile(repo, rp))
+                changed++;
+            } else if ((await repo.list()).includes(rp)) {
+              await repo.deleteFile(rp);
+              changed++;
+            } else {
+              console.error("skip (not on disk, not tracked): " + p);
+            }
+          }
+          commitRoot = await repo.head();
+        } else {
+          const optedIn = wholeTreeOptIn || process.env.SOL_ALLOW_WHOLE_TREE === "1";
+          const otherActors = [...new Set((await log.history()).map((o) => o.by).filter((b) => !!b && b !== actor))];
+          const otherActorPresent = otherActors.length > 0;
+          if (process.env.SOL_ACTOR && !optedIn && otherActorPresent) {
+            const others = otherActors.join(", ");
+            die(`refusing a whole-tree commit as "${actor}" — other author(s) have committed here (${others}), so sweeping the whole tree would mis-attribute their pending files to you. (this guard only fires because they're present; a solo author commits the whole tree freely.)
+  scope to your files: sol commit -m "${message}" <your files>   (or a per-agent SolWorkspace/MCP)
+  if you truly own the whole tree: add --whole-tree  or set SOL_ALLOW_WHOLE_TREE=1`);
+          }
+          const snap = await snapshotTree(repo);
+          changed = snap.changed;
+          commitRoot = snap.root;
+          if (!process.env.SOL_ACTOR && changed > 1) {
+            console.error(`note: whole-tree commit attributes all ${changed} pending files to ${actor}. for concurrent agents, prefer \`sol commit -m "msg" <files>\`.`);
+          }
+        }
+        if (!args.includes("--force")) {
+          const cstore = loadStore();
+          const cd = diffTrees(cstore, parentHead, commitRoot);
+          const changedPaths = paths.length ? paths.map((p) => repoRel(p)) : [...cd.added, ...cd.modified.map((m) => m.path)];
+          for (const p of changedPaths) {
+            const f = fileAt(cstore, commitRoot, p);
+            if (f && f.encoding !== "base64" && /^<{7}( |$)/m.test(f.content) && /^>{7}( |$)/m.test(f.content)) {
+              die(`refusing to commit unresolved conflict markers in ${p} — resolve the <<<<<<< / >>>>>>> blocks first (or \`sol commit --force ...\` to override).`);
+            }
+          }
+        }
+        await appendCommit(log, commitRoot, message, parentHead, parent2);
+        if (parent2) {
+          try {
+            unlinkSync8(mergeHeadPath);
+          } catch {}
+        }
+        const refs = await loadRefs(log);
+        saveRefs(refs);
+        writeWorkingIndex(await repo.list());
+        clearMergeConflicts(solDir);
+        clearSemanticFlag(solDir);
+        console.log(`commit ${commitRoot.slice(0, 14)} — ${message}  (${changed} file change${changed === 1 ? "" : "s"})`);
+        break;
+      }
+      case "status": {
+        const { repo, log } = open();
+        const refs = existsSync18(refsPath()) ? await loadRefs(log) : undefined;
+        const head = await repo.head();
+        const headOp = head ? [...await log.history()].reverse().find((o) => o.rootAfter === head) : undefined;
+        const headBy = headOp?.by ?? "?";
+        const seq = await log.seq();
+        const rows = workingChangeRows(loadStore(), head);
+        const conflicts = unresolvedConflictPaths();
+        const dirty = rows.length;
+        const clean = dirty === 0 && conflicts.length === 0;
+        const semantic = activeSemanticFlag(solDir, head || undefined);
+        const state = conflicts.length ? "CONFLICTED" : dirty ? "DIRTY" : semantic ? "SEMANTIC" : !head ? "EMPTY" : "CLEAN";
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({
+            branch: refs ? refs.current : "main",
+            head: head || null,
+            headAuthor: head ? headBy : null,
+            seq,
+            sessionActor: actor,
+            state,
+            clean,
+            changes: rows.map((r) => ({ path: r.path, kind: r.kind })),
+            conflicts,
+            semantic: semantic ? { check: semantic.check, exitCode: semantic.exitCode, head: semantic.head, at: semantic.at, output: semantic.output } : undefined
+          }));
+          break;
+        }
+        console.log(`repo ${cwd}`);
+        console.log(`on ${refs ? refs.current : "main"}   head ${head ? `${head.slice(0, 14)} by ${headBy}` : "(empty)"}   seq ${seq}`);
+        console.log(`you: ${actor}`);
+        if (conflicts.length) {
+          console.log(`CONFLICTED — ${conflicts.length} path(s) with unresolved conflicts:`);
+          for (const f of conflicts)
+            console.log("  ! " + f);
+          console.log("  resolve the <<<<<<< / ======= / >>>>>>> markers, then `sol commit` (`sol conflicts` to inspect)");
+        }
+        if (semantic) {
+          console.log(`SEMANTIC conflict — a merge auto-converged with no line conflicts, but the check FAILED (\`${semantic.check}\`, exit ${semantic.exitCode}).`);
+          console.log("  review the merged result and land a follow-up commit (`sol check` to re-run; it clears on pass or a new commit).");
+        }
+        if (!dirty) {
+          if (!conflicts.length && !semantic)
+            console.log("working tree clean");
+          break;
+        }
+        const conflictSet = new Set(conflicts);
+        console.log(`${dirty} uncommitted change(s):`);
+        for (const r of rows) {
+          const sigil = r.kind === "added" ? "+" : r.kind === "removed" ? "-" : conflictSet.has(r.path) ? "!" : "~";
+          console.log(`  ${sigil} ${r.path}${sigil === "!" ? "  (conflicted)" : ""}`);
+        }
+        break;
+      }
+      case "conflicts": {
+        open();
+        const paths = unresolvedConflictPaths();
+        const recorded = new Map(loadMergeConflicts(solDir).map((c) => [c.path, c]));
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({
+            count: paths.length,
+            conflicts: paths.map((p) => {
+              const r = recorded.get(p);
+              const hunks2 = conflictHunks(p).map((h) => ({ ...h, base: r?.base }));
+              return { path: p, hunks: hunks2, base: r?.base, ours: r?.ours, theirs: r?.theirs };
+            })
+          }));
+          break;
+        }
+        if (!paths.length) {
+          console.log("no unresolved conflicts");
+          break;
+        }
+        console.log(`${paths.length} path(s) with unresolved conflicts:`);
+        for (const p of paths) {
+          const hunks2 = conflictHunks(p);
+          console.log(`  ! ${p}  (${hunks2.length} hunk${hunks2.length === 1 ? "" : "s"})`);
+          for (const h of hunks2)
+            console.log(`      lines ${h.startLine}-${h.endLine}: ${h.ours.length} ours / ${h.theirs.length} theirs`);
+        }
+        console.log("resolve the markers, then `sol commit` (or `sol conflicts --json` for the full hunks)");
+        break;
+      }
+      case "ls": {
+        const wantJson = args.includes("--json");
+        const { repo } = open();
+        const head = await repo.head();
+        const store2 = loadStore();
+        const { revealView: revealView2, slotIdFromKey: slotIdFromKey2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+        const { listAll: listAll3 } = await Promise.resolve().then(() => (init_tree(), exports_tree));
+        const { loadSelfIdentity: loadSelfIdentity2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+        const { openContent: openContent2, UNREADABLE: UNREADABLE2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+        const ring = existsSync18(solDir) ? loadKeyRing() : new (await Promise.resolve().then(() => (init_crypto(), exports_crypto))).KeyRing;
+        const self = loadSelfIdentity2();
+        const decrypt = (boxStr) => {
+          try {
+            const opened = openContent2(ring, JSON.parse(boxStr), actor, self);
+            return opened === UNREADABLE2 ? undefined : opened;
+          } catch {
+            return;
+          }
+        };
+        const { HIDDEN_KEY: HIDDEN_KEY2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+        const view = head ? revealView2(store2, head, decrypt) : head;
+        const rows = (head ? listAll3(store2, view) : []).map((p) => {
+          const seg = p.split("/").pop() ?? p;
+          if (seg === HIDDEN_KEY2)
+            return { path: p, hidden: "existence", slotId: null };
+          const slotId = slotIdFromKey2(seg);
+          if (slotId !== undefined)
+            return { path: p, hidden: "name", slotId };
+          return { path: p, hidden: null, slotId: null };
+        });
+        if (wantJson) {
+          console.log(JSON.stringify({ count: rows.length, files: rows }));
+          break;
+        }
+        for (const r of rows) {
+          if (r.hidden === "existence")
+            console.log(`\uD83D\uDD12 ${r.path.split("/").slice(0, -1).join("/") || "."}/  [hidden children — names & existence sealed]`);
+          else if (r.hidden === "name")
+            console.log(`\uD83D\uDD12 ${r.path.split("/").slice(0, -1).concat(`[locked] ${r.slotId} (name hidden)`).join("/")}`);
+          else
+            console.log(r.path);
+        }
+        break;
+      }
+      case "cat": {
+        const wantJson = args.includes("--json");
+        const path = args.filter((a) => !a.startsWith("-"))[0] || die("cat needs a path");
+        const repo = open().repo;
+        let c = await repo.readFile(path);
+        if (c === undefined) {
+          const head = await repo.head();
+          if (head) {
+            const store2 = loadStore();
+            const { revealView: revealView2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+            const { readFile: readTree, entryKindAt: kindAt } = await Promise.resolve().then(() => (init_tree(), exports_tree));
+            const { loadSelfIdentity: loadSelfIdentity2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+            const { openContent: openContent2, UNREADABLE: UNREADABLE2, KeyRing: KeyRing3 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+            const ring = existsSync18(solDir) ? loadKeyRing() : new KeyRing3;
+            const self = loadSelfIdentity2();
+            const decrypt = (boxStr) => {
+              try {
+                const opened = openContent2(ring, JSON.parse(boxStr), actor, self);
+                return opened === UNREADABLE2 ? undefined : opened;
+              } catch {
+                return;
+              }
+            };
+            const view = revealView2(store2, head, decrypt);
+            if (view !== head) {
+              const revealed = readTree(store2, view, path);
+              if (revealed !== undefined)
+                c = revealed;
+              else if (kindAt(store2, view, path) === "sealed")
+                die(`name+content hidden: pull/checkout to materialize "${path}" as a recipient (cat can't address a sealed slot)`);
+            }
+          }
+        }
+        if (c === undefined)
+          die("no such tracked path: " + path);
+        if (c === SEALED) {
+          const [{ SealedClient: SealedClient2 }, { UNREADABLE: UNREADABLE2 }, { loadSelfIdentity: loadSelfIdentity2 }] = await Promise.all([Promise.resolve().then(() => (init_sealed_client(), exports_sealed_client)), Promise.resolve().then(() => (init_crypto(), exports_crypto)), Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience))]);
+          const self = loadSelfIdentity2();
+          const opened = await new SealedClient2(repo, loadKeyRing()).open(path, actor, self);
+          const readable = !(opened === undefined || opened === UNREADABLE2);
+          if (wantJson) {
+            console.log(JSON.stringify({ path, sealed: true, readable, actor, content: readable ? opened : null }));
+            break;
+          }
+          process.stdout.write(readable ? opened : `<<sealed — you are not a recipient>>
+`);
+          break;
+        }
+        if (wantJson) {
+          console.log(JSON.stringify({ path, sealed: false, readable: true, content: c }));
+          break;
+        }
+        process.stdout.write(c);
+        break;
+      }
+      case "log": {
+        const { log } = open();
+        const ops = await log.history();
+        if (args.includes("--all") || args.includes("--ops")) {
+          if (args.includes("--json")) {
+            const store3 = loadStore();
+            const trust2 = loadTrust();
+            console.log(JSON.stringify({
+              version: 1,
+              ops: ops.map((o) => ({
+                seq: o.seq,
+                id: o.entryHash ?? null,
+                type: o.type,
+                path: o.path,
+                by: o.by ?? null,
+                message: o.message ?? null,
+                root: o.rootAfter,
+                parents: [o.parent, o.parent2].filter((p) => !!p),
+                prevHash: o.prevHash ?? null,
+                at: o.at,
+                prov: provJson(o, store3, ATTEST_KEY2, trust2) ?? null
+              }))
+            }));
+            break;
+          }
+          if (!ops.length)
+            console.log("(no history yet)");
+          for (const line of formatLog(ops))
+            console.log(line.replace(/\bcheckpoint\b/, "commit"));
+          break;
+        }
+        const store2 = loadStore();
+        const trust = loadTrust();
+        const producersByRoot = new Map;
+        for (const o of ops)
+          if (o.type === "checkpoint") {
+            let list = producersByRoot.get(o.rootAfter);
+            if (!list)
+              producersByRoot.set(o.rootAfter, list = []);
+            list.push(o);
+          }
+        const latestAt = (root) => {
+          const list = root ? producersByRoot.get(root) : undefined;
+          return list ? list[list.length - 1] : undefined;
+        };
+        const parentAt = (root, before) => {
+          const list = root ? producersByRoot.get(root) : undefined;
+          if (!list)
+            return;
+          let best;
+          for (const p of list)
+            if (p.seq < before.seq && (!best || p.seq > best.seq))
+              best = p;
+          return best;
+        };
+        const live = await log.head() ?? "";
+        const refArg = args.find((a) => !a.startsWith("-"));
+        const lrefs = existsSync18(refsPath()) ? JSON.parse(readFileSync18(refsPath(), "utf8")) : null;
+        let tipRoot = live;
+        if (refArg) {
+          tipRoot = lrefs?.branches[refArg]?.head ?? refArg;
+        } else if (lrefs && !producersByRoot.has(tipRoot)) {
+          const stored = lrefs.branches[lrefs.current]?.head;
+          if (stored && producersByRoot.has(stored))
+            tipRoot = stored;
+        }
+        const chain = [];
+        const seen = new Set;
+        const stack = [latestAt(tipRoot)];
+        while (stack.length) {
+          const c = stack.pop();
+          if (!c || seen.has(c.seq))
+            continue;
+          seen.add(c.seq);
+          chain.push(c);
+          stack.push(parentAt(c.parent, c));
+          if (c.parent2)
+            stack.push(parentAt(c.parent2, c));
+        }
+        chain.sort((a, b) => b.seq - a.seq);
+        if (args.includes("--json")) {
+          console.log(JSON.stringify(chain.map((c) => ({
+            hash: c.rootAfter,
+            by: c.by ?? null,
+            message: c.message ?? "",
+            seq: c.seq,
+            parents: [c.parent, c.parent2].filter((p) => !!p),
+            prov: provJson(c, store2, ATTEST_KEY2, trust) ?? null
+          }))));
+          break;
+        }
+        if (!chain.length) {
+          console.log(ops.length ? '(no commits on this branch yet — run `sol commit "msg"`)' : "(no history yet)");
+        }
+        for (const c of chain) {
+          const n = countChanges(store2, c.parent ?? "", c.rootAfter);
+          const mergedIn = [c.parent2 && parentAt(c.parent2, c)?.by].filter(Boolean);
+          const tag = c.parent2 ? `  [merge ${c.parent2.slice(0, 8)}${mergedIn.length ? ` <- ${mergedIn.join(", ")}` : ""}]` : "";
+          console.log(`${c.rootAfter.slice(0, 14)}  ${authorLabel(c, store2).padEnd(14)}  ${c.message ?? ""}  (${n} change${n === 1 ? "" : "s"})${tag}  ${attTag(c, ATTEST_KEY2)}  ${signTag(c, trust)}`);
+        }
+        const wc = workingChanges(store2, live);
+        const dirty = wc.added.length + wc.modified.length + wc.removed.length;
+        if (dirty)
+          console.log(`(working: ${dirty} uncommitted change(s))`);
+        break;
+      }
+      case "rm": {
+        const path = args[0] || die("rm needs a path");
+        let onDisk = false;
+        try {
+          unlinkSync8(join19(cwd, path));
+          onDisk = true;
+        } catch {}
+        if (onDisk) {
+          console.log(`removed ${path} from disk (commit to record the deletion)`);
+          break;
+        }
+        const { repo } = open();
+        if (!(await repo.list()).includes(path))
+          die("not tracked and not on disk: " + path);
+        await repo.deleteFile(path);
+        console.log("removed (tracked-only) " + path);
+        break;
+      }
+      case "diff": {
+        const { log } = open();
+        const store2 = loadStore();
+        const head = await log.head() ?? "";
+        const wantJson = args.includes("--json");
+        const da = args.filter((a) => a !== "--json");
+        const emitJson = (base, only) => console.log(JSON.stringify(workingChangeRows(store2, base, only)));
+        if (da.length >= 2) {
+          const aR = revealedHeadForRender(store2, (await resolveRef(log, da[0])).head);
+          const bR = revealedHeadForRender(store2, (await resolveRef(log, da[1])).head);
+          const td = diffTrees(store2, aR, bR);
+          wantJson ? console.log(JSON.stringify(td)) : printTreeDiff(td);
+        } else if (da.length === 1) {
+          const resolved = await resolveRefSoft(log, da[0]);
+          if (resolved) {
+            wantJson ? emitJson(resolved.head) : printWorkingDiff(store2, resolved.head);
+          } else {
+            const path = isWorkingPath(store2, head, da[0]);
+            if (path)
+              wantJson ? emitJson(head, path) : printWorkingDiff(store2, head, path);
+            else
+              die(`'${da[0]}' is neither a ref nor a working-tree path.
+  usage: sol diff            (working tree vs HEAD)
+         sol diff <ref>      (working tree vs a branch/commit)
+         sol diff <ref> <ref> (tree vs tree)
+         sol diff <path>     (one file, working tree vs HEAD)`);
+          }
+        } else {
+          wantJson ? emitJson(head) : printWorkingDiff(store2, head);
+        }
+        break;
+      }
+      case "restore":
+      case "checkout": {
+        const { log } = open();
+        const store2 = loadStore();
+        let from = "head";
+        const rest = [];
+        for (let i = 0;i < args.length; i++) {
+          if (args[i] === "--from")
+            from = args[++i];
+          else if (args[i] !== "--all")
+            rest.push(args[i]);
+        }
+        const { head } = await resolveRef(log, from);
+        if (rest.length === 0) {
+          const n = materializeTree(store2, head);
+          console.log(`restored the working tree to ${from === "head" ? "HEAD" : from} (${n} change(s))`);
+        } else {
+          let n = 0;
+          for (const p of rest) {
+            if (materialize(store2, head, p))
+              n++;
+            else
+              console.error(`not in ${from}: ${p}`);
+          }
+          console.log(`restored ${n} file(s) from ${from === "head" ? "HEAD" : from}`);
+        }
+        break;
+      }
+      case "show": {
+        const { log } = open();
+        const store2 = loadStore();
+        const trust = loadTrust();
+        const ops = await log.history();
+        const refArg = args.find((a) => !a.startsWith("-"));
+        const resolved = await resolveRef(log, refArg);
+        let op = resolved.op;
+        if (op && op.type !== "checkpoint") {
+          const sealing = ops.find((o) => o.type === "checkpoint" && o.rootAfter === op.rootAfter);
+          if (sealing)
+            op = sealing;
+        }
+        if (!op)
+          die("nothing to show (empty repo)");
+        const idx = ops.findIndex((o) => o.seq === op.seq);
+        let prev = emptyRoot(store2);
+        if (op.parent !== undefined) {
+          prev = op.parent;
+        } else if (op.type === "checkpoint") {
+          for (let i = idx - 1;i >= 0; i--)
+            if (ops[i].type === "checkpoint") {
+              prev = ops[i].rootAfter;
+              break;
+            }
+        } else if (idx > 0) {
+          prev = ops[idx - 1].rootAfter;
+        }
+        const kind = op.type === "checkpoint" ? "commit" : op.type;
+        const prevR = revealedHeadForRender(store2, prev);
+        const afterR = revealedHeadForRender(store2, op.rootAfter);
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({ hash: op.rootAfter, seq: op.seq, by: op.by ?? null, message: op.message ?? "", prov: provJson(op, store2, ATTEST_KEY2, trust) ?? null, diff: diffTrees(store2, prevR, afterR) }));
+          break;
+        }
+        const pnode = provOf(op, store2);
+        console.log(`${kind} ${op.rootAfter.slice(0, 14)}   seq ${op.seq}   by ${authorLabel(op, store2)}  ${attTag(op, ATTEST_KEY2)}  ${signTag(op, trust)}${op.message ? `
+
+    ` + op.message : ""}${pnode?.rationale ? `
+
+    rationale: ` + pnode.rationale : ""}
+`);
+        printTreeDiff(diffTrees(store2, prevR, afterR));
+        break;
+      }
+      case "blame": {
+        const path = args.find((a) => !a.startsWith("-")) || die("blame needs a path");
+        const store2 = loadStore();
+        const trust = loadTrust();
+        const repo = open().repo;
+        const ops = await repo.history();
+        const head = await repo.head() ?? "";
+        const { entryKindAt: kindAt } = await Promise.resolve().then(() => (init_tree(), exports_tree));
+        const readAt = (root, p) => {
+          const revealed = revealedHeadForRender(store2, root);
+          const c = readFile(store2, revealed, p);
+          return c === undefined || c === SEALED ? undefined : c;
+        };
+        const lines2 = blameFile(ops, store2, path, readAt);
+        if (!lines2.length) {
+          const revealedHead2 = revealedHeadForRender(store2, head);
+          const hostKind = head ? kindAt(store2, head, path) : undefined;
+          const revealedKind = revealedHead2 ? kindAt(store2, revealedHead2, path) : undefined;
+          if (hostKind === "sealed" && revealedKind !== "blob") {
+            if (args.includes("--json")) {
+              console.log(JSON.stringify({ path, sealed: true, lines: [] }));
+              break;
+            }
+            console.log(`${path}: sealed — content hidden (no per-line blame; you are not a recipient). structural history is visible via \`sol log\`.`);
+            break;
+          }
+          die("no history for " + path);
+        }
+        const bySeq = new Map(ops.map((o) => [o.seq, o]));
+        if (args.includes("--json")) {
+          console.log(JSON.stringify(lines2.map((t, i) => {
+            const op = bySeq.get(t.seq);
+            return { line: i + 1, content: t.line, seq: t.seq, by: t.by ?? null, kind: op?.kind ?? null, prov: op ? provJson(op, store2, ATTEST_KEY2, trust) ?? null : null };
+          })));
+          break;
+        }
+        for (const t of lines2) {
+          const op = bySeq.get(t.seq);
+          const who = op ? authorLabel(op, store2) : t.by ?? "?";
+          const tag = op ? attTag(op, ATTEST_KEY2) : "[unattested/local]";
+          const sigtag = op ? signTag(op, trust) : "unsigned";
+          console.log(`${String(t.seq).padStart(4)} ${who.padEnd(16)} ${tag.padEnd(24)} ${sigtag.padEnd(26)} ${t.line}`);
+        }
+        break;
+      }
+      case "fsck": {
+        const { log } = open();
+        const store2 = loadStore();
+        const head = await log.head();
+        const ops = await log.history();
+        let chainOk = true;
+        let chainErr = "";
+        try {
+          for (let i = 0;i < ops.length; i++)
+            if (ops[i].seq !== i + 1)
+              throw new Error("gap before seq " + (i + 1));
+          verifyChain(ops);
+        } catch (e) {
+          chainOk = false;
+          chainErr = String(e?.message ?? e);
+        }
+        const missing = [];
+        if (head) {
+          const seen = new Set;
+          const walk = (h) => {
+            if (seen.has(h))
+              return;
+            seen.add(h);
+            const node = store2.get(h);
+            if (!node) {
+              missing.push(h);
+              return;
+            }
+            if (node.kind === "tree")
+              for (const e of Object.values(node.entries))
+                walk(e.hash);
+          };
+          walk(head);
+        }
+        const ok = chainOk && missing.length === 0;
+        console.log(`fsck: ${ok ? "OK" : "PROBLEMS FOUND"}`);
+        console.log(`  op-log: ${ops.length} op(s), chain ${chainOk ? "valid + contiguous" : "BROKEN — " + chainErr}`);
+        console.log(`  head:   ${head ? head.slice(0, 16) : "(empty)"}, ${missing.length} missing object(s)`);
+        for (const mh of missing)
+          console.log("    missing " + mh);
+        process.exitCode = ok ? 0 : 1;
+        break;
+      }
+      case "gc": {
+        const { log } = open();
+        const store2 = loadStore();
+        const ops = await log.history();
+        const reachable = new Set;
+        const walk = (h) => {
+          if (reachable.has(h))
+            return;
+          const node = store2.get(h);
+          if (!node)
+            return;
+          reachable.add(h);
+          if (node.kind === "tree")
+            for (const e of Object.values(node.entries))
+              walk(e.hash);
+        };
+        for (const op of ops) {
+          walk(op.rootAfter);
+          if (op.prov)
+            walk(op.prov);
+        }
+        const objDir = join19(solDir, "objects");
+        let removed = 0;
+        for (const name of readdirSync9(objDir)) {
+          if (name.endsWith(".tmp") || !reachable.has(name)) {
+            unlinkSync8(join19(objDir, name));
+            removed++;
+          }
+        }
+        console.log(`gc: kept ${reachable.size} object(s), removed ${removed} unreachable`);
+        if (existsSync18(join19(solDir, "env", "seal"))) {
+          const { gcStaleStanzas: gcStaleStanzas2 } = await Promise.resolve().then(() => (init_secret(), exports_secret));
+          const st = gcStaleStanzas2(solDir);
+          if (st.removed)
+            console.log(`gc: removed ${st.removed} orphaned sealed stanza(s) (${st.bytes} bytes) — stale post-reseal epochs, value-safe`);
+        }
+        break;
+      }
+      case "ignore": {
+        const pat = args.join(" ").trim();
+        if (!pat) {
+          for (const p of ignorePatterns())
+            console.log(p);
+          break;
+        }
+        const f = join19(cwd, ".solignore");
+        const lead = existsSync18(f) && !readFileSync18(f, "utf8").endsWith(`
+`) ? `
+` : "";
+        appendFileSync2(f, lead + pat + `
+`);
+        console.log("ignoring: " + pat);
+        break;
+      }
+      case "hide": {
+        const { repo } = open();
+        const wantJson = args.includes("--json");
+        const cfg = resolveRemote2(solDir) || die("no remote — `sol push <repo>` (or `sol remote <url> <repo>`) first; the policy lives on the repo");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const sub = args[0];
+        const flag2 = (name) => {
+          const i = args.indexOf(name);
+          return i >= 0 ? args[i + 1] : undefined;
+        };
+        const has2 = (name) => args.includes(name);
+        if (sub === "list") {
+          const policy = await policyGet(cfg, token);
+          const paths = await repo.list();
+          const describe2 = (a) => a.kind === "role" ? `role>=${a.min}` : a.kind === "team" ? `team:${a.teamId}` : a.kind === "users" ? `users:${a.userIds.join(",")}` : "owner";
+          const rows = policy.rules.map((r) => ({ ...r, covers: paths.filter((p) => globCovers2(r.pattern, p)) }));
+          if (wantJson) {
+            console.log(JSON.stringify({ count: rows.length, rules: rows }));
+            break;
+          }
+          if (!rows.length) {
+            console.log('no visibility-policy rules yet — `sol hide "<pattern>" --role write` to add one.');
+            break;
+          }
+          for (const r of rows) {
+            console.log(`${r.pattern}  -> ${describe2(r.audience)}${r.recovery?.length ? `  +escrow(${r.recovery.join(",")})` : ""}${r.noList ? "  [no-list: full opacity]" : ""}${r.hideExistence ? "  [hide-existence: L3 path absent]" : r.hideNames ? "  [hide-names: L2 filename sealed]" : ""}`);
+            if (r.covers.length)
+              for (const p of r.covers)
+                console.log(`    ${p}`);
+            else
+              console.log("    (no current paths match)");
+          }
+          break;
+        }
+        if (sub === "remove") {
+          const pattern2 = args[1] || die("usage: sol hide remove <pattern>");
+          const { removed } = await policyRemove(cfg, token, pattern2);
+          if (wantJson) {
+            console.log(JSON.stringify({ pattern: pattern2, removed }));
+            break;
+          }
+          if (!removed)
+            die(`no policy rule for pattern "${pattern2}"`);
+          console.log(`removed policy rule "${pattern2}".`);
+          console.log("  NOTE: this does NOT auto-unseal existing content — already-sealed paths keep their lockboxes.");
+          console.log("  to recall, re-seal them: `sol seal --reapply` (re-wraps to the now-current audience, bumps epoch).");
+          break;
+        }
+        const pattern = args.filter((a) => !a.startsWith("-"))[0] || die("usage: sol hide <pattern> [--role write|admin] [--team <id>] [--users a,b] [--escrow]");
+        let audience2;
+        const usersArg = flag2("--users");
+        const teamArg = flag2("--team");
+        const roleArg = flag2("--role");
+        if (usersArg)
+          audience2 = { kind: "users", userIds: usersArg.split(",").map((s) => s.trim()).filter(Boolean) };
+        else if (teamArg)
+          audience2 = { kind: "team", teamId: teamArg };
+        else if (has2("--owner"))
+          audience2 = { kind: "owner" };
+        else {
+          const min = roleArg ?? "write";
+          if (min !== "read" && min !== "write" && min !== "admin")
+            die(`invalid --role '${min}' — use write or admin`);
+          audience2 = { kind: "role", min };
+        }
+        const noList = has2("--no-list");
+        const hideExistence2 = has2("--hide-existence");
+        const hideNames = has2("--hide-names") || hideExistence2;
+        const rule = { pattern, audience: audience2, ...has2("--escrow") ? { recovery: ["org-escrow"] } : {}, ...noList ? { noList: true } : {}, ...hideNames ? { hideNames: true } : {}, ...hideExistence2 ? { hideExistence: true } : {} };
+        const res = await policyUpsert(cfg, token, rule);
+        if (res.error)
+          die(`policy update rejected: ${res.error}`);
+        const describe = (a) => a.kind === "role" ? `role>=${a.min}` : a.kind === "team" ? `team:${a.teamId}` : a.kind === "users" ? `users:${a.userIds.join(",")}` : "owner";
+        if (wantJson) {
+          console.log(JSON.stringify({ pattern, audience: audience2, recovery: rule.recovery ?? [], noList, hideNames, hideExistence: hideExistence2, rules: res.policy.rules.length }));
+          break;
+        }
+        const covered = (await repo.list()).filter((p) => globCovers2(pattern, p));
+        const flags = `${noList ? " [--no-list: full opacity — non-audience members can't list/fetch these paths]" : ""}${hideExistence2 ? " [--hide-existence: L3 — the PATH is ABSENT from host+collaborators; only a per-dir \\0hidden marker remains]" : hideNames ? " [--hide-names: L2 — the FILENAME is sealed too; non-recipients see only an opaque slot]" : ""}`;
+        console.log(`hid "${pattern}" -> ${describe(audience2)}${flags} — a VisibilityPolicy rule (host-visible metadata; the host learns the audience, never a key).`);
+        if (covered.length) {
+          console.log(`  ${covered.length} current path(s) match: ${covered.slice(0, 8).join(", ")}${covered.length > 8 ? ", …" : ""}`);
+          console.log("  seal them to this audience now: `sol seal <path>` (no recipients consults the policy).");
+        } else {
+          console.log("  no current paths match — new files under this pattern seal to the audience on `sol seal <path>`.");
+        }
+        break;
+      }
+      case "seal": {
+        const { repo, log } = open();
+        const wantJson = args.includes("--json");
+        const reapply = args.includes("--reapply");
+        const positional = args.filter((a) => !a.startsWith("-"));
+        if (args.includes("--scrub-history")) {
+          const { pendingScrubPaths: pendingScrubPaths2, historyHasCleartext: historyHasCleartext2, scrubHistory: scrubHistory2, clearPendingScrub: clearPendingScrub2, gcAfterScrub: gcAfterScrub2 } = await Promise.resolve().then(() => (init_secret_scrub(), exports_secret_scrub));
+          const ops = await log.history();
+          const only = positional[0];
+          const targets = (only ? [only] : pendingScrubPaths2(solDir)).filter((p) => historyHasCleartext2(solDir, ops, p));
+          if (!targets.length) {
+            if (only)
+              die(`no pre-seal cleartext in history for "${only}" — nothing to scrub (it was never committed in the clear, or is already scrubbed).`);
+            clearPendingScrub2(solDir);
+            console.log(wantJson ? JSON.stringify({ scrubbed: [], rewrittenOps: 0 }) : "no paths with recoverable pre-seal cleartext — nothing to scrub.");
+            break;
+          }
+          let removed = 0;
+          {
+            const res = await scrubHistory2(solDir, ops, targets);
+            writeFileSync16(join19(solDir, "ops.jsonl"), res.ops.map((o) => JSON.stringify(o)).join(`
+`) + (res.ops.length ? `
+` : ""));
+            writeFileSync16(join19(solDir, "HEAD"), JSON.stringify({ head: res.newHead, seq: res.newSeq, logTip: res.newLogTip }));
+            if (existsSync18(refsPath())) {
+              const refs = JSON.parse(readFileSync18(refsPath(), "utf8"));
+              for (const b of Object.values(refs.branches)) {
+                if (b.head && res.rootMap.has(b.head))
+                  b.head = res.rootMap.get(b.head);
+                if (b.base && res.rootMap.has(b.base))
+                  b.base = res.rootMap.get(b.base);
+                if (b.remote && res.rootMap.has(b.remote))
+                  b.remote = res.rootMap.get(b.remote);
+              }
+              saveRefs(refs);
+            }
+            removed = gcAfterScrub2(solDir, res.ops);
+            clearPendingScrub2(solDir);
+          }
+          if (wantJson) {
+            console.log(JSON.stringify({ scrubbed: targets, removedObjects: removed }));
+            break;
+          }
+          console.log(`scrubbed pre-seal cleartext from history for: ${targets.join(", ")} — the op-log was rewritten and ${removed} orphaned cleartext object(s) dropped (\`sol restore\` can no longer recover them); push is unblocked.`);
+          console.log("  NOTE: this is a DESTRUCTIVE local history rewrite. collaborators who already pulled the old history must re-clone.");
+          break;
+        }
+        if (reapply) {
+          const cfg = resolveRemote2(solDir) || die("no remote — the policy lives on the repo; `sol remote <url> <repo>` first");
+          const token = process.env.SOL_TOKEN || authExpired2();
+          const { SealedClient: SealedClient3 } = await Promise.resolve().then(() => (init_sealed_client(), exports_sealed_client));
+          const { UNREADABLE: UNREADABLE2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+          const { loadSelfIdentity: loadSelfIdentity2, recordAudience: recordAudience3 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          const ring2 = loadKeyRing();
+          const self = loadSelfIdentity2();
+          const client2 = new SealedClient3(repo, ring2);
+          const only = positional[0];
+          const targets = [];
+          for (const p of await repo.list()) {
+            if (only && p !== only)
+              continue;
+            const leaf = await repo.read(p);
+            if (leaf?.kind === "sealed")
+              targets.push(p);
+          }
+          if (only && !targets.length)
+            die(`not a sealed path: ${only}`);
+          let rewrapped = 0;
+          const skipped = [];
+          for (const path2 of targets) {
+            const resolved = await recipientsForPath(cfg, token, path2);
+            if (!resolved.covered) {
+              skipped.push({ path: path2, reason: "no policy rule covers it (explicit/ad-hoc seal — leave as-is)" });
+              continue;
+            }
+            const opened = await client2.open(path2, actor, self);
+            if (opened === undefined || opened === UNREADABLE2) {
+              skipped.push({ path: path2, reason: "you are not a current recipient — a recipient must run --reapply" });
+              continue;
+            }
+            const leaf = await repo.read(path2);
+            const oldEpoch = leaf?.kind === "sealed" ? JSON.parse(leaf.box).epoch ?? 1 : 1;
+            const recipientPubKeys2 = {};
+            const audienceAccounts2 = [];
+            const { pubFingerprint: pubFingerprint2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+            for (const r of resolved.recipients) {
+              recipientPubKeys2[r.accountId] = r.x25519Pub;
+              audienceAccounts2.push({ accountId: r.accountId, fingerprint: pubFingerprint2(r.x25519Pub), keyEpoch: r.keyEpoch });
+            }
+            await client2.sealToAccounts(path2, opened, recipientPubKeys2, { localRecipients: [actor], epoch: oldEpoch + 1 });
+            recordAudience3(solDir, { path: path2, epoch: oldEpoch + 1, at: Date.now(), accounts: audienceAccounts2, local: [actor] });
+            rewrapped++;
+            if (resolved.unresolved.length && !wantJson)
+              console.error(`note: ${path2}: ${resolved.unresolved.length} audience account(s) have no published key yet — not wrapped: ${resolved.unresolved.join(", ")}`);
+          }
+          saveKeyRing(ring2);
+          if (wantJson) {
+            console.log(JSON.stringify({ reapplied: rewrapped, skipped }));
+            break;
+          }
+          console.log(`reapplied policy to ${rewrapped} sealed path(s) — re-wrapped to the CURRENT audience, epoch bumped.`);
+          for (const s of skipped)
+            console.log(`  skipped ${s.path}: ${s.reason}`);
+          console.log(`
+  NO-RECALL: a newly-added writer cannot read PAST sealed content until a reapply re-wraps the CEK to`);
+          console.log("  them; a removed recipient is not retroactively recalled (they may already hold old plaintext). for a");
+          console.log("  LIVE secret (an API key), rotate it AT THE SOURCE — re-sealing only protects content written from now.");
+          break;
+        }
+        if (args.includes("--seal-subtree")) {
+          const dir = positional[0] || die("usage: sol seal <dir> --seal-subtree [recipient...]");
+          const ring2 = loadKeyRing();
+          const { SealedClient: SealedClient3 } = await Promise.resolve().then(() => (init_sealed_client(), exports_sealed_client));
+          const { parseRecipient: parseRecipient3, resolveRecipient: resolveRecipient3, recordAudience: recordAudience3 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          const { pubFingerprint: pubFingerprint2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+          const dirUrl2 = (process.env.SOL_REMOTE || DEFAULT_REMOTE_URL2).replace(/\/+$/, "");
+          const explicit = positional.slice(1);
+          const recipientPubKeys2 = {};
+          const audienceAccounts2 = [];
+          const localRecipients2 = new Set([actor]);
+          const crossAccount2 = [];
+          let policyApplied2 = false;
+          if (!explicit.length) {
+            const cfg = resolveRemote2(solDir);
+            const token = process.env.SOL_TOKEN;
+            if (cfg && token) {
+              const resolved = await recipientsForPath(cfg, token, dir).catch(() => {
+                return;
+              });
+              if (resolved?.covered) {
+                policyApplied2 = true;
+                for (const r of resolved.recipients) {
+                  recipientPubKeys2[r.accountId] = r.x25519Pub;
+                  audienceAccounts2.push({ accountId: r.accountId, fingerprint: pubFingerprint2(r.x25519Pub), keyEpoch: r.keyEpoch });
+                  if (r.accountId !== actor)
+                    crossAccount2.push(r.accountId);
+                }
+              }
+            }
+          }
+          for (const raw of explicit) {
+            const spec = parseRecipient3(raw);
+            if (spec.accountId === actor) {
+              localRecipients2.add(actor);
+              continue;
+            }
+            const resolved = await resolveRecipient3(dirUrl2, spec);
+            if (!resolved) {
+              localRecipients2.add(spec.accountId);
+              continue;
+            }
+            if (!resolved.selfSigned)
+              die(`@${spec.accountId}: directory key has an INVALID self-signature — possible MITM, refusing to seal.`);
+            if (resolved.pinMismatch)
+              die(`@${spec.accountId}: directory fingerprint differs from your pinned key — possible MITM/rotation, refusing to seal.`);
+            recipientPubKeys2[spec.accountId] = resolved.entry.x25519Pub;
+            audienceAccounts2.push({ accountId: spec.accountId, fingerprint: resolved.fingerprint, keyEpoch: resolved.entry.keyEpoch });
+            crossAccount2.push(spec.accountId);
+          }
+          const client2 = new SealedClient3(repo, ring2);
+          const head = await client2.sealSubtree(dir, recipientPubKeys2, { localRecipients: [...localRecipients2] });
+          if (head === undefined)
+            die(`not a directory in the current head: ${dir} (seal a tracked directory; commit its files first)`);
+          saveKeyRing(ring2);
+          recordAudience3(solDir, { path: dir, epoch: 1, at: Date.now(), accounts: audienceAccounts2, local: [...localRecipients2] });
+          const recipients2 = [...crossAccount2.map((a) => `@${a}`), ...[...localRecipients2]];
+          if (wantJson) {
+            console.log(JSON.stringify({ path: dir, sealedSubtree: true, recipients: recipients2, audience: { accounts: audienceAccounts2, local: [...localRecipients2] } }));
+            break;
+          }
+          console.log(`sealed subtree ${dir} -> ${recipients2.join(", ")} — the directory's CONTENTS are now host-blind: the host sees the dir name + one opaque blob, never the child names/count.`);
+          if (policyApplied2)
+            console.log("  audience resolved from the VisibilityPolicy (`sol hide`) for this dir.");
+          if (crossAccount2.length)
+            console.log(`  cross-account: ${crossAccount2.map((a) => `@${a}`).join(", ")} — wrapped to their published X25519 keys; the host stays blind.`);
+          break;
+        }
+        const path = positional[0] || die("usage: sol seal <path> [recipient...]  |  sol seal --reapply [<path>]");
+        const rawRecipients = positional.slice(1);
+        let content = await repo.readFile(path);
+        if (content === SEALED && !args.includes("--hide-names"))
+          die("already sealed: " + path);
+        if (content === undefined) {
+          const abs = join19(cwd, path);
+          if (!existsSync18(abs))
+            die("no such file: " + path);
+          content = readFileSync18(abs, "utf8");
+        }
+        const ring = loadKeyRing();
+        const { SealedClient: SealedClient2 } = await Promise.resolve().then(() => (init_sealed_client(), exports_sealed_client));
+        const { parseRecipient: parseRecipient2, resolveRecipient: resolveRecipient2, recordAudience: recordAudience2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+        const dirUrl = (process.env.SOL_REMOTE || DEFAULT_REMOTE_URL2).replace(/\/+$/, "");
+        const recipientPubKeys = {};
+        const audienceAccounts = [];
+        const localRecipients = new Set([actor]);
+        const crossAccount = [];
+        const recoveryPubKeys = {};
+        const escrowSlots = [];
+        const escrowUnresolved = [];
+        const wantEscrow = args.includes("--escrow");
+        let policyApplied = false;
+        let hideNamesFromPolicy = false;
+        let hideExistenceFromPolicy = false;
+        if (!rawRecipients.length) {
+          const cfg = resolveRemote2(solDir);
+          const token = process.env.SOL_TOKEN;
+          if (cfg && token) {
+            const { pubFingerprint: pubFingerprint2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+            const resolved = await recipientsForPath(cfg, token, path).catch(() => {
+              return;
+            });
+            if (resolved?.covered) {
+              policyApplied = true;
+              hideNamesFromPolicy = resolved.hideNames === true;
+              hideExistenceFromPolicy = resolved.hideExistence === true;
+              for (const r of resolved.recipients) {
+                recipientPubKeys[r.accountId] = r.x25519Pub;
+                audienceAccounts.push({ accountId: r.accountId, fingerprint: pubFingerprint2(r.x25519Pub), keyEpoch: r.keyEpoch });
+                if (r.accountId !== actor)
+                  crossAccount.push(r.accountId);
+              }
+              if (resolved.unresolved.length && !wantJson)
+                console.error(`note: ${resolved.unresolved.length} audience account(s) have no published key yet — not wrapped: ${resolved.unresolved.join(", ")} (they cannot decrypt until they \`sol keys publish\`).`);
+              for (const [slot, pub] of Object.entries(resolved.recoveryKeys ?? {})) {
+                recoveryPubKeys[slot] = pub;
+                escrowSlots.push(slot);
+              }
+              for (const slot of resolved.unresolvedRecovery ?? [])
+                escrowUnresolved.push(slot);
+            }
+          }
+        }
+        if (wantEscrow && !escrowSlots.length) {
+          const cfg = resolveRemote2(solDir);
+          const token = process.env.SOL_TOKEN;
+          if (cfg && token) {
+            const { recipientsForAudience: recipientsForAudience2 } = await Promise.resolve().then(() => (init_remote(), exports_remote));
+            const r = await recipientsForAudience2(cfg, token, { kind: "owner" }, ["org-escrow"]).catch(() => {
+              return;
+            });
+            for (const [slot, pub] of Object.entries(r?.recoveryKeys ?? {})) {
+              recoveryPubKeys[slot] = pub;
+              escrowSlots.push(slot);
+            }
+            for (const slot of r?.unresolvedRecovery ?? [])
+              escrowUnresolved.push(slot);
+          }
+          if (!escrowSlots.length && !escrowUnresolved.length)
+            escrowUnresolved.push("org-escrow");
+        }
+        for (const raw of rawRecipients) {
+          const spec = parseRecipient2(raw);
+          if (spec.accountId === actor) {
+            localRecipients.add(actor);
+            continue;
+          }
+          const resolved = await resolveRecipient2(dirUrl, spec);
+          if (!resolved) {
+            localRecipients.add(spec.accountId);
+            continue;
+          }
+          if (!resolved.selfSigned) {
+            die(`@${spec.accountId}: directory key has an INVALID self-signature — possible MITM, refusing to seal. verify out-of-band: \`sol keys verify ${spec.accountId} <fpr>\``);
+          }
+          if (resolved.pinMismatch) {
+            die(`@${spec.accountId}: directory fingerprint ${resolved.fingerprint} DIFFERS from your pinned key — possible MITM/rotation, refusing to seal. re-verify: \`sol keys verify ${spec.accountId} <fpr>\``);
+          }
+          if (!resolved.pinned && !wantJson) {
+            console.error(`note: @${spec.accountId} pinned on first use (fingerprint ${resolved.fingerprint}). confirm it out-of-band with \`sol keys verify ${spec.accountId} <fpr>\`.`);
+          }
+          recipientPubKeys[spec.accountId] = resolved.entry.x25519Pub;
+          audienceAccounts.push({ accountId: spec.accountId, fingerprint: resolved.fingerprint, keyEpoch: resolved.entry.keyEpoch });
+          crossAccount.push(spec.accountId);
+        }
+        const bareSelfSeal = !rawRecipients.length && !policyApplied && !Object.keys(recipientPubKeys).length && !escrowSlots.length;
+        if (bareSelfSeal) {
+          const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_identity_store(), exports_identity_store));
+          const stored = loadIdentity2();
+          if (stored) {
+            const { pubFingerprint: pubFingerprint2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+            recipientPubKeys[stored.accountId] = stored.x25519Pub;
+            audienceAccounts.push({ accountId: stored.accountId, fingerprint: pubFingerprint2(stored.x25519Pub), keyEpoch: stored.keyEpoch });
+            localRecipients.add(actor);
+          } else if (!wantJson) {
+            console.error(`WARNING: no identity (~/.sol/identity.json) — sealing "${path}" with a LOCAL-ONLY symmetric key.`);
+            console.error(`  this box will NOT decrypt on another machine even with your recovery code (the key lives only in this repo's .sol keyring).`);
+            console.error(`  run \`sol keys init\` first for a PORTABLE self-seal (decryptable with your recovery code on any of your devices).`);
+          }
+        }
+        const client = new SealedClient2(repo, ring);
+        const wantHideName = args.includes("--hide-names") || hideNamesFromPolicy;
+        const wantHideExistence = args.includes("--hide-existence") || hideExistenceFromPolicy;
+        const onTree = await repo.readFile(path);
+        const alreadySealed = onTree === SEALED;
+        const { isHiddenPath: isHiddenPathFn } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+        const alreadyHidden = onTree === undefined && isHiddenPathFn(solDir, path);
+        const untrackedFresh = onTree === undefined && !alreadyHidden && (wantHideName || wantHideExistence);
+        let hiddenSlot;
+        if (wantHideExistence && (onTree !== undefined || untrackedFresh)) {
+          const strict = args.includes("--strict");
+          const priorOps = await log.history();
+          const burned = priorOps.some((o) => o.path === path || o.path.startsWith(path + "/"));
+          if (burned) {
+            if (strict)
+              die(`--strict: "${path}" already appears in op history — its name is burned and cannot be truly existence-hidden. hide a fresh path, or drop --strict to proceed (the old name stays recoverable from history).`);
+            if (!wantJson)
+              console.error(`WARNING: "${path}" already appears in op history — existence-hiding protects the name going forward, but the OLD name is still recoverable from prior ops. use \`--strict\` to refuse, or hide a fresh path for a true zero-day filename.`);
+          }
+          const { loadSelfIdentity: loadSelfIdentity2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          const { openContent: openContent2, UNREADABLE: UNREADABLE2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+          const self = loadSelfIdentity2();
+          const openPrior = (boxStr) => {
+            try {
+              const opened = openContent2(ring, JSON.parse(boxStr), actor, self);
+              return opened === UNREADABLE2 ? undefined : opened;
+            } catch {
+              return;
+            }
+          };
+          const exHead = await client.hideExistence(path, recipientPubKeys, { localRecipients: [...localRecipients], openPrior, contentSeal: untrackedFresh || !alreadySealed, ...untrackedFresh ? { absentContent: content } : {}, ...escrowSlots.length ? { recoveryPubKeys } : {} });
+          if (exHead === undefined)
+            die(`nothing to existence-hide at "${path}" — the path is not in the tree and no on-disk bytes were found. (a fresh hide needs the file on disk; an already-hidden path edits in your revealed working tree.)`);
+          saveKeyRing(ring);
+          const { recordHiddenPath: recordHiddenPath2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          recordHiddenPath2(solDir, path, "existence");
+          if (Object.keys(recipientPubKeys).length)
+            recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: audienceAccounts, local: [...localRecipients] });
+          else
+            recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: [], local: [...localRecipients] });
+          const recipients2 = [...crossAccount.map((a) => `@${a}`), ...[...localRecipients]];
+          const segs2 = path.split("/").filter(Boolean);
+          const dir2 = segs2.slice(0, -1).join("/") || ".";
+          if (wantJson) {
+            console.log(JSON.stringify({ path, sealed: true, recipients: recipients2, audience: { accounts: audienceAccounts, local: [...localRecipients] }, existenceHidden: true, hiddenDir: dir2 }));
+            break;
+          }
+          console.log(`existence-hidden ${path} (L3) — the host now sees only a per-dir \x00hidden marker in "${dir2}", never "${path.split("/").pop()}", its bytes, or that this path exists. recipients reveal it locally.`);
+          if (policyApplied)
+            console.log("  audience resolved from the VisibilityPolicy (`sol hide`) for this path.");
+          if (crossAccount.length)
+            console.log(`  cross-account: ${crossAccount.map((a) => `@${a}`).join(", ")} — wrapped to their published X25519 keys; the host stays blind.`);
+          break;
+        }
+        if (wantHideExistence && onTree === undefined) {
+          die(`"${path}" is already existence-hidden (absent from the host tree). edit it in your revealed working tree, then re-run \`sol seal ${path} --hide-existence\` to re-seal the new bytes under the same \x00hidden sidecar.`);
+        }
+        if (wantHideName && onTree === undefined) {
+          const { slotForPath: slotForPath2, recordNameSlot: recordNameSlot2, recordHiddenPath: recordHiddenPath2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          const existingSlot = slotForPath2(solDir, path);
+          if (existingSlot) {
+            const segs = path.split("/").filter(Boolean);
+            const realDir = segs.slice(0, -1).join("/");
+            const name = segs[segs.length - 1];
+            await client.reHideName(realDir, name, existingSlot, content, recipientPubKeys, { localRecipients: [...localRecipients], ...escrowSlots.length ? { recoveryPubKeys } : {} });
+            recordNameSlot2(solDir, path, existingSlot);
+            recordHiddenPath2(solDir, path, "name");
+            if (Object.keys(recipientPubKeys).length)
+              recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: audienceAccounts, local: [...localRecipients] });
+            else
+              recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: [], local: [...localRecipients] });
+            saveKeyRing(ring);
+            hiddenSlot = existingSlot;
+            const recipients2 = [...crossAccount.map((a) => `@${a}`), ...[...localRecipients]];
+            if (wantJson) {
+              console.log(JSON.stringify({ path, sealed: true, recipients: recipients2, audience: { accounts: audienceAccounts, local: [...localRecipients] }, nameHidden: true, slotId: hiddenSlot, modified: true }));
+              break;
+            }
+            console.log(`re-sealed ${path} (edit) under its stable slot \x00slot\x00${hiddenSlot} — converge sees a MODIFICATION, the name stays host-blind`);
+            break;
+          }
+        }
+        if (!(wantHideName && !alreadySealed)) {
+          if (Object.keys(recipientPubKeys).length) {
+            await client.sealToAccounts(path, content, recipientPubKeys, { localRecipients: [...localRecipients], ...escrowSlots.length ? { recoveryPubKeys } : {} });
+            recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: audienceAccounts, local: [...localRecipients] });
+          } else if (escrowSlots.length) {
+            await client.sealToAccounts(path, content, {}, { localRecipients: [...localRecipients], recoveryPubKeys });
+            recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: [], local: [...localRecipients] });
+          } else {
+            await client.seal(path, content, [...localRecipients]);
+            recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: [], local: [...localRecipients] });
+          }
+          saveKeyRing(ring);
+          if (onTree !== undefined && onTree !== SEALED) {
+            const { historyHasCleartext: historyHasCleartext2, addPendingScrub: addPendingScrub2 } = await Promise.resolve().then(() => (init_secret_scrub(), exports_secret_scrub));
+            if (historyHasCleartext2(solDir, await log.history(), path)) {
+              addPendingScrub2(solDir, path);
+              if (!wantJson) {
+                console.error(`
+WARNING: "${path}" was committed as PLAINTEXT before this seal — the pre-seal cleartext is STILL recoverable from history (\`sol restore\`) and would ship to every clone on push.`);
+                console.error(`  push is now BLOCKED for safety. run \`sol seal ${path} --scrub-history\` to rewrite it out of history, then push.
+`);
+              }
+            }
+          }
+        }
+        if (wantHideName) {
+          const { slotForPath: slotForPath2, recordNameSlot: recordNameSlot2, recordHiddenPath: recordHiddenPath2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+          const nameHidePubKeys = { ...recipientPubKeys };
+          const existing = slotForPath2(solDir, path);
+          hiddenSlot = await client.hideName(path, nameHidePubKeys, { localRecipients: [...localRecipients], slotId: existing, contentSeal: untrackedFresh || !alreadySealed, ...untrackedFresh ? { absentContent: content } : {}, ...escrowSlots.length ? { recoveryPubKeys } : {} });
+          if (hiddenSlot) {
+            recordNameSlot2(solDir, path, hiddenSlot);
+            recordHiddenPath2(solDir, path, "name");
+            if (Object.keys(recipientPubKeys).length)
+              recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: audienceAccounts, local: [...localRecipients] });
+            else
+              recordAudience2(solDir, { path, epoch: 1, at: Date.now(), accounts: [], local: [...localRecipients] });
+          } else {
+            die(`nothing to name-hide at "${path}" — the path is not in the tree and no on-disk bytes were found. (a fresh hide needs the file on disk.)`);
+          }
+          saveKeyRing(ring);
+        }
+        const recipients = [...crossAccount.map((a) => `@${a}`), ...[...localRecipients]];
+        if (wantJson) {
+          console.log(JSON.stringify({ path, sealed: true, recipients, audience: { accounts: audienceAccounts, local: [...localRecipients] }, ...hiddenSlot ? { nameHidden: true, slotId: hiddenSlot } : {}, ...escrowSlots.length ? { escrow: escrowSlots } : {}, ...escrowUnresolved.length ? { escrowUnresolved } : {} }));
+          break;
+        }
+        console.log(`sealed ${path} to ${recipients.join(", ")} — content is now host-blind ciphertext (the keystore stays local)`);
+        if (bareSelfSeal && audienceAccounts.length)
+          console.log(`  PORTABLE self-seal: also wrapped to your own identity (@${audienceAccounts[0].accountId}) — it decrypts with your recovery code on any of your machines.`);
+        if (hiddenSlot)
+          console.log(`  name hidden (L2): the host now sees an opaque slot \x00slot\x00${hiddenSlot}, never "${path.split("/").pop()}" — recipients rebuild the real name locally.`);
+        if (policyApplied)
+          console.log("  audience resolved from the VisibilityPolicy (`sol hide`) for this path — server named the accounts, the client minted the lockboxes.");
+        if (crossAccount.length)
+          console.log(`  cross-account: ${crossAccount.map((a) => `@${a}`).join(", ")} — wrapped to their published X25519 keys; the host stays blind.`);
+        if (escrowSlots.length) {
+          console.log(`  ⚠ ESCROW ON: the CEK is ALSO wrapped to the org-escrow recovery slot [${escrowSlots.join(", ")}] — an org admin holding the escrow PRIVATE key CAN recover this content. it is NOT hidden from them.`);
+          console.log("    (the host still never holds the escrow private key — recovery is the admin's, off-host.)");
+        }
+        if (escrowUnresolved.length)
+          console.log(`  ⚠ ESCROW REQUESTED BUT UNRESOLVED: no published key for [${escrowUnresolved.join(", ")}] — the content is NOT escrow-recoverable. publish the org-escrow key, then \`sol seal --reapply\`.`);
+        break;
+      }
+      case "sealed": {
+        const { repo } = open();
+        const wantJson = args.includes("--json");
+        if (args.includes("--check")) {
+          const cfg = resolveRemote2(solDir) || die("no remote — drift is checked against the policy on the repo; `sol remote <url> <repo>` first");
+          const token = process.env.SOL_TOKEN || authExpired2();
+          const { policyCheck: policyCheck2 } = await Promise.resolve().then(() => (init_remote(), exports_remote));
+          const states = [];
+          for (const path of await repo.list()) {
+            const leaf = await repo.read(path);
+            if (!leaf || leaf.kind !== "sealed")
+              continue;
+            const box = JSON.parse(leaf.box);
+            states.push({ path, recipients: Object.keys(box.asym ?? {}), recovery: Object.keys(box.recovery ?? {}) });
+          }
+          if (!states.length) {
+            if (wantJson) {
+              console.log(JSON.stringify({ count: 0, drifted: 0, reports: [] }));
+              break;
+            }
+            console.log("no sealed paths in this repo.");
+            break;
+          }
+          const res = await policyCheck2(cfg, token, states);
+          if (wantJson) {
+            console.log(JSON.stringify(res));
+            break;
+          }
+          const describe = (a) => !a ? "(no rule)" : a.kind === "role" ? `role>=${a.min}` : a.kind === "team" ? `team:${a.teamId}` : a.kind === "users" ? `users:${a.userIds.join(",")}` : "owner";
+          const drifted = res.reports.filter((r) => r.covered && !r.inPolicy);
+          const inPolicy = res.reports.filter((r) => r.covered && r.inPolicy);
+          const adhoc = res.reports.filter((r) => !r.covered);
+          if (!drifted.length)
+            console.log(`all ${inPolicy.length} policy-covered sealed path(s) are IN POLICY — recipient sets match the audience.`);
+          for (const r of drifted) {
+            console.log(`DRIFT  ${r.path}  -> ${describe(r.audience)}  (recipients out of policy)`);
+            if (r.missing.length)
+              console.log(`  missing (audience says recipient, box does NOT wrap to): ${r.missing.map((a) => `@${a}`).join(", ")}`);
+            if (r.extra.length)
+              console.log(`  extra   (box still wraps to, audience no longer includes): ${r.extra.map((a) => `@${a}`).join(", ")}`);
+            if (r.recoveryDrift)
+              console.log(`  escrow  (rule wants [${r.expectedRecovery.join(",") || "none"}], box has [${r.actualRecovery.join(",") || "none"}])`);
+          }
+          if (inPolicy.length && drifted.length)
+            console.log(`(${inPolicy.length} path(s) in policy)`);
+          if (adhoc.length)
+            console.log(`(${adhoc.length} ad-hoc/explicit seal(s) not governed by any rule — left as-is)`);
+          if (drifted.length) {
+            console.log(`
+  ${drifted.length} sealed path(s) are OUT OF POLICY. re-wrap them to the current audience:`);
+            console.log("    sol seal --reapply              # all policy-covered sealed paths");
+            console.log("    sol seal --reapply <path>       # one path");
+            console.log("  NO-RECALL: a removed recipient is not retroactively recalled (they may already hold old plaintext);");
+            console.log("  a newly-added reader cannot read PAST content until --reapply re-wraps the CEK to them.");
+          }
+          break;
+        }
+        const { loadAudiences: loadAudiences2, loadSelfIdentity: loadSelfIdentity2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+        const { openContent: openContent2, UNREADABLE: UNREADABLE2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+        const { parseStruct: parseStruct2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+        const audiences = loadAudiences2(solDir);
+        const ring = existsSync18(solDir) ? loadKeyRing() : new (await Promise.resolve().then(() => (init_crypto(), exports_crypto))).KeyRing;
+        const self = loadSelfIdentity2();
+        const levelOf = (boxStr) => {
+          try {
+            const opened = openContent2(ring, JSON.parse(boxStr), actor, self);
+            if (opened !== UNREADABLE2) {
+              const st = parseStruct2(opened);
+              if (st?.__solStruct === "subtree")
+                return { level: "subtree" };
+              if (st?.__solStruct === "name")
+                return { level: "name", realName: st.name };
+              if (st?.__solStruct === "entries")
+                return { level: "existence", hiddenNames: Object.keys(st.slots) };
+            }
+          } catch {}
+          return { level: "content" };
+        };
+        const { slotIdFromKey: slotIdFromKey2, HIDDEN_KEY: HIDDEN_KEY2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+        const sealedPaths = [];
+        for (const path of await repo.list()) {
+          const leaf = await repo.read(path);
+          if (!leaf || leaf.kind !== "sealed")
+            continue;
+          const box = JSON.parse(leaf.box);
+          const rec = audiences[path];
+          const asymAccounts = Object.keys(box.asym ?? {});
+          const accounts = asymAccounts.map((accountId) => {
+            const r = rec?.accounts.find((a) => a.accountId === accountId);
+            return { accountId, fingerprint: r?.fingerprint ?? "(unknown — sealed elsewhere)", keyEpoch: r?.keyEpoch ?? 0 };
+          });
+          const local = Object.keys(box.lockboxes ?? {});
+          const escrow = Object.keys(box.recovery ?? {});
+          const lv = levelOf(leaf.box);
+          const seg = path.split("/").pop() ?? path;
+          const slotId = slotIdFromKey2(seg);
+          const isHiddenSidecar = seg === HIDDEN_KEY2;
+          const dir = path.split("/").slice(0, -1).join("/") || ".";
+          const display = isHiddenSidecar ? lv.hiddenNames ? `${dir}/  (existence-hidden: ${lv.hiddenNames.map((k) => slotIdFromKey2(k) ? `[slot ${slotIdFromKey2(k)}]` : k).join(", ")})` : `${dir}/  [per-dir \x00hidden marker — ${">="}1 hidden child, names sealed]` : slotId !== undefined ? lv.realName ? `${path.split("/").slice(0, -1).concat(lv.realName).join("/")}  (slot ${slotId})` : `[locked] slot ${slotId} (name hidden)` : path;
+          sealedPaths.push({ path, display, level: lv.level, ...slotId !== undefined ? { slotId } : {}, ...lv.realName ? { realName: lv.realName } : {}, ...lv.hiddenNames ? { hiddenNames: lv.hiddenNames } : {}, epoch: box.epoch ?? 1, accounts, local, escrow });
+        }
+        if (wantJson) {
+          console.log(JSON.stringify({ count: sealedPaths.length, sealed: sealedPaths }));
+          break;
+        }
+        if (!sealedPaths.length) {
+          console.log("no sealed paths in this repo.");
+          break;
+        }
+        for (const s of sealedPaths) {
+          const kind = s.level === "existence" ? "existence " : s.level === "subtree" ? "sealed dir " : s.level === "name" ? "name-hidden" : "sealed file";
+          console.log(`[${kind}]  ${s.display}  (epoch ${s.epoch})`);
+          for (const a of s.accounts)
+            console.log(`  @${a.accountId}  ${a.fingerprint}${a.keyEpoch ? `  (key epoch ${a.keyEpoch})` : ""}`);
+          if (s.local.length)
+            console.log(`  local: ${s.local.join(", ")}`);
+          if (s.escrow.length)
+            console.log(`  ⚠ escrow: [${s.escrow.join(", ")}] — an org-escrow key-holder CAN recover this content (it is NOT hidden from admins).`);
+        }
+        break;
+      }
+      case "open": {
+        const recoveryFlagIdx = args.indexOf("--recovery");
+        const path = args.filter((a) => !a.startsWith("-"))[0] || die("usage: sol open <path> [--recovery [slotId]] [--as <escrowAccountId>]");
+        const wantJson = args.includes("--json");
+        const repo = open().repo;
+        const leaf = await repo.read(path);
+        if (!leaf)
+          die("no such tracked path: " + path);
+        if (leaf.kind !== "sealed") {
+          process.stdout.write(leaf.kind === "blob" ? leaf.content : "");
+          break;
+        }
+        if (recoveryFlagIdx === -1) {
+          const [{ SealedClient: SealedClient2 }, { UNREADABLE: UNREADABLE3 }, { loadSelfIdentity: loadSelfIdentity2 }] = await Promise.all([Promise.resolve().then(() => (init_sealed_client(), exports_sealed_client)), Promise.resolve().then(() => (init_crypto(), exports_crypto)), Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience))]);
+          const opened2 = await new SealedClient2(repo, loadKeyRing()).open(path, actor, loadSelfIdentity2());
+          const readable = !(opened2 === undefined || opened2 === UNREADABLE3);
+          if (wantJson) {
+            console.log(JSON.stringify({ path, recovered: false, readable, content: readable ? opened2 : null }));
+            break;
+          }
+          process.stdout.write(readable ? opened2 : `<<sealed — you are not a recipient; use --recovery if you hold an escrow key>>
+`);
+          break;
+        }
+        const box = JSON.parse(leaf.box);
+        const slots = Object.keys(box.recovery ?? {});
+        if (!slots.length)
+          die(`"${path}" has no recovery slot — it was sealed WITHOUT --escrow. only a named recipient can open it.`);
+        const slotArg = args[recoveryFlagIdx + 1] && !args[recoveryFlagIdx + 1].startsWith("-") && args[recoveryFlagIdx + 1] !== path ? args[recoveryFlagIdx + 1] : undefined;
+        const slotId = slotArg ?? (slots.includes("org-escrow") ? "org-escrow" : slots[0]);
+        if (!slots.includes(slotId))
+          die(`"${path}" has no recovery slot "${slotId}". available: ${slots.join(", ")}`);
+        const asIdx = args.indexOf("--as");
+        const escrowAccount = asIdx >= 0 ? args[asIdx + 1] : slotId;
+        const recoveryCode = process.env.SOL_RECOVERY_CODE || die("set SOL_RECOVERY_CODE to the org-escrow recovery code (the escrow private key derives from it off-host; the host never holds it)");
+        const { deriveIdentity: deriveIdentity2, openWithRecovery: openWithRecovery2, UNREADABLE: UNREADABLE2 } = await Promise.resolve().then(() => (init_crypto(), exports_crypto));
+        const escrowId = deriveIdentity2(escrowAccount, recoveryCode, 1);
+        const opened = openWithRecovery2(escrowId.x25519Priv, JSON.parse(leaf.box), slotId);
+        if (opened === UNREADABLE2)
+          die(`recovery FAILED for slot "${slotId}" — wrong escrow code/account, or the box isn't wrapped to this escrow key. (the host holds no key; recovery is yours alone.)`);
+        const { parseStruct: parseStruct2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+        const struct = parseStruct2(opened);
+        if (struct) {
+          if (wantJson) {
+            console.log(JSON.stringify({ path, recovered: true, slot: slotId, struct: struct.__solStruct }));
+            break;
+          }
+          console.error(`recovered ${path} via escrow slot "${slotId}" — this is a ${struct.__solStruct} STRUCTURE box, not file bytes. recover the underlying files via a recipient checkout.`);
+          break;
+        }
+        if (wantJson) {
+          console.log(JSON.stringify({ path, recovered: true, slot: slotId, content: opened }));
+          break;
+        }
+        process.stdout.write(opened);
+        break;
+      }
+      case "branch":
+      case "branches": {
+        const { log } = open();
+        const refs = await loadRefs(log);
+        if (cmd === "branches" || !args[0]) {
+          for (const [n, b] of Object.entries(refs.branches))
+            console.log(`${n === refs.current ? "* " : "  "}${n}  ${(b.head || "empty").slice(0, 12)}`);
+          break;
+        }
+        const name = args[0];
+        if (refs.branches[name] || refs.tags[name])
+          die("already exists: " + name);
+        let head = await log.head() ?? "";
+        if (args[1]) {
+          const resolved = refs.branches[args[1]]?.head ?? refs.tags[args[1]] ?? (args[1].startsWith("h_") ? args[1] : "");
+          if (!resolved)
+            die(`cannot resolve ref '${args[1]}' — use a branch/tag name or a commit hash`);
+          head = resolved;
+        }
+        refs.branches[name] = { head, base: head };
+        saveRefs(refs);
+        console.log(`branch ${name} at ${(head || "empty").slice(0, 12)}`);
+        break;
+      }
+      case "tag": {
+        const { log } = open();
+        const refs = await loadRefs(log);
+        if (!args[0]) {
+          for (const [n, h] of Object.entries(refs.tags))
+            console.log(`${n}  ${h.slice(0, 12)}`);
+          break;
+        }
+        const name = args[0];
+        if (refs.branches[name] || refs.tags[name])
+          die("already exists: " + name);
+        refs.tags[name] = await log.head() ?? "";
+        saveRefs(refs);
+        console.log(`tag ${name} at ${(refs.tags[name] || "empty").slice(0, 12)}`);
+        break;
+      }
+      case "switch": {
+        const { repo, log } = open();
+        const name = args[0] || die("switch needs a branch name");
+        const refs = await loadRefs(log);
+        const target = refs.branches[name];
+        if (!target)
+          die(`no such branch: ${name} (run \`sol branch ${name}\` to create it)`);
+        const fromHead = await repo.head();
+        const wc = workingChanges(loadStore(), fromHead);
+        if (wc.added.length + wc.modified.length + wc.removed.length > 0) {
+          die('you have uncommitted changes — commit them first (`sol commit "msg"`), then switch. your work is safe on disk.');
+        }
+        setOpLogHead(target.head);
+        refs.current = name;
+        saveRefs(refs);
+        const n = materializeDiff(loadStore(), fromHead, target.head);
+        console.log(`switched to ${name} (${(target.head || "empty").slice(0, 12)}); ${n} file(s) changed`);
+        break;
+      }
+      case "merge": {
+        const { repo, log } = open();
+        const name = args[0] || die("merge needs a branch name");
+        const refs = await loadRefs(log);
+        const other = refs.branches[name];
+        if (!other)
+          die("no such branch: " + name);
+        if (name === refs.current)
+          die("cannot merge a branch into itself");
+        const mc = workingChanges(loadStore(), await repo.head());
+        if (mc.added.length + mc.modified.length + mc.removed.length > 0) {
+          die("you have uncommitted changes — commit them first, then merge.");
+        }
+        const ours = await log.head() ?? "";
+        const store2 = loadStore();
+        const { merge: merge2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+        const result = merge2({ store: store2 }, other.base, ours, other.head);
+        if (result.conflicts.length) {
+          materializeTree(store2, result.head);
+          writeFileSync16(join19(solDir, "MERGE_HEAD"), other.head);
+          saveMergeConflicts(solDir, result.conflicts);
+          console.log(`merge ${name} -> ${result.conflicts.length} conflict(s), left in your working tree (uncommitted):`);
+          for (const c of result.conflicts)
+            console.log("  " + c.path);
+          console.log("resolve the <<<<<<< markers, then `sol commit`");
+          process.exitCode = 1;
+          break;
+        }
+        await persistTree(store2, new FileStore(solDir, objectsDir()), result.head);
+        await appendCommit(log, result.head, `merge ${name} into ${refs.current}`, ours, other.head);
+        refs.branches[refs.current].head = result.head;
+        refs.branches[name].base = other.head;
+        saveRefs(refs);
+        setOpLogHead(result.head);
+        materializeTree(store2, result.head);
+        clearMergeConflicts(solDir);
+        console.log(`merged ${name} into ${refs.current} cleanly -> ${result.head.slice(0, 12)}`);
+        reportSemanticGate2(gateMerge(solDir, cfgDir2(), cwd, result.head), args.includes("--json"));
+        break;
+      }
+      case "undo": {
+        const { repo, log } = open();
+        const refs = await loadRefs(log);
+        const store2 = loadStore();
+        const wc = workingChanges(store2, await repo.head());
+        if (wc.added.length + wc.modified.length + wc.removed.length > 0) {
+          die('you have uncommitted changes — commit them first (`sol commit "msg"`), then undo. your work is safe on disk.');
+        }
+        const head = await log.head() ?? "";
+        const ops = await log.history();
+        const headOp = [...ops].reverse().find((o) => o.type === "checkpoint" && o.rootAfter === head);
+        if (!head || !headOp)
+          die("nothing to undo — no commit on this branch yet.");
+        const parent = headOp.parent;
+        if (parent === undefined)
+          die("nothing to undo — this is the first commit on the branch (it has no parent).");
+        const parentTree = parent || emptyRoot(store2);
+        const message = `undo ${head.slice(0, 8)} — ${headOp.message ?? ""}`.trimEnd();
+        await appendCommit(log, parentTree, message, head);
+        refs.branches[refs.current].head = parentTree;
+        saveRefs(refs);
+        setOpLogHead(parentTree);
+        const n = materializeDiff(store2, head, parentTree);
+        const undone = await log.head() ?? parentTree;
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({ undid: head, head: undone, parent: parentTree || null, filesChanged: n }));
+          break;
+        }
+        console.log(`undid ${head.slice(0, 14)} — branch ${refs.current} now at ${(parentTree || "empty").slice(0, 12)} (${n} file change${n === 1 ? "" : "s"})`);
+        console.log("  the undone commit stays in history (fsck OK) — `sol log --all` to see it; `sol revert` for a preserved-history inverse.");
+        break;
+      }
+      case "revert": {
+        const { repo, log } = open();
+        const refs = await loadRefs(log);
+        const store2 = loadStore();
+        const wc = workingChanges(store2, await repo.head());
+        if (wc.added.length + wc.modified.length + wc.removed.length > 0) {
+          die("you have uncommitted changes — commit them first, then revert.");
+        }
+        const refArg = args.find((a) => !a.startsWith("-")) || die("revert needs a ref: sol revert <branch|commit|seq>");
+        const ops = await log.history();
+        const resolved = await resolveRef(log, refArg);
+        const target = resolved.head;
+        const targetOp = resolved.op?.type === "checkpoint" && resolved.op.rootAfter === target ? resolved.op : [...ops].reverse().find((o) => o.type === "checkpoint" && o.rootAfter === target);
+        if (!targetOp)
+          die(`'${refArg}' does not name a commit to revert.`);
+        const before = targetOp.parent ?? "";
+        const beforeTree = before || emptyRoot(store2);
+        const head = await log.head() ?? "";
+        const { merge: merge2 } = await Promise.resolve().then(() => (init_merge(), exports_merge));
+        const result = merge2({ store: store2 }, target, head, beforeTree);
+        if (result.conflicts.length) {
+          materializeTree(store2, result.head);
+          if (args.includes("--json")) {
+            console.log(JSON.stringify({ reverted: target, conflicts: result.conflicts.map((c) => c.path), committed: false }));
+            break;
+          }
+          console.log(`revert ${target.slice(0, 12)} -> ${result.conflicts.length} conflict(s), left in your working tree (uncommitted):`);
+          for (const c of result.conflicts)
+            console.log("  " + c.path);
+          console.log("resolve the <<<<<<< markers, then `sol commit`");
+          process.exitCode = 1;
+          break;
+        }
+        await persistTree(store2, new FileStore(solDir, objectsDir()), result.head);
+        const message = `revert ${target.slice(0, 8)} — ${targetOp.message ?? ""}`.trimEnd();
+        await appendCommit(log, result.head, message, head);
+        refs.branches[refs.current].head = result.head;
+        saveRefs(refs);
+        setOpLogHead(result.head);
+        const n = materializeDiff(store2, head, result.head);
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({ reverted: target, head: result.head, filesChanged: n, committed: true }));
+          break;
+        }
+        console.log(`reverted ${target.slice(0, 14)} — new commit ${result.head.slice(0, 12)} (${n} file change${n === 1 ? "" : "s"}); ${refArg} stays in history.`);
+        break;
+      }
+      case "remote": {
+        if (!existsSync18(solDir))
+          die("not a sol repo");
+        if (args[0]) {
+          const repoName = args[1] || die("usage: sol remote <url> <repo>");
+          saveRemote(solDir, { url: args[0], repo: repoName });
+          console.log(`remote set: ${args[0]} (repo ${repoName})`);
+          break;
+        }
+        const cfg = loadRemote(solDir);
+        console.log(cfg ? `${cfg.url} (repo ${cfg.repo}${cfg.forkParent ? `, fork of ${cfg.forkParent}` : ""})` : "(no remote — `sol remote <url> <repo>` or `sol clone`)");
+        break;
+      }
+      case "auth": {
+        const sub = args[0];
+        if (sub === "login") {
+          const webUrl = (args[1] || "https://auth.midsummer.new").replace(/\/+$/, "");
+          const osLabel = { darwin: "macOS", win32: "Windows", linux: "Linux" }[platform3()] ?? platform3();
+          const deviceLabel = `${osLabel} · ${hostname2()}`;
+          const codeRes = await fetch(`${webUrl}/api/auth/device/code`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ deviceLabel })
+          });
+          if (!codeRes.ok)
+            die(`could not reach ${webUrl} (device/code -> ${codeRes.status})`);
+          const { code, authorizeUrl, verification_uri_complete, interval } = await codeRes.json();
+          const openUrl = verification_uri_complete || `${authorizeUrl || `${webUrl}/cli/authorize`}?code=${encodeURIComponent(code)}`;
+          console.log(`
+  To sign in, open:  ${openUrl}`);
+          console.log(`  (code, for reference:  ${code})
+`);
+          console.log("  Waiting for approval...");
+          const deadline = Date.now() + 300000;
+          let tokens;
+          while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, (interval || 2) * 1000));
+            const pr = await (await fetch(`${webUrl}/api/auth/device/poll`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ code }) })).json();
+            if (pr.status === "approved" && pr.accessToken) {
+              tokens = { accessToken: pr.accessToken, refreshToken: pr.refreshToken ?? "" };
+              break;
+            }
+            if (pr.status === "expired")
+              die("the code expired — run `sol auth login` again");
+          }
+          if (!tokens)
+            die("timed out waiting for approval");
+          mkdirSync12(dirname6(CRED_PATH2), { recursive: true });
+          writeFileSync16(CRED_PATH2, JSON.stringify({ webUrl, ...tokens }, null, 2), { mode: 384 });
+          const c = tokenClaims2(tokens.accessToken);
+          console.log(`
+  Logged in as ${c.handle ? `@${c.handle}` : c.email || "user"}.`);
+          if (!c.handle)
+            console.log("  (no handle yet — set one in the web app to get your <handle>/<repo> namespace)");
+        } else if (sub === "logout") {
+          if (existsSync18(CRED_PATH2))
+            unlinkSync8(CRED_PATH2);
+          console.log("logged out");
+        } else if (sub === "status" || !sub) {
+          if (process.env.SOL_TOKEN) {
+            const c2 = tokenClaims2(process.env.SOL_TOKEN);
+            console.log(`authenticated via SOL_TOKEN (env)${c2.handle ? ` as @${c2.handle}` : ""}`);
+            break;
+          }
+          if (!existsSync18(CRED_PATH2)) {
+            console.log("not logged in — run `sol auth login` (or set SOL_TOKEN)");
+            break;
+          }
+          const creds = JSON.parse(readFileSync18(CRED_PATH2, "utf8"));
+          const c = tokenClaims2(creds.accessToken || "");
+          const stale = typeof c.exp === "number" && c.exp * 1000 < Date.now();
+          console.log(`logged in as ${c.handle ? `@${c.handle}` : c.email || "user"} via ${creds.webUrl}${stale ? " (token stale — refreshes on next use)" : ""}`);
+        } else if (sub === "whoami") {
+          const token = process.env.SOL_TOKEN || await loadStoredToken2();
+          if (!token)
+            authExpired2();
+          let id = identityFromToken2(token);
+          try {
+            const res = await fetch(`${authHost2()}/api/auth/me`, { headers: { authorization: `Bearer ${token}` } });
+            if (res.status === 401 && !id)
+              authExpired2();
+            if (res.ok) {
+              const me = await res.json();
+              id = { handle: me.handle ?? id?.handle, email: me.email ?? id?.email, userId: id?.userId };
+            }
+          } catch {}
+          if (!id)
+            authExpired2();
+          console.log(id.handle ? `signed in as @${id.handle}  ${id.email ?? ""}`.trimEnd() : `signed in${id.email ? ` as ${id.email}` : ""} — no handle yet (\`sol auth set-handle <name>\`)`);
+        } else if (sub === "set-handle") {
+          const want = args[1] || die("usage: sol auth set-handle <name>");
+          const handle2 = want.toLowerCase();
+          const token = process.env.SOL_TOKEN || await loadStoredToken2();
+          if (!token)
+            authExpired2();
+          let hadHandle = false;
+          try {
+            const meRes = await fetch(`${authHost2()}/api/auth/me`, { headers: { authorization: `Bearer ${token}` } });
+            if (meRes.ok)
+              hadHandle = Boolean((await meRes.json()).handle);
+          } catch {}
+          const res = await fetch(`${authHost2()}/api/auth/handle`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ handle: handle2 }) });
+          if (res.status === 401)
+            authExpired2();
+          if (!res.ok) {
+            let msg = `could not set handle (${res.status})`;
+            try {
+              const err = await res.json();
+              if (err.error?.message)
+                msg = err.error.message;
+            } catch {}
+            die(msg);
+          }
+          const out = await res.json();
+          if (hadHandle)
+            console.log("heads-up: changing your handle re-namespaces your repos under the new <handle>/<repo>.");
+          console.log(`handle set to @${out.handle}`);
+        } else if (sub === "pat") {
+          if (!existsSync18(CRED_PATH2))
+            die("run `sol auth login` first");
+          const creds = JSON.parse(readFileSync18(CRED_PATH2, "utf8"));
+          const token = await loadStoredToken2();
+          if (!token || !creds.webUrl)
+            die("run `sol auth login` first");
+          const patAction = args[1];
+          if (patAction === "list") {
+            const res = await fetch(`${creds.webUrl}/api/auth/pat`, { headers: { authorization: `Bearer ${token}` } });
+            if (!res.ok)
+              die(`could not list PATs (${res.status})`);
+            const { tokens } = await res.json();
+            if (!tokens.length) {
+              console.log("(no personal access tokens — `sol auth pat [days] [name]` to mint one)");
+              break;
+            }
+            for (const t of tokens) {
+              const state = t.revokedAt ? "revoked" : t.expiresAt < Date.now() ? "expired" : "active";
+              const used = t.lastUsedAt ? `, last used ${new Date(t.lastUsedAt).toISOString().slice(0, 10)}` : "";
+              console.log(`  ${t.id}  ${t.name.padEnd(20)} [${state}]  expires ${new Date(t.expiresAt).toISOString().slice(0, 10)}${used}`);
+            }
+          } else if (patAction === "revoke") {
+            const id = args[2] || die("usage: sol auth pat revoke <id>");
+            const res = await fetch(`${creds.webUrl}/api/auth/pat`, { method: "DELETE", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ id }) });
+            if (res.status === 404)
+              die(`no such PAT (or not yours): ${id}`);
+            if (!res.ok)
+              die(`could not revoke PAT (${res.status})`);
+            const out = await res.json();
+            console.log(`revoked PAT ${id}${out.edgePropagated === false ? " (DB only — edge KV not configured; valid at the edge until expiry)" : ""}`);
+          } else {
+            const days = Number(patAction) || 90;
+            const name = (Number(patAction) ? args[2] : patAction) || undefined;
+            const res = await fetch(`${creds.webUrl}/api/auth/pat`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ days, ...name ? { name } : {} }) });
+            if (!res.ok)
+              die(`could not mint a PAT (${res.status})`);
+            const out = await res.json();
+            console.log(`
+  Personal Access Token "${out.name}" (id ${out.id}, expires in ${days} days) — store it now, it is not shown again:
+`);
+            console.log(`    ${out.token}
+`);
+            console.log("  Use it for git or CI (no device flow needed):");
+            console.log("    git clone https://x:<token>@<sol-backend>/git/<owner>/<repo>");
+            console.log("    export SOL_TOKEN=<token>");
+            console.log(`
+  Manage:  sol auth pat list   |   sol auth pat revoke ${out.id}`);
+          }
+        } else {
+          die("usage: sol auth [login [<web-url>] | logout | status | whoami | set-handle <name> | pat [days] [name] | pat list | pat revoke <id>]");
+        }
+        break;
+      }
+      case "clone": {
+        const { localPeerSolDir: localPeerSolDir2, openPeer: openPeer2, peerNodes: peerNodes2 } = await Promise.resolve().then(() => (init_local_peer(), exports_local_peer));
+        const localSrc = args[0] ? localPeerSolDir2(args[0], procCwd) : undefined;
+        if (localSrc) {
+          const { converge: converge2 } = await Promise.resolve().then(() => (init_converge(), exports_converge));
+          const peer = openPeer2(localSrc);
+          const peerHead = await peer.log.head();
+          const dest = resolve5(procCwd, args[1] || (args[0].replace(/\/+$/, "").split("/").pop() || "clone") + "-clone");
+          const ddir = join19(dest, ".sol");
+          if (existsSync18(ddir))
+            die("already a sol repo: " + dest);
+          mkdirSync12(ddir, { recursive: true });
+          const peerOps = await peer.log.history();
+          const res = await converge2({ store: new FileStore(ddir), log: new FileOpLog(ddir) }, { nodes: await peerNodes2(peer, peerHead, peerOps), ops: peerOps, incomingHead: peerHead, actor });
+          const dstore = new Store;
+          for (const n2 of await peerNodes2({ store: new FileStore(ddir), log: new FileOpLog(ddir) }, res.head))
+            dstore.put(n2);
+          const { isReservedKey: isReservedKey2 } = await Promise.resolve().then(() => (init_struct(), exports_struct));
+          const files = (res.head ? listAll(dstore, res.head) : []).filter((f) => !f.split("/").some(isReservedKey2));
+          for (const f of files)
+            materializeInto(dstore, res.head, dest, f);
+          writeFileSync16(join19(ddir, "refs.json"), JSON.stringify({ current: "main", branches: { main: { head: res.head, base: res.head, remote: res.head } }, tags: {} }, null, 2));
+          writeWorkingIndexAt(ddir, dest, files);
+          console.log(`cloned local peer ${args[0]} -> ${dest} (${(await peer.log.history()).length} ops, ${files.length} files)`);
+          break;
+        }
+        const [url, rest] = remoteUrlArg2(args);
+        const repoName = rest[0] || die("usage: sol clone [<url>] <owner>/<repo> [dir]");
+        const token = process.env.SOL_TOKEN || die("set SOL_TOKEN to the backend bearer token");
+        const target = resolve5(cwd, rest[1] || repoName.split("/").pop() || repoName);
+        const fdir = join19(target, ".sol");
+        if (existsSync18(fdir))
+          die("already a sol repo: " + target);
+        const cfg = { url, repo: repoName };
+        const bundle = await remoteExport(cfg, token);
+        mkdirSync12(fdir, { recursive: true });
+        await writeBundle(fdir, bundle, 0);
+        saveRemote(fdir, cfg);
+        await pullEnvState2(fdir, cfg, token);
+        const srvRefs = bundle.refs ?? { branches: { main: bundle.head ?? "" }, production: "main" };
+        const checkout = bundle.checkout ?? { branch: srvRefs.production || "main", head: srvRefs.branches[srvRefs.production] ?? bundle.head };
+        const onBranch = checkout.branch;
+        const checkoutHead = checkout.head ?? bundle.head ?? "";
+        const cloneBranches = {};
+        for (const [name, h] of Object.entries(srvRefs.branches))
+          cloneBranches[name] = { head: h, base: h, remote: h };
+        if (!cloneBranches[onBranch])
+          cloneBranches[onBranch] = { head: checkoutHead, base: checkoutHead, remote: checkoutHead };
+        writeFileSync16(join19(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
+        writeFileSync16(join19(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: bundle.seq, logTip: bundle.tip }));
+        const store2 = new Store;
+        for (const node of bundle.nodes)
+          store2.put(node);
+        let n = 0;
+        if (checkoutHead) {
+          const files = listAll(store2, checkoutHead);
+          for (const f of files)
+            if (materializeInto(store2, checkoutHead, target, f))
+              n++;
+          writeWorkingIndexAt(fdir, target, files);
+        }
+        console.log(`cloned ${repoName} -> ${rest[1] || repoName} (${bundle.ops.length} ops, ${Object.keys(cloneBranches).length} branch(es), ${n} files, on ${onBranch})`);
+        break;
+      }
+      case "push": {
+        const { log } = open();
+        const wantPublic = args.includes("--public");
+        if (!loadRemote(solDir)) {
+          const repoName = args.find((a) => !a.startsWith("-"));
+          if (repoName) {
+            saveRemote(solDir, { url: DEFAULT_REMOTE_URL2, repo: repoName });
+            console.log(`remote set: ${DEFAULT_REMOTE_URL2} (repo ${repoName})`);
+          }
+        }
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`, or `sol push <repo>` to use the hosted Sol");
+        {
+          const { pendingScrubPaths: pendingScrubPaths2, historyHasCleartext: historyHasCleartext2 } = await Promise.resolve().then(() => (init_secret_scrub(), exports_secret_scrub));
+          const ops0 = await log.history();
+          const stillLeaking = pendingScrubPaths2(solDir).filter((p) => historyHasCleartext2(solDir, ops0, p));
+          if (stillLeaking.length) {
+            die(`refusing to push — pre-seal CLEARTEXT is still in history for: ${stillLeaking.join(", ")}. the plaintext would ship to every clone (recoverable via \`sol restore\`). run \`sol seal ${stillLeaking[0]} --scrub-history\` (repeat per path, or \`sol seal --scrub-history\` for all) first.`);
+          }
+        }
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const rh = await remoteHead(cfg, token);
+        const ops = await log.history();
+        const localSeq = ops.length ? ops[ops.length - 1].seq : 0;
+        const localTip = await log.logTip();
+        const localRefs = existsSync18(refsPath()) ? JSON.parse(readFileSync18(refsPath(), "utf8")) : undefined;
+        const branch = localRefs?.current ?? "main";
+        const branchHead = await log.head() ?? "";
+        const remoteWasEmpty = rh.seq === 0 && !rh.tip;
+        if (localSeq === rh.seq && localTip === rh.tip) {
+          console.log(remoteWasEmpty ? "nothing to push — local repo is empty (commit something first)" : "everything up to date");
+          break;
+        }
+        if (localSeq <= rh.seq) {}
+        const forkBase = localRefs?.branches[branch]?.remote;
+        const baseOp = forkBase ? ops.find((o) => o.rootAfter === forkBase) : undefined;
+        const fromSeq = baseOp ? baseOp.seq : rh.seq;
+        const res = await remotePush(cfg, token, {
+          nodes: allLocalNodes(),
+          ops: ops.filter((o) => o.seq > fromSeq),
+          branch,
+          head: branchHead,
+          expectedHead: forkBase
+        });
+        const canon = await remoteExport(cfg, token);
+        const prevHead = await log.head() ?? "";
+        await writeBundle(solDir, canon, 0);
+        const convergedHead = res.head ?? canon.refs?.branches?.[branch] ?? branchHead;
+        if (existsSync18(refsPath())) {
+          const refs = JSON.parse(readFileSync18(refsPath(), "utf8"));
+          if (canon.refs) {
+            for (const [name, h] of Object.entries(canon.refs.branches)) {
+              refs.branches[name] = { head: refs.branches[name]?.head ?? h, base: refs.branches[name]?.base ?? h, remote: h };
+            }
+          }
+          if (refs.branches[branch]) {
+            refs.branches[branch].head = convergedHead;
+            refs.branches[branch].remote = convergedHead;
+          }
+          saveRefs(refs);
+        }
+        setOpLogHead(convergedHead);
+        if (convergedHead && convergedHead !== prevHead)
+          materializeDiff(loadStore(), prevHead, convergedHead);
+        const prod = res.refs?.production;
+        const mergedNote = res.merged ? " (converged with a concurrent commit)" : "";
+        const conflictNote = res.conflicts && res.conflicts.length ? ` — ${res.conflicts.length} conflict(s) kept with markers in: ${res.conflicts.map((c) => c.path).join(", ")}` : "";
+        if (remoteWasEmpty) {
+          console.log(`created remote repo ${cfg.repo} — pushed ${res.applied} op(s) (branch ${branch} @ ${(convergedHead || "").slice(0, 12)})${prod ? `; production=${prod}` : ""}`);
+        } else {
+          console.log(`pushed ${res.applied} op(s) -> remote (branch ${branch} @ ${(convergedHead || "").slice(0, 12)})${mergedNote}${conflictNote}${prod ? `; production=${prod}` : ""}`);
+        }
+        await pushEnvState2(solDir, cfg, token);
+        if (wantPublic) {
+          const a = await accessSet(cfg, token, { visibility: "public" });
+          console.log(`${cfg.repo} is now ${a.visibility}`);
+        }
+        if (res.merged && !(res.conflicts && res.conflicts.length) && convergedHead) {
+          reportSemanticGate2(gateMerge(solDir, cfgDir2(), cwd, convergedHead), args.includes("--json"));
+        }
+        break;
+      }
+      case "pull": {
+        const { log } = open();
+        const [{ localPeerSolDir: localPeerSolDir2, openPeer: openPeer2, peerNodes: peerNodes2 }, { converge: converge2 }, { merge: merge2 }] = await Promise.all([
+          Promise.resolve().then(() => (init_local_peer(), exports_local_peer)),
+          Promise.resolve().then(() => (init_converge(), exports_converge)),
+          Promise.resolve().then(() => (init_merge(), exports_merge))
+        ]);
+        {
+          const marked = unresolvedConflictPaths();
+          if (marked.length)
+            die(`unresolved conflict markers in ${marked.join(", ")} — resolve them and \`sol commit\`, then pull again.`);
+        }
+        const peerArg = args[0];
+        const peerSolDir = peerArg ? localPeerSolDir2(peerArg, cwd) : undefined;
+        if (peerSolDir) {
+          const wcLocal = workingChanges(loadStore(), await log.head() ?? "");
+          if (wcLocal.added.length + wcLocal.modified.length + wcLocal.removed.length > 0) {
+            die("you have uncommitted changes — commit (`sol commit`) or discard them before pulling.");
+          }
+          const peer = openPeer2(peerSolDir);
+          const peerHead = await peer.log.head();
+          if (!peerHead) {
+            console.log("peer repo is empty — nothing to pull");
+            break;
+          }
+          const prevHead = await log.head() ?? "";
+          const peerOps = await peer.log.history();
+          const peerMeta = readViewMeta(peerSolDir);
+          const ownMeta = readViewMeta(solDir);
+          const base2 = peerMeta?.startHead ?? ownMeta?.startHead;
+          const res = await converge2({ store: new FileStore(solDir, objectsDir()), log }, { nodes: await peerNodes2(peer, peerHead, peerOps), ops: peerOps, incomingHead: peerHead, actor, ...base2 ? { base: base2 } : {} });
+          if (existsSync18(refsPath())) {
+            const refs = JSON.parse(readFileSync18(refsPath(), "utf8"));
+            if (refs.branches[refs.current])
+              refs.branches[refs.current].head = res.head;
+            saveRefs(refs);
+          }
+          setOpLogHead(res.head);
+          if (res.head !== prevHead)
+            materializeDiff(loadStore(), prevHead, res.head);
+          if (res.conflicts.length) {
+            saveMergeConflicts(solDir, res.conflicts);
+            console.log(`pulled + merged from ${peerArg} WITH ${res.conflicts.length} conflict(s) — both sides kept with markers in:`);
+            for (const c of res.conflicts)
+              console.log("  " + c.path);
+            console.log("resolve the <<<<<<< markers, then `sol commit`");
+            process.exitCode = 1;
+          } else {
+            clearMergeConflicts(solDir);
+            console.log(`pulled from ${peerArg} -> ${res.applied} new op(s)${res.merged ? " (converged by merge)" : ""}, now at ${(res.head || "").slice(0, 12)}`);
+            if (res.merged)
+              reportSemanticGate2(gateMerge(solDir, cfgDir2(), cwd, res.head), args.includes("--json"));
+          }
+          break;
+        }
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        await surfaceEnvDivergence2(solDir, cfg, token);
+        await pullEnvState2(solDir, cfg, token);
+        const bundle = await remoteExport(cfg, token);
+        const ops = await log.history();
+        const localSeq = ops.length ? ops[ops.length - 1].seq : 0;
+        const localTip = await log.logTip();
+        const curBranch = existsSync18(refsPath()) ? JSON.parse(readFileSync18(refsPath(), "utf8")).current : bundle.refs?.production || "main";
+        const remoteCurHead = bundle.refs?.branches?.[curBranch] ?? bundle.head ?? "";
+        if (bundle.seq === localSeq && bundle.tip === localTip) {
+          if (bundle.refs && existsSync18(refsPath())) {
+            const lr = JSON.parse(readFileSync18(refsPath(), "utf8"));
+            const before = lr.branches[lr.current]?.head;
+            for (const [name, h] of Object.entries(bundle.refs.branches))
+              lr.branches[name] = { head: h, base: lr.branches[name]?.base ?? h, remote: h };
+            saveRefs(lr);
+            const after = lr.branches[lr.current]?.head;
+            if (after && after !== before) {
+              setOpLogHead(after);
+              materializeDiff(loadStore(), before ?? "", after);
+              console.log(`updated ${lr.current} -> ${after.slice(0, 12)} (a ref moved on the remote — merge/promote)`);
+              break;
+            }
+          }
+          console.log("already up to date");
+          break;
+        }
+        let n = 0;
+        while (n < ops.length && n < bundle.ops.length && ops[n].entryHash === bundle.ops[n].entryHash)
+          n++;
+        if (n === bundle.ops.length) {
+          console.log("up to date (local is ahead — run `sol push`)");
+          break;
+        }
+        const syncRefHead = (h) => {
+          if (!existsSync18(refsPath()))
+            return;
+          const refs = JSON.parse(readFileSync18(refsPath(), "utf8"));
+          if (refs.branches[refs.current])
+            refs.branches[refs.current].head = h;
+          saveRefs(refs);
+        };
+        {
+          const wc = workingChanges(loadStore(), await log.head() ?? "");
+          const dirty = [...wc.added.map((f) => "+ " + f), ...wc.modified.map((f) => "~ " + f), ...wc.removed.map((f) => "- " + f)];
+          if (dirty.length)
+            die(`you have uncommitted changes — commit (\`sol commit\`) or discard them before pulling:
+  ${dirty.join(`
+  `)}`);
+        }
+        if (n === ops.length) {
+          const added = await writeBundle(solDir, bundle, localSeq);
+          syncRefHead(remoteCurHead);
+          setOpLogHead(remoteCurHead);
+          materializeTree(loadStore(), remoteCurHead);
+          if (bundle.refs && existsSync18(refsPath())) {
+            const lr = JSON.parse(readFileSync18(refsPath(), "utf8"));
+            for (const [name, h] of Object.entries(bundle.refs.branches))
+              lr.branches[name] = { head: h, base: lr.branches[name]?.base ?? h, remote: h };
+            saveRefs(lr);
+          }
+          console.log(`pulled ${added} new op(s) -> ${curBranch} now at ${(remoteCurHead || "").slice(0, 12)}`);
+          break;
+        }
+        const store2 = loadStore();
+        for (const node of bundle.nodes)
+          store2.put(node);
+        const base = n > 0 ? ops[n - 1].rootAfter : emptyRoot(store2);
+        const localHead = await log.head() ?? "";
+        const remoteHead2 = remoteCurHead;
+        const pathAuthor = new Map;
+        for (const op of ops.slice(n))
+          if (op.by && op.path)
+            pathAuthor.set(op.path, op.by);
+        const result = merge2({ store: store2 }, base, localHead, remoteHead2);
+        const conflicted = new Set(result.conflicts.map((c) => c.path));
+        await writeBundle(solDir, bundle, 0);
+        setOpLogHead(remoteHead2);
+        const { repo: rebased } = open();
+        const d = diffTrees(store2, remoteHead2, result.head);
+        for (const p of [...d.added, ...d.modified.map((m) => m.path)]) {
+          if (conflicted.has(p))
+            continue;
+          const blob = fileAt(store2, result.head, p);
+          if (!blob)
+            continue;
+          const author = pathAuthor.get(p);
+          if (blob.encoding === "base64")
+            await rebased.writeBytes(p, new Uint8Array(Buffer.from(blob.content, "base64")), undefined, author);
+          else
+            await rebased.writeFile(p, blob.content, undefined, author);
+        }
+        for (const p of d.removed)
+          if (!conflicted.has(p))
+            await rebased.deleteFile(p, undefined, pathAuthor.get(p));
+        if (!result.conflicts.length)
+          await appendCommit(log, await rebased.head(), "merge remote into local", remoteHead2);
+        const mergedHead = await log.head() ?? "";
+        syncRefHead(mergedHead);
+        materializeTree(loadStore(), mergedHead);
+        if (result.conflicts.length) {
+          for (const c of result.conflicts) {
+            const blob = fileAt(store2, result.head, c.path);
+            if (blob)
+              writeFileSync16(join19(cwd, c.path), blob.encoding === "base64" ? Buffer.from(blob.content, "base64") : blob.content);
+          }
+          writeFileSync16(join19(solDir, "MERGE_HEAD"), remoteHead2);
+          saveMergeConflicts(solDir, result.conflicts);
+          console.log(`pulled + merged WITH ${result.conflicts.length} conflict(s), left uncommitted in your working tree:`);
+          for (const c of result.conflicts)
+            console.log("  " + c.path);
+          console.log("resolve the <<<<<<< markers, then `sol commit` and `sol push`");
+          process.exitCode = 1;
+        } else {
+          clearMergeConflicts(solDir);
+          console.log(`pulled + merged remote into local -> ${mergedHead.slice(0, 12)} (now run \`sol push\`)`);
+          reportSemanticGate2(gateMerge(solDir, cfgDir2(), cwd, mergedHead), args.includes("--json"));
+        }
+        break;
+      }
+      case "promote": {
+        if (!existsSync18(solDir))
+          die("not a sol repo");
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const cur = existsSync18(refsPath()) ? JSON.parse(readFileSync18(refsPath(), "utf8")).current : "main";
+        const branch = args[0] || cur;
+        const refs = await remotePromote(cfg, token, branch);
+        console.log(`promoted '${branch}' -> production '${refs.production}' now at ${(refs.branches[refs.production] ?? "").slice(0, 12)}`);
+        break;
+      }
+      case "fork": {
+        const [url, frest] = remoteUrlArg2(args);
+        const parent = frest[0] || die("usage: sol fork [<url>] <parent-repo> <new-repo> [dir]");
+        const newRepo = frest[1] || die("usage: sol fork [<url>] <parent-repo> <new-repo> [dir]");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const target = resolve5(cwd, frest[2] || newRepo);
+        const fdir = join19(target, ".sol");
+        if (existsSync18(fdir))
+          die("already a sol repo: " + target);
+        const parentCfg = { url, repo: parent };
+        const newCfg = { url, repo: newRepo, forkParent: parent };
+        const bundle = await remoteExport(parentCfg, token);
+        if (!bundle.ops.length)
+          die(`parent repo '${parent}' is empty or unreachable`);
+        const prodBranch = bundle.refs?.production || "main";
+        const prodHead = bundle.checkout?.head || bundle.head;
+        await remotePush(newCfg, token, { nodes: bundle.nodes, ops: bundle.ops, branch: prodBranch, head: prodHead });
+        for (const [name, h] of Object.entries(bundle.refs?.branches ?? {})) {
+          if (name !== prodBranch)
+            await remotePush(newCfg, token, { nodes: [], ops: [], branch: name, head: h });
+        }
+        await forkMeta(newCfg, token, parent);
+        const canon = await remoteExport(newCfg, token);
+        mkdirSync12(fdir, { recursive: true });
+        await writeBundle(fdir, canon, 0);
+        const srvRefs = canon.refs ?? { branches: { main: canon.head ?? "" }, production: "main" };
+        const checkout = canon.checkout ?? { branch: srvRefs.production || "main", head: srvRefs.branches[srvRefs.production] ?? canon.head };
+        const onBranch = checkout.branch;
+        const checkoutHead = checkout.head ?? canon.head ?? "";
+        const cloneBranches = {};
+        for (const [name, h] of Object.entries(srvRefs.branches))
+          cloneBranches[name] = { head: h, base: h, remote: h };
+        writeFileSync16(join19(fdir, "refs.json"), JSON.stringify({ current: onBranch, branches: cloneBranches, tags: {} }, null, 2));
+        writeFileSync16(join19(fdir, "HEAD"), JSON.stringify({ head: checkoutHead, seq: canon.seq, logTip: canon.tip }));
+        saveRemote(fdir, newCfg);
+        const store2 = new Store;
+        for (const node of canon.nodes)
+          store2.put(node);
+        let n = 0;
+        if (checkoutHead) {
+          const files = listAll(store2, checkoutHead);
+          for (const f of files)
+            if (materializeInto(store2, checkoutHead, target, f))
+              n++;
+          writeWorkingIndexAt(fdir, target, files);
+        }
+        console.log(`forked ${parent} -> ${newRepo}  (your copy at ${args[3] || newRepo}: ${Object.keys(cloneBranches).length} branch(es), ${n} files; parent: ${parent})`);
+        break;
+      }
+      case "access": {
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`");
+        const sub = args[0];
+        if (!sub || sub === "show") {
+          const a = await accessGet(cfg, token);
+          console.log(`${cfg.repo}: ${a.visibility}`);
+          const cols = Object.entries(a.collaborators);
+          if (cols.length)
+            for (const [u, r] of cols)
+              console.log(`  ${u}: ${r}`);
+          else
+            console.log("  (no collaborators)");
+          const teams = Object.entries(a.teams ?? {});
+          if (teams.length)
+            for (const [t, r] of teams)
+              console.log(`  team:${t}: ${r}`);
+        } else if (sub === "public" || sub === "private") {
+          const a = await accessSet(cfg, token, { visibility: sub });
+          console.log(`${cfg.repo} is now ${a.visibility}`);
+        } else if (sub === "add") {
+          const userId = args[1] || die("usage: sol access add <userId> <read|write|admin>");
+          const role = args[2] || "read";
+          if (role !== "read" && role !== "write" && role !== "admin")
+            die(`invalid role '${role}' — use read, write, or admin`);
+          const a = await accessSet(cfg, token, { collaborator: { userId, role } });
+          if (a.collaborators?.[userId] === role)
+            console.log(`granted ${role} to ${userId} on ${cfg.repo}`);
+          else
+            die(`failed to grant ${role} to ${userId} (the server did not apply it)`);
+        } else if (sub === "add-team") {
+          const teamId = args[1] || die("usage: sol access add-team <teamId> <read|write|admin>");
+          const role = args[2] || "read";
+          if (role !== "read" && role !== "write" && role !== "admin")
+            die(`invalid role '${role}' — use read, write, or admin`);
+          const a = await accessSet(cfg, token, { team: { teamId, role } });
+          if (a.teams?.[teamId] === role)
+            console.log(`granted ${role} to team:${teamId} on ${cfg.repo}`);
+          else
+            die(`failed to grant ${role} to team:${teamId} (the server did not apply it)`);
+        } else if (sub === "remove-team") {
+          const teamId = args[1] || die("usage: sol access remove-team <teamId>");
+          await accessSet(cfg, token, { team: { teamId, remove: true } });
+          console.log(`removed team:${teamId} from ${cfg.repo}`);
+        } else if (sub === "remove") {
+          const userId = args[1] || die("usage: sol access remove <userId>");
+          await accessSet(cfg, token, { collaborator: { userId, remove: true } });
+          console.log(`removed ${userId} from ${cfg.repo}`);
+        } else {
+          die("usage: sol access [show | public | private | add <userId> <role> | remove <userId> | add-team <teamId> <role> | remove-team <teamId>]");
+        }
+        break;
+      }
+      case "forks": {
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const { forks } = await forksList(cfg, token);
+        if (!forks.length)
+          console.log(`(no forks of ${cfg.repo})`);
+        else {
+          console.log(`forks of ${cfg.repo}:`);
+          for (const f of forks)
+            console.log(`  ${f.repo}`);
+        }
+        break;
+      }
+      case "mr": {
+        const cfg = resolveRemote2(solDir) || die("no remote — set one with `sol remote <url> <repo>`");
+        const token = process.env.SOL_TOKEN || authExpired2();
+        const { mrSummary: mrSummary2 } = await Promise.resolve().then(() => exports_mr);
+        const sub = args[0];
+        const localRefs = () => existsSync18(refsPath()) ? JSON.parse(readFileSync18(refsPath(), "utf8")) : { current: "main", branches: {}, tags: {} };
+        const flag2 = (name) => {
+          const i = args.indexOf(name);
+          return i >= 0 ? args[i + 1] : undefined;
+        };
+        const has2 = (name) => args.includes(name);
+        const idArg = () => +(args[1] || die("this `sol pr` command needs an <id>"));
+        if (sub === "open") {
+          const refs = localRefs();
+          const fromBranch = flag2("--from") || refs.current;
+          const fromHead = refs.branches[fromBranch]?.head;
+          const upstream = flag2("--upstream") || (has2("--upstream") ? cfg.forkParent : undefined);
+          const target = upstream ? { url: cfg.url, repo: upstream } : cfg;
+          const pr = await mrOpen(target, token, { fromRepo: upstream ? cfg.repo : undefined, fromBranch, fromHead, toBranch: flag2("--to"), title: flag2("-t") || flag2("--title"), body: flag2("-m") || flag2("--body") });
+          const where = upstream ? `${cfg.repo}/${pr.fromBranch} -> ${upstream}/${pr.toBranch}` : `${pr.fromBranch} -> ${pr.toBranch}`;
+          console.log(`opened MR #${pr.id}${upstream ? ` on ${upstream}` : ""}: ${pr.title}  (${where})`);
+        } else if (sub === "list") {
+          const { mrs } = await mrList(cfg, token);
+          if (!mrs.length)
+            console.log("(no merge requests)");
+          for (const p of mrs)
+            console.log(`#${p.id}  [${p.status}]  ${p.fromRepo ? `${p.fromRepo}/` : ""}${p.fromBranch} -> ${p.toBranch}  "${p.title}"  — ${mrSummary2(p)}`);
+        } else if (sub === "show") {
+          const pr = await mrGet(cfg, token, idArg());
+          console.log(`MR #${pr.id}  [${pr.status}]  by ${pr.author}`);
+          console.log(`${pr.fromRepo ? `${pr.fromRepo}/` : ""}${pr.fromBranch} (${(pr.fromHead || "").slice(0, 12)}) -> ${pr.toBranch}${pr.fromRepo ? "  [cross-fork]" : ""}`);
+          console.log(pr.title);
+          if (pr.body)
+            console.log(`
+${pr.body}`);
+          console.log(`
+${mrSummary2(pr)}`);
+          for (const c of pr.checks)
+            console.log(`  check ${c.name}: ${c.status}${c.detail ? ` (${c.detail.split(`
+`)[0]})` : ""}`);
+          for (const r of pr.reviews)
+            console.log(`  review ${r.actor}: ${r.verdict}${r.body ? ` — ${r.body}` : ""}`);
+          for (const c of pr.comments)
+            console.log(`  comment ${c.actor}${c.path ? ` @${c.path}:${c.line}` : ""}: ${c.body}`);
+          console.log(`
+--- diff (what would merge) ---`);
+          if (pr.fromRepo) {
+            const d = await mrDiff(cfg, token, pr.id);
+            for (const p of d.added ?? [])
+              console.log(`  + ${p}`);
+            for (const m of d.modified ?? []) {
+              const path = typeof m === "string" ? m : m.path;
+              console.log(`  ~ ${path}`);
+              const hunks2 = typeof m === "string" ? "" : m.hunks;
+              if (hunks2)
+                console.log(hunks2.split(`
+`).map((l) => "      " + l).join(`
+`));
+            }
+            for (const p of d.removed ?? [])
+              console.log(`  - ${p}`);
+            if (!((d.added?.length ?? 0) + (d.modified?.length ?? 0) + (d.removed?.length ?? 0)))
+              console.log("  (no changes)");
+          } else {
+            const toHead = localRefs().branches[pr.toBranch]?.head;
+            if (toHead && pr.fromHead) {
+              try {
+                printTreeDiff(diffTrees(loadStore(), toHead, pr.fromHead));
+              } catch {
+                console.log("(run `sol pull` to compute the diff locally)");
+              }
+            }
+          }
+        } else if (sub === "review") {
+          const verdict = has2("--approve") ? "approve" : has2("--request-changes") ? "request-changes" : "comment";
+          const pr = await mrAction(cfg, token, "review", { id: idArg(), verdict, body: flag2("-m") ?? "" });
+          console.log(`reviewed MR #${pr.id}: ${verdict}`);
+        } else if (sub === "comment") {
+          const line = flag2("--line");
+          const pr = await mrAction(cfg, token, "comment", { id: idArg(), body: flag2("-m") ?? "", path: flag2("--path"), line: line ? +line : undefined });
+          console.log(`commented on MR #${pr.id}`);
+        } else if (sub === "check") {
+          const id = idArg();
+          if (has2("--run")) {
+            const dashes = args.indexOf("--");
+            if (dashes < 0 || args.length <= dashes + 1)
+              die("usage: sol mr check <id> --run -- <test command>");
+            const cmd2 = args.slice(dashes + 1);
+            const name = flag2("--name") || cmd2.join(" ");
+            let status = "pass";
+            let detail = "";
+            try {
+              execFileSync3(cmd2[0], cmd2.slice(1), { cwd, stdio: "pipe" });
+            } catch (e) {
+              status = "fail";
+              const err = e;
+              detail = (err.stdout?.toString() || err.message || "").slice(-200);
+            }
+            const pr = await mrAction(cfg, token, "check", { id, name, status, detail });
+            console.log(`check '${name}' on MR #${pr.id}: ${status}`);
+          } else {
+            const name = flag2("--name") || "check";
+            const status = flag2("--status") || "pending";
+            await mrAction(cfg, token, "check", { id, name, status, detail: flag2("--detail") });
+            console.log(`reported check '${name}' = ${status} on MR #${id}`);
+          }
+        } else if (sub === "merge") {
+          const id = idArg();
+          try {
+            const pr = await mrAction(cfg, token, "merge", { id, force: has2("--force") });
+            console.log(`merged MR #${pr.id} -> ${pr.toBranch} now at ${(pr.mergeHead || "").slice(0, 12)} (run \`sol pull\` to sync)`);
+          } catch (e) {
+            const msg = String(e.message).replace(/^remote \/mr\/merge -> \d+: /, "");
+            let clean = msg;
+            try {
+              const j = JSON.parse(msg);
+              clean = j.reasons?.length ? `${j.error}: ${j.reasons.join("; ")} — use \`--force\` to override` : j.error;
+            } catch {}
+            die(clean);
+          }
+        } else if (sub === "close") {
+          const pr = await mrAction(cfg, token, "close", { id: idArg() });
+          console.log(`closed MR #${pr.id}`);
+        } else {
+          die("usage: sol mr open|list|show <id>|review <id>|comment <id>|check <id>|merge <id>|close <id>");
+        }
+        break;
+      }
+      case "watch": {
+        const { repo, log } = open();
+        const tick = async (announce) => {
+          const release2 = acquireLock();
+          let changed = 0;
+          try {
+            const snap = await snapshotTree(repo);
+            changed = snap.changed;
+            if (changed) {
+              await appendCapture(log, snap.root);
+              writeWorkingIndex(await repo.list());
+            }
+          } finally {
+            release2();
+          }
+          const t = new Date().toLocaleTimeString();
+          if (changed)
+            console.log(`[${t}] auto-captured ${changed} change(s) -> ${(await repo.head()).slice(0, 12)}`);
+          else if (announce)
+            console.log(`[${t}] working tree already up to date`);
+        };
+        await tick(true);
+        console.log(`sol watching ${cwd}
+  every change is auto-captured into the op-log — nothing is lost, even if you never commit.
+  run \`sol commit "msg"\` any time to mark a milestone. Ctrl-C to stop.`);
+        let timer;
+        watch2(cwd, { recursive: true }, (_e, filename) => {
+          if (!filename)
+            return;
+          const top = String(filename).split(sep3)[0];
+          if (top === ".sol" || DEFAULT_IGNORE.includes(top))
+            return;
+          clearTimeout(timer);
+          timer = setTimeout(() => tick(false).catch((e) => console.error("sol: " + (e?.message || e))), 400);
+        });
+        await new Promise(() => {});
+        break;
+      }
+      case "run": {
+        const { repo, log } = open();
+        const keep = [];
+        const command = [];
+        let isolate = false;
+        for (let i = 0;i < args.length; i++) {
+          if (args[i] === "--keep")
+            keep.push(args[++i]);
+          else if (args[i] === "--isolate")
+            isolate = true;
+          else
+            command.push(args[i]);
+        }
+        if (!command.length)
+          die("usage: sol run [--keep <path>] [--isolate] <command...>");
+        const { capture: capture3, hydrate: hydrate3, isolateCommand: isolateCommand2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
+        const head = await repo.head();
+        const dir = mkdtempSync2(join19(tmpdir2(), "sol-run-"));
+        try {
+          const hn = hydrate3(loadStore(), head, dir);
+          console.log(`hydrated ${hn} file(s) -> sandbox${isolate ? " (isolated: no network, writes confined to the sandbox)" : ""}`);
+          const argv2 = isolate ? isolateCommand2(command, dir) : command;
+          console.log(`$ ${command.join(" ")}`);
+          let failed = 0;
+          try {
+            execFileSync3(argv2[0], argv2.slice(1), { cwd: dir, stdio: "inherit" });
+          } catch (e) {
+            failed = typeof e?.status === "number" ? e.status : 1;
+          }
+          if (failed) {
+            console.error(`(command failed with exit ${failed}; nothing captured)`);
+            process.exitCode = failed;
+            break;
+          }
+          const { written, deleted } = await capture3(repo, dir, keep);
+          if (written.length || deleted.length) {
+            await appendCommit(log, await repo.head(), `run: ${command.join(" ")}`, head);
+            if (existsSync18(refsPath())) {
+              const refs = JSON.parse(readFileSync18(refsPath(), "utf8"));
+              if (refs.branches[refs.current]) {
+                refs.branches[refs.current].head = await repo.head();
+                saveRefs(refs);
+              }
+            }
+            const synced = loadStore();
+            const nh = await repo.head();
+            for (const f of written)
+              materialize(synced, nh, f);
+            for (const f of deleted) {
+              try {
+                unlinkSync8(join19(cwd, f));
+              } catch {}
+            }
+            console.log(`captured ${written.length} written, ${deleted.length} deleted file(s):`);
+            for (const f of written)
+              console.log("  + " + f);
+            for (const f of deleted)
+              console.log("  - " + f);
+          } else {
+            console.log("no files captured (the run produced no tracked changes)");
+          }
+        } finally {
+          rmSync3(dir, { recursive: true, force: true });
+        }
+        break;
+      }
+      case "git": {
+        const [{ exportHistoryToGit: exportHistoryToGit2, importGitRepo: importGitRepo2 }, { hydrate: hydrate3 }] = await Promise.all([Promise.resolve().then(() => (init_git_adapter(), exports_git_adapter)), Promise.resolve().then(() => (init_runtime(), exports_runtime))]);
+        const sub = args[0];
+        if (sub === "import") {
+          const gitPath = resolve5(cwd, args[1] || die("usage: sol git import <git-repo> [dir]"));
+          const target = resolve5(cwd, args[2] || basename2(gitPath));
+          const fdir = join19(target, ".sol");
+          if (existsSync18(fdir))
+            die("already a sol repo: " + target);
+          mkdirSync12(fdir, { recursive: true });
+          const { commits, branches, head, current } = await importGitRepo2(gitPath, fdir);
+          const refsBranches = {};
+          for (const b of branches)
+            refsBranches[b.name] = { head: b.head, base: b.head };
+          if (!refsBranches[current])
+            refsBranches[current] = { head, base: head };
+          refsBranches[current].head = head;
+          writeFileSync16(join19(fdir, "refs.json"), JSON.stringify({ current, branches: refsBranches, tags: {} }, null, 2));
+          const store2 = new Store;
+          for (const name of readdirSync9(join19(fdir, "objects"))) {
+            if (name.endsWith(".tmp"))
+              continue;
+            try {
+              store2.put(decodeObject(readFileSync18(join19(fdir, "objects", name))));
+            } catch {}
+          }
+          const onDisk = hydrate3(store2, head, target);
+          console.log(`imported ${commits} commit(s), ${branches.length} branch(es) from git -> ${args[2] || basename2(gitPath)} (${onDisk} files; on branch ${current})`);
+        } else if (sub === "export") {
+          const { log } = open();
+          const gitPath = resolve5(cwd, args[1] || die("usage: sol git export <git-repo> [-b branch]"));
+          const store2 = loadStore();
+          const head = await log.head() ?? "";
+          if (!head || !listAll(store2, head).length) {
+            die(`nothing to export — this Sol repo has no committed files yet. \`sol commit\` your work first, then \`sol git export ${args[1]}\`.`);
+          }
+          const bi = args.indexOf("-b");
+          const branch = bi >= 0 ? args[bi + 1] : (await loadRefs(log)).current || "main";
+          try {
+            const { commits, head: oid } = await exportHistoryToGit2(await log.history(), head, async (h) => store2.get(h), store2, gitPath, branch, loadTrust());
+            console.log(`exported ${commits} commit(s) -> refs/heads/${branch} @ ${oid.slice(0, 12)} in ${args[1]} (now \`git push\`)`);
+          } catch (e) {
+            die(e.message);
+          }
+        } else {
+          die("usage: sol git import <repo> [dir]   |   sol git export <repo> [-b branch]");
+        }
+        break;
+      }
+      case "view": {
+        const { log } = open();
+        if (readViewMeta(solDir))
+          die("already inside a view — create views from the parent repo (its `.sol` owns the shared store + op-log).");
+        const name = args.find((a) => !a.startsWith("-")) || die("usage: sol view <name> [dir]");
+        const rest = args.filter((a) => !a.startsWith("-"));
+        const defaultDir = join19(dirname6(cwd), `${basename2(cwd)}-${name}`);
+        const viewDir = rest[1] ? resolve5(procCwd, rest[1]) : defaultDir;
+        if (existsSync18(join19(viewDir, ".sol")))
+          die("already a sol repo/view: " + viewDir);
+        const branch = `view/${name}`;
+        const startHead = await log.head() ?? emptyRoot(loadStore());
+        const { createView: createView2, sharedObjectCount: sharedObjectCount2 } = await Promise.resolve().then(() => (init_views(), exports_views));
+        const { files } = createView2({ parentSol: solDir, viewDir, name, branch, actor, startHead });
+        const objN = sharedObjectCount2(solDir);
+        console.log(`created view '${name}' -> ${viewDir}`);
+        console.log(`  branch ${branch}  @ ${(startHead || "empty").slice(0, 12)}  (you: ${actor})`);
+        console.log(`  ${files} file(s) materialized; SHARING ${objN} object(s) from ${solDir} (zero copy — one store on disk)`);
+        console.log(`  -> cd ${viewDir} && edit + \`sol commit -m "..." <files>\`; converge with \`sol pull ${cwd}\` (or from the parent: \`sol pull ${viewDir}\`)`);
+        break;
+      }
+      case "views": {
+        if (!existsSync18(solDir))
+          die("not a sol repo");
+        const parentSol = parentSolDir(solDir) ?? solDir;
+        const { pruneViews: pruneViews2, viewStatuses: viewStatuses2, sharedObjectCount: sharedObjectCount2 } = await Promise.resolve().then(() => (init_views(), exports_views));
+        if (args[0] === "--prune" || args[0] === "prune") {
+          const named = args.slice(1).find((a) => !a.startsWith("-"));
+          const removed = pruneViews2(parentSol, { name: named, deleteDir: args.includes("--delete") });
+          console.log(removed.length ? `pruned ${removed.length} view(s): ${removed.join(", ")}` : "no views to prune");
+          break;
+        }
+        const views = await viewStatuses2(parentSol);
+        if (args.includes("--json")) {
+          console.log(JSON.stringify({ repo: parentSol, sharedObjects: sharedObjectCount2(parentSol), views }));
+          break;
+        }
+        if (!views.length) {
+          console.log("no views — create one with `sol view <name>` (a clone-free agent working tree sharing this store)");
+          break;
+        }
+        console.log(`views of ${parentSol}  (${sharedObjectCount2(parentSol)} SHARED object(s), one store on disk):`);
+        for (const v of views) {
+          const state = v.stale ? "STALE" : "active";
+          console.log(`  ${v.name.padEnd(16)} ${v.branch.padEnd(18)} ${(v.head || "empty").slice(0, 12)}  ${v.actor.padEnd(12)} [${state}]`);
+          console.log(`      ${v.dir}`);
+        }
+        console.log("  prune: `sol views --prune` (drop gone dirs) | `sol views --prune <name> [--delete]`");
+        break;
+      }
+      case "check": {
+        open();
+        const cd = cfgDir2();
+        const setIdx = args.indexOf("--set");
+        if (setIdx >= 0) {
+          const cmd2 = args[setIdx + 1] || die('usage: sol check --set "<command>"   (e.g. sol check --set "bun test")');
+          const cfg2 = loadSolConfig(cd);
+          cfg2.check = cmd2;
+          saveSolConfig(cd, cfg2);
+          console.log(`check command set: ${cmd2}
+  it runs automatically after a converging merge (pull/merge/push); \`sol check\` runs it now.`);
+          break;
+        }
+        if (args.includes("--clear")) {
+          const cfg2 = loadSolConfig(cd);
+          delete cfg2.check;
+          saveSolConfig(cd, cfg2);
+          clearSemanticFlag(solDir);
+          console.log("check command cleared (the convergence gate is now inert)");
+          break;
+        }
+        if (args.includes("--show")) {
+          const c = loadSolConfig(cd).check;
+          console.log(c ? `check: ${c}` : 'no check configured — set one with `sol check --set "<cmd>"`');
+          break;
+        }
+        const cfg = loadSolConfig(cd);
+        if (!cfg.check) {
+          if (args.includes("--json"))
+            console.log(JSON.stringify({ configured: false, ok: true }));
+          else
+            console.log('no check configured — set one with `sol check --set "<cmd>"` (e.g. `sol check --set "bun test"`)');
+          break;
+        }
+        const outcome = runCheck(cd, cwd);
+        if (outcome.ok)
+          clearSemanticFlag(solDir);
+        if (args.includes("--json")) {
+          console.log(JSON.stringify(outcome));
+        } else {
+          console.log(`check: ${cfg.check}`);
+          console.log(outcome.ok ? "PASS" : `FAIL (exit ${outcome.exitCode})`);
+          if (outcome.output)
+            console.log(outcome.output);
+        }
+        process.exitCode = outcome.ok ? 0 : 1;
+        break;
+      }
+      case "mcp": {
+        const http = await resolveMcpHttp2(args);
+        if (args.includes("--secret") || args.includes("--secrets")) {
+          const { startSecretMcp: startSecretMcp2 } = await Promise.resolve().then(() => (init_sol_secret_mcp(), exports_sol_secret_mcp));
+          await startSecretMcp2({ solDir, http });
+        } else {
+          const { startWorkspaceMcp: startWorkspaceMcp2 } = await Promise.resolve().then(() => (init_sol_mcp(), exports_sol_mcp));
+          await startWorkspaceMcp2({ solDir, http });
+        }
+        break;
+      }
+      case "env":
+      case "secret":
+      case "resolve": {
+        if (cmd === "secret" && args[0] === "mcp") {
+          const http = await resolveMcpHttp2(args.slice(1), "sol-secrets");
+          const { startSecretMcp: startSecretMcp2 } = await Promise.resolve().then(() => (init_sol_secret_mcp(), exports_sol_secret_mcp));
+          await startSecretMcp2({ solDir, http });
+          break;
+        }
+        if (!existsSync18(solDir))
+          die("not a sol repo — run `sol init` first");
+        const { runEnv: runEnv2, runSecret: runSecret2, resolveReference: resolveReference2 } = await Promise.resolve().then(() => (init_secret2(), exports_secret2));
+        const { loadSelfIdentity: loadSelfIdentity2, loadManageIdentity: loadManageIdentity2, fetchKey: fetchKey2 } = await Promise.resolve().then(() => (init_seal_audience(), exports_seal_audience));
+        const { loadIdentity: loadIdentity2 } = await Promise.resolve().then(() => (init_identity_store(), exports_identity_store));
+        const dirUrl = (process.env.SOL_REMOTE || DEFAULT_REMOTE_URL2).replace(/\/+$/, "");
+        const selfPub = (account) => {
+          const id = loadIdentity2();
+          return id && id.accountId === account ? id.x25519Pub : undefined;
+        };
+        const dirPub = async (account) => (await fetchKey2(dirUrl, account))?.x25519Pub;
+        const selfEdPub = (account) => {
+          const id = loadIdentity2();
+          return id && id.accountId === account ? id.edPub : undefined;
+        };
+        const dirEdPub = async (account) => (await fetchKey2(dirUrl, account))?.edPub;
+        const remoteAnchorVerify = async () => {
+          const rcfg = resolveRemote2(solDir);
+          const token = process.env.SOL_TOKEN || await loadStoredToken2();
+          if (!rcfg || !token)
+            return;
+          const { remoteEnvAnchor: remoteEnvAnchor2 } = await Promise.resolve().then(() => (init_remote(), exports_remote));
+          const { readEnvStateBundle: readEnvStateBundle2 } = await Promise.resolve().then(() => (init_anchor(), exports_anchor));
+          const { verifyLocalAgainstRemote: verifyLocalAgainstRemote2 } = await Promise.resolve().then(() => (init_env_state(), exports_env_state));
+          const { record } = await remoteEnvAnchor2(rcfg, token);
+          const local = readEnvStateBundle2(solDir) ?? { v: 1, journal: [], journalLen: 0 };
+          return verifyLocalAgainstRemote2(local, record ?? undefined);
+        };
+        const ctx = { solDir, actor, loadSelfIdentity: () => loadSelfIdentity2(), loadManageIdentity: () => loadManageIdentity2(), die, selfPub, dirPub, selfEdPub, dirEdPub, remoteAnchorVerify };
+        if (cmd === "env")
+          await runEnv2(ctx, args[0], args.slice(1));
+        else if (cmd === "secret")
+          await runSecret2(ctx, args[0], args.slice(1));
+        else {
+          const ei = args.indexOf("--env");
+          resolveReference2(ctx, args.filter((a) => !a.startsWith("-"))[0], ei >= 0 ? args[ei + 1] : undefined);
+        }
+        break;
+      }
+      default:
+        if (cmd && cmd !== "help" && cmd !== "-h" && cmd !== "--help") {
+          console.error("sol: unknown command: " + cmd + `
+`);
+          process.exitCode = 1;
+        }
+        console.log(`sol — local content-addressed VCS (the new git)
+
+the model: edit files freely, then commit — or run \`sol watch\` and every change is captured
+automatically. there is NO separate "git add".
+
+everyday (examples are copy-safe — use real filenames):
+  sol init                       create a repo in ./.sol
+  sol watch                      AUTO-CAPTURE every change (run once; nothing is ever lost)
+  sol run npm test               hydrate to a sandbox, run, capture outputs (--isolate to confine)
+  sol commit "what changed"      commit the whole tree (SINGLE-AUTHOR; -m "msg" file.ts scopes to files)
+  sol status                     current branch + uncommitted changes
+  sol log                        commit history              (sol log --all for every op)
+  sol diff                       working-tree changes        (sol diff main feature between refs)
+  sol show 5                     a commit's message + its diff
+  sol undo                       roll back the LAST commit (non-destructive — it stays in history, fsck OK)
+  sol revert <ref>               commit the inverse of any commit (like git revert; full history kept)
+  sol restore --from 3 app.py    put a file (or the whole tree) back from a ref
+  sol blame todo/cli.py          who/which commit last touched each line
+  sol ls / sol cat README.md   list tracked files / print one
+  sol rm old.txt                 delete a file (from the repo and disk)
+  sol ignore "*.tmp"             add an ignore pattern (no arg lists the active patterns)
+  sol fsck / sol gc            verify integrity / drop unreachable objects
+  sol check --set "bun test"     gate convergence on a test command: a merge that line-converges but FAILS
+                                 the check is flagged as a SEMANTIC conflict (status state:"SEMANTIC"), not
+                                 silently accepted. \`sol check\` runs it on demand. (sol check --help)
+
+per-agent authorship signing (CRYPTOGRAPHIC author identity — not the forgeable plaintext SOL_ACTOR):
+  sol keygen                     mint an Ed25519 keypair; prints SOL_SIGNING_KEY=<seed> + its fingerprint
+                                 the orchestrator gives each agent its OWN seed (SOL_SIGNING_KEY / a keyfile)
+                                 so every commit is signed AT authorship — log/show/blame show "signed <fp> ✓"
+  sol trust <name> <fingerprint> bind an actor name to a key; a commit claiming that name but signed by a
+                                 DIFFERENT key is then flagged FORGED (sol trust = list, --remove <name> = drop)
+
+privacy (native per-path encryption — the host only ever stores ciphertext):
+  sol hide "src/private/**"      ROLE-BASED hiding: a VisibilityPolicy rule "only \`write\`+ may decrypt this" —
+                                 the headline verb. \`sol seal <path>\` then seals to the resolved audience. (sol hide --help)
+  sol seal secrets/.env          NO recipients -> consult the policy for this path + seal to its audience
+  sol seal secrets/.env alice    explicit recipients (you + alice); keys stay LOCAL, history is host-blind
+                                 \`sol cat\` decrypts for a recipient; everyone else sees <<sealed>>. (sol seal --help)
+  sol seal secrets/.env @alice   CROSS-ACCOUNT: wrap to alice's PUBLISHED X25519 key — she opens it on her own
+                                 account, the host never holds a key (\`sol keys publish\` first). (sol seal --help)
+  sol seal --reapply             re-resolve every policy-covered seal + re-wrap to the CURRENT audience (bumps epoch)
+  sol sealed                     list every sealed path + its audience (recipient accounts + fingerprints + epoch)
+
+cross-account identity keys (host-blind: the directory holds PUBLIC keys only, never a private key or plaintext):
+  sol keys init                  mint your X25519 identity keypair; the recovery code is shown ONCE (back it up)
+  sol keys publish               publish your PUBLIC key so others can seal to you across accounts
+  sol keys rotate                roll to a new key epoch (past seals stay on the old epoch until reapplied)
+  sol keys verify <acct> <fpr>   confirm a peer's published key out-of-band before sealing to them (anti-MITM)
+  sol keys export / import       encrypted keystore backup. (sol keys --help)
+
+clone-free agent views (the worktree killer — N agents, one shared store on disk, zero duplication):
+  sol view <name> [dir]          new working tree + branch + index that SHARES this repo's object store
+                                 (git would need a full worktree per agent: node_modules/build duplicated, ~GBs,
+                                 and concurrent agents deadlock on .git/index.lock). commit in the view, then
+                                 \`sol pull <view>\` converges losslessly. (sol view --help)
+  sol views                      list every view (name, dir, branch, head, author, active/stale) + --prune
+
+branches & tags:
+  sol branch                     list branches (sol branch feature creates one at HEAD)
+  sol switch feature             switch to a branch (captures current work first, never loses it)
+  sol merge feature              3-way merge a branch in (conflicts land in the working tree)
+  sol tag v1                     mark an immutable label at HEAD
+
+auth (sign in once; remote commands then use the cached token, no SOL_TOKEN needed):
+  sol auth login [<web-url>]     device-flow sign-in via the Midsummer web app; caches the token ~/.sol/credentials
+  sol auth whoami                print the identity behind the cached token (signed in as @<handle>)
+  sol auth set-handle <name>     choose your @handle — the <owner> in <owner>/<repo> (changing it re-namespaces repos)
+  sol auth pat [days]            mint a long-lived Personal Access Token for git/CI (default 90 days)
+  sol auth status / logout       show who you're signed in as / clear the cached token
+
+remotes (self-hostable backend; token in SOL_TOKEN or via sol auth login):
+  sol clone [<url>] <owner>/<repo> [dir]   clone a remote repo (checks out PRODUCTION); default dir = <repo>
+  sol push / sol pull          sync your commits with the remote (push registers your branch's head)
+  sol push <repo>                one-step share: no remote set? use the hosted Sol + <repo>, then push
+  sol push --public <repo>       create + push + make public in one step (new repos are private by default)
+  sol promote [branch]         point the remote's production branch at <branch> (default: current)
+  sol remote <url> <repo>        set the remote (no arg: show it; url defaults to the hosted Sol)
+  sol fork [<url>] <parent> <new> [dir]   make your own copy of a repo (all branches + history + a parent link)
+  sol forks                      list the forks of the current repo
+  sol access [show|public|private|add <userId> <role>|remove <userId>]   manage repo visibility + collaborators
+
+merge requests (propose a branch's commits to merge; reviews + CI checks):
+  sol mr open [--from B] [--to B] -t "title" [-m body]   open an MR (from=current branch, to=production)
+  sol mr list                  list MRs (open/merged/closed)
+  sol mr show <id>             metadata, reviews/checks, + the diff it would merge
+  sol mr review <id> --approve | --request-changes | --comment [-m ...]
+  sol mr check <id> --run [--name N] -- <test cmd>       run the tests, report a pass/fail check
+  sol mr merge <id> [--force]  fast-forward-merge (gated on checks + reviews; --force overrides)
+  sol mr close <id>
+
+git interop (adopt Sol without leaving GitHub):
+  sol git import <repo> [dir]    import a git repo's HEAD into a new Sol repo (modes/symlinks/binaries)
+  sol git export <repo> [-b br]  replay the Sol commit DAG as git history (parents/merges/author/time + provenance trailers), then \`git push\`
+
+for concurrent agents, use scoped commits (sol commit -m "msg" file) or a per-agent workspace.
+a solo author commits the whole tree freely; once OTHER authors are present the whole-tree commit is refused
+(--whole-tree / SOL_ALLOW_WHOLE_TREE=1 to override) so one agent can't sweep everyone's pending files.
+
+a ref is a branch/tag name, a commit hash-prefix, an op seq number, or HEAD. content is SHA-256
+addressed; history is a tamper-evident hash-chained op-log. attribute changes with SOL_ACTOR=you.`);
+    }
+  } finally {
+    release?.();
+  }
+}
+async function runCli2(argv) {
+  try {
+    await dispatch2(argv);
+  } catch (e) {
+    const msg = e?.message || String(e);
+    if (/ -> 401\b/.test(msg) || /\b401 unauthorized\b/i.test(msg))
+      authExpired2();
+    die(msg);
+  }
+}
+var CRED_PATH2, DEFAULT_REMOTE_URL2, ATTEST_KEY2, remoteUrlArg2 = (a) => /^https?:\/\//.test(a[0] ?? "") ? [a[0].replace(/\/+$/, ""), a.slice(1)] : [DEFAULT_REMOTE_URL2, a], cfgDir2 = () => parentSolDir(solDir) ?? solDir;
+var init_dispatch2 = __esm(() => {
+  init_chain();
+  init_diff();
+  init_file_store();
+  init_prov();
+  init_store();
+  init_tree();
+  init_lib();
+  init_remote();
+  init_lib();
+  init_test_gate();
+  CRED_PATH2 = join19(homedir3(), ".sol", "credentials");
+  DEFAULT_REMOTE_URL2 = (process.env.SOL_REMOTE || "https://sol.midsummer.new").replace(/\/+$/, "");
+  ATTEST_KEY2 = process.env.SOL_ATTEST_KEY || undefined;
+});
+
+// src/bin/sol.ts
+import { readFileSync as readFileSync19 } from "fs";
+function cliVersion3() {
+  if (typeof __SOL_COMPILED_VERSION__ === "string" && __SOL_COMPILED_VERSION__)
+    return __SOL_COMPILED_VERSION__;
+  try {
+    return JSON.parse(readFileSync19(new URL("./package.json", import.meta.url), "utf8")).version || "dev";
+  } catch {
+    return "dev";
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
+    console.log(`sol ${cliVersion3()}`);
+    return;
+  }
+  const { runCli: runCli3 } = await Promise.resolve().then(() => (init_dispatch2(), exports_dispatch2));
+  await runCli3(argv);
 }
 main();