@use-aistack/cli 0.3.0 → 0.5.0

package/dist/index.js

@@ -3,14 +3,10 @@
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/login.ts
-import * as p2 from "@clack/prompts";
-import open from "open";
-
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
-async function request(path, options = {}) {
-  return fetch(`${BASE_URL}${path}`, {
+async function request(path2, options = {}) {
+  return fetch(`${BASE_URL}${path2}`, {
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -21,34 +17,37 @@ async function request(path, options = {}) {
 function authHeaders(token) {
   return { Authorization: `Bearer ${token}` };
 }
-async function authStart() {
-  const res = await request("/api/cli/auth/start", { method: "POST" });
-  if (!res.ok) throw new Error(`Auth start failed: ${res.status}`);
+function failure(what, res) {
+  if (res.status === 429) {
+    const retry = res.headers.get("Retry-After");
+    return new Error(
+      retry ? `${what}: too many requests. Try again in ${retry} seconds.` : `${what}: too many requests. Try again in a minute.`
+    );
+  }
+  if (res.status === 403) {
+    return new Error(
+      `${what}: this machine is not allowed to do that. Run \`aistack login\` again to re-link it.`
+    );
+  }
+  return new Error(`${what}: ${res.status}`);
+}
+async function authStart(machineName) {
+  const res = await request("/api/cli/auth/start", {
+    method: "POST",
+    body: JSON.stringify(machineName ? { machineName } : {})
+  });
+  if (!res.ok) throw failure("Auth start failed", res);
   return res.json();
 }
 async function authPoll(secretId) {
   const res = await request(
     `/api/cli/auth/poll?secretId=${encodeURIComponent(secretId)}`
   );
-  if (!res.ok) throw new Error(`Auth poll failed: ${res.status}`);
-  return res.json();
-}
-async function projectsCheck(token, name) {
-  const res = await request(
-    `/api/cli/projects/check?name=${encodeURIComponent(name)}`,
-    {
-      headers: authHeaders(token)
-    }
-  );
-  if (res.status === 401)
-    throw new Error(
-      "Authentication expired. Run `npx @use-aistack/cli login` again."
-    );
-  if (!res.ok) throw new Error(`Project check failed: ${res.status}`);
+  if (!res.ok) throw failure("Auth poll failed", res);
   return res.json();
 }
-async function projectsCollect(token, data) {
-  const res = await request("/api/cli/projects/collect", {
+async function stackCollect(token, data) {
+  const res = await request("/api/cli/stacks/collect", {
     method: "POST",
     headers: authHeaders(token),
     body: JSON.stringify(data)
@@ -64,44 +63,187 @@ async function projectsCollect(token, data) {
 }
 async function formatHttpError(res, label) {
   const prefix = `${label}: ${res.status} ${res.statusText || ""}`.trim();
-  const text2 = await res.text().catch(() => "");
-  if (!text2) return prefix;
+  const text = await res.text().catch(() => "");
+  if (!text) return prefix;
   try {
-    const body = JSON.parse(text2);
+    const body = JSON.parse(text);
     const detail = body.error || body.message;
     if (detail) return `${prefix} \u2014 ${detail}`;
   } catch {
   }
-  const snippet = text2.trim().slice(0, 500);
+  const snippet = text.trim().slice(0, 500);
   return snippet ? `${prefix} \u2014 ${snippet}` : prefix;
 }
-async function projectGet(shortId) {
-  const res = await request(`/api/cli/projects/${encodeURIComponent(shortId)}`);
+async function syncPublish(token, bodyJson) {
+  const res = await request("/api/cli/sync", {
+    method: "POST",
+    headers: authHeaders(token),
+    body: bodyJson
+  });
+  if (res.status === 401)
+    throw new Error(
+      "Authentication expired. Run `npx @use-aistack/cli login` again."
+    );
+  if (res.status === 403 || res.status === 429)
+    throw failure("Sync failed", res);
+  if (!res.ok) {
+    throw new Error(await formatHttpError(res, "Sync failed"));
+  }
+  return res.json();
+}
+async function stackGet(token) {
+  const res = await request("/api/cli/stacks", {
+    headers: authHeaders(token)
+  });
+  if (res.status === 401)
+    throw new Error(
+      "Authentication expired. Run `npx @use-aistack/cli login` again."
+    );
   if (res.status === 404) return null;
-  if (!res.ok) throw new Error(`Project fetch failed: ${res.status}`);
+  if (!res.ok) throw failure("Stack fetch failed", res);
   return res.json();
 }
 
+// src/commands/collect.ts
+import * as p2 from "@clack/prompts";
+
+// src/classifier.ts
+import { basename, dirname } from "path";
+
+// src/stableKey.ts
+function computeStableKey(group, type, relPath) {
+  return `${group}:${type}:${relPath}`;
+}
+
+// src/classifier.ts
+function classify(files) {
+  const groups = /* @__PURE__ */ new Map();
+  const singletons = [];
+  const singletonRoots = /* @__PURE__ */ new Set([
+    ".",
+    "~",
+    "~/.claude",
+    "~/.cursor",
+    "~/.continue",
+    ".claude",
+    ".cursor",
+    ".github"
+  ]);
+  for (const file of files) {
+    const dir = dirname(file.relativePath);
+    const isSingleton = singletonRoots.has(dir);
+    if (isSingleton) {
+      singletons.push(file);
+    } else {
+      const key = `${file.group}:${file.source}:${file.type}:${dir}`;
+      const existing = groups.get(key) ?? [];
+      existing.push(file);
+      groups.set(key, existing);
+    }
+  }
+  const items = [];
+  for (const file of singletons) {
+    const relPath = file.relativePath.replace(/^~\/\.[^/]+\//, "").replace(/^\.[^/]+\//, "");
+    items.push({
+      type: file.type,
+      name: file.relativePath,
+      group: file.group,
+      stableKey: computeStableKey(file.group, file.type, relPath),
+      files: [
+        {
+          name: basename(file.relativePath),
+          content: file.content,
+          path: file.relativePath
+        }
+      ]
+    });
+  }
+  for (const [, groupFiles] of groups) {
+    const first = groupFiles[0];
+    const dir = dirname(first.relativePath);
+    const relPath = dir.replace(/^~\/\.claude\//, "").replace(/^\.claude\//, "").replace(/^~\/\.cursor\//, "").replace(/^\.cursor\//, "");
+    const typeLabel = first.type === "subagent" ? "subagents" : `${first.type}s`;
+    items.push({
+      type: first.type,
+      name: dir,
+      description: `${groupFiles.length} ${typeLabel}`,
+      group: first.group,
+      stableKey: computeStableKey(first.group, first.type, relPath),
+      files: groupFiles.map((f) => ({
+        name: basename(f.relativePath),
+        content: f.content,
+        path: f.relativePath
+      }))
+    });
+  }
+  return items;
+}
+
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { dirname as dirname2, join } from "path";
 var CONFIG_DIR = join(homedir(), ".config", "aistack");
 var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
-function getToken() {
-  if (!existsSync(CREDENTIALS_FILE)) return null;
+var DEFAULT_SERVER_URL = "https://aistack.to";
+function readCredentials(file) {
+  const empty = { data: { servers: {} }, legacy: false };
+  if (!existsSync(file)) return empty;
   try {
-    const data = JSON.parse(
-      readFileSync(CREDENTIALS_FILE, "utf-8")
-    );
-    return data.token ?? null;
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    if (!raw || typeof raw !== "object") return empty;
+    if (raw.servers && typeof raw.servers === "object") {
+      return {
+        data: { servers: raw.servers },
+        legacy: false
+      };
+    }
+    if (typeof raw.token === "string" && raw.token) {
+      return {
+        data: {
+          servers: {
+            [DEFAULT_SERVER_URL]: { token: raw.token, userId: raw.userId }
+          }
+        },
+        legacy: true
+      };
+    }
+    return { data: { servers: {} }, legacy: true };
   } catch {
-    return null;
+    return empty;
   }
 }
-function saveToken(token, userId) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CREDENTIALS_FILE, JSON.stringify({ token, userId }, null, 2));
+function writeCredentials(file, data) {
+  mkdirSync(dirname2(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(data, null, 2));
+}
+function getToken(serverUrl = BASE_URL, file = CREDENTIALS_FILE) {
+  const { data, legacy } = readCredentials(file);
+  if (legacy) writeCredentials(file, data);
+  return data.servers[serverUrl]?.token ?? null;
+}
+function saveToken(token, userId, serverUrl = BASE_URL, file = CREDENTIALS_FILE) {
+  const { data } = readCredentials(file);
+  data.servers[serverUrl] = { token, userId };
+  writeCredentials(file, data);
+}
+var SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
+var DEFAULT_FREQUENCY_HOURS = 24;
+function getSettings(file = SETTINGS_FILE) {
+  if (!existsSync(file)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    return raw && typeof raw === "object" ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function saveSettings(patch, file = SETTINGS_FILE) {
+  mkdirSync(dirname2(file), { recursive: true });
+  writeFileSync(
+    file,
+    JSON.stringify({ ...getSettings(file), ...patch }, null, 2)
+  );
 }
 var PROJECTS_FILE = join(CONFIG_DIR, "projects.json");
 function readProjects() {
@@ -111,9 +253,10 @@ function readProjects() {
     const data = {};
     for (const [key, value] of Object.entries(raw)) {
       if (typeof value === "string") {
-        data[key] = { name: value };
-      } else {
-        data[key] = value;
+        data[key] = {};
+      } else if (value && typeof value === "object") {
+        const excluded = value.excluded;
+        data[key] = Array.isArray(excluded) ? { excluded } : {};
       }
     }
     return data;
@@ -125,160 +268,486 @@ function writeProjects(data) {
   mkdirSync(CONFIG_DIR, { recursive: true });
   writeFileSync(PROJECTS_FILE, JSON.stringify(data, null, 2));
 }
-function getProjectName(directory) {
-  return readProjects()[directory]?.name ?? null;
-}
 function getExcludedPaths(directory) {
   return readProjects()[directory]?.excluded ?? [];
 }
-function saveProjectSettings(directory, name, excluded) {
+function saveExcludedPaths(directory, excluded) {
   const data = readProjects();
   data[directory] = {
-    name,
     excluded: excluded.length > 0 ? excluded : void 0
   };
   writeProjects(data);
 }
 
-// src/theme.ts
-import * as p from "@clack/prompts";
-var esc = (code) => `\x1B[${code}m`;
-var reset = esc("0");
-var LIME = "163;230;53";
-var BLACK = "0;0;0";
-var YELLOW = "250;204;21";
-var RED = "248;113;113";
-var MUTED = "120;120;120";
-var lime = (s) => `${esc(`38;2;${LIME}`)}${s}${reset}`;
-var limeBold = (s) => `${esc("1")}${esc(`38;2;${LIME}`)}${s}${reset}`;
-var bgLime = (s) => `${esc(`48;2;${LIME}`)}${esc(`38;2;${BLACK}`)}${s}${reset}`;
-var yellow = (s) => `${esc(`38;2;${YELLOW}`)}${s}${reset}`;
-var red = (s) => `${esc(`38;2;${RED}`)}${s}${reset}`;
-var dim = (s) => `${esc(`38;2;${MUTED}`)}${s}${reset}`;
-var bold = (s) => `${esc("1")}${s}${reset}`;
-var banner = (cmd) => `${lime("\u25A0")} ${bgLime(` AISTACK `)} ${bold(cmd.toUpperCase())}`;
-var BAR = `${esc(`38;2;${MUTED}`)}\u2502${reset}`;
-function lines(items) {
-  for (const item of items) {
-    console.log(`${BAR}  ${item}`);
+// src/git.ts
+import { execFileSync } from "child_process";
+
+// src/github-repo.ts
+function isGithubHost(host) {
+  const h = host.toLowerCase();
+  return h === "github.com" || h === "www.github.com";
+}
+function parseRepo(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const scpMatch = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
+  let host;
+  let withoutHost;
+  if (scpMatch) {
+    host = scpMatch[1];
+    withoutHost = scpMatch[2];
+  } else {
+    const withoutScheme = trimmed.replace(/^[a-z]+:\/\//i, "");
+    const slash = withoutScheme.indexOf("/");
+    if (slash === -1) return null;
+    host = withoutScheme.slice(0, slash);
+    withoutHost = withoutScheme.slice(slash + 1);
   }
+  if (!isGithubHost(host)) return null;
+  const pathPart = withoutHost.replace(/[?#].*$/, "");
+  const segments = pathPart.split("/").filter(Boolean);
+  const owner = segments[0];
+  const repo = segments[1]?.replace(/\.git$/, "");
+  if (!owner || !repo) return null;
+  return { owner: owner.toLowerCase(), repo: repo.toLowerCase() };
 }
-function section(label, count) {
-  console.log(`${BAR}`);
-  const countStr = count !== void 0 ? ` ${dim(String(count))}` : "";
-  console.log(`${BAR}  ${bold(label.toUpperCase())}${countStr}`);
+function canonicalizeRepoUrl(input) {
+  const parsed = parseRepo(input);
+  if (!parsed) return null;
+  return `https://github.com/${parsed.owner}/${parsed.repo}`;
 }
-function divider() {
-  console.log(`${BAR}  ${dim("\u2500".repeat(40))}`);
+function repoNameFromCanonical(canonical) {
+  return parseRepo(canonical)?.repo ?? "";
 }
-function intro2(cmd) {
-  console.log();
-  p.intro(banner(cmd));
+function normalizeUpstreamPath(path2) {
+  if (!path2) return "";
+  return path2.split("/").filter(Boolean).join("/");
 }
-function outro2(msg) {
-  p.outro(msg);
-  console.log();
+
+// src/git.ts
+var defaultGitRemoteRunner = (cwd) => {
+  try {
+    return execFileSync("git", ["-C", cwd, "remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+};
+function detectRepoUrl(cwd, run = defaultGitRemoteRunner) {
+  const raw = run(cwd);
+  if (!raw) return null;
+  return canonicalizeRepoUrl(raw);
 }
-function outroError(msg) {
-  p.outro(red(msg));
-  console.log();
+function buildLinkResource(spec) {
+  const normPath = normalizeUpstreamPath(spec.path);
+  return {
+    type: spec.type,
+    name: spec.name,
+    group: spec.group,
+    stableKey: `linked:${spec.canonical}:${normPath}`,
+    upstream: {
+      repoUrl: spec.canonical,
+      ...normPath ? { path: normPath } : {},
+      ...spec.sha ? { lastCommitSha: spec.sha } : {}
+    }
+  };
 }
-function outroCancel(msg = "cancelled") {
-  p.cancel(dim(msg));
-  console.log();
+function buildRepoLinkResource(canonical) {
+  return buildLinkResource({
+    canonical,
+    name: repoNameFromCanonical(canonical),
+    type: "custom",
+    group: "generic"
+  });
 }
-function outroSkipped(msg) {
-  p.outro(dim(msg));
-  console.log();
+
+// src/hooks.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function readJson(path2) {
+  try {
+    if (!existsSync2(path2)) return null;
+    return JSON.parse(readFileSync2(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function hooksFrom(path2, source, out, seen) {
+  const hooks = readJson(path2)?.hooks;
+  if (!hooks || typeof hooks !== "object") return;
+  for (const [event, config] of Object.entries(hooks)) {
+    const stableKey = `hooks:${source}:${event}`;
+    if (seen.has(stableKey)) continue;
+    seen.add(stableKey);
+    out.push({
+      type: "hook",
+      name: event,
+      group: "claude-code",
+      stableKey,
+      files: [
+        {
+          name: `${event}.json`,
+          content: JSON.stringify(config, null, 2),
+          path: `hooks/${event}.json`
+        }
+      ]
+    });
+  }
+}
+function detectHooks(cwd, home = homedir2()) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  hooksFrom(join2(cwd, ".claude", "settings.json"), "local", out, seen);
+  hooksFrom(join2(cwd, ".claude", "settings.local.json"), "local", out, seen);
+  hooksFrom(join2(home, ".claude", "settings.json"), "global", out, seen);
+  return out;
 }
 
-// src/commands/login.ts
-async function loginCommand() {
-  intro2("login");
-  const s = p2.spinner();
-  s.start("Starting authentication...");
-  let session;
+// src/mcp.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3, platform } from "os";
+import { join as join3 } from "path";
+import { parse as parseToml } from "smol-toml";
+import { parse as parseYaml } from "yaml";
+function commandName(cmd) {
+  return cmd.replace(/\\/g, "/").split("/").pop() ?? cmd;
+}
+function splitVersion(spec) {
+  const at = spec.indexOf("@", spec.startsWith("@") ? 1 : 0);
+  if (at <= 0) return { id: spec };
+  return { id: spec.slice(0, at), version: spec.slice(at + 1) || void 0 };
+}
+function firstPositional(args, skip = 0) {
+  for (const a of args.slice(skip)) {
+    if (!a.startsWith("-")) return a;
+  }
+  return void 0;
+}
+var CONTAINER_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-e",
+  "--env",
+  "-v",
+  "--volume",
+  "-p",
+  "--publish",
+  "-w",
+  "--workdir",
+  "--name",
+  "--mount",
+  "--network",
+  "-u",
+  "--user",
+  "-l",
+  "--label"
+]);
+function containerImage(args) {
+  const runIdx = args.indexOf("run");
+  const rest = runIdx >= 0 ? args.slice(runIdx + 1) : args;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a.startsWith("-")) {
+      if (CONTAINER_VALUE_FLAGS.has(a) && !a.includes("=")) i++;
+      continue;
+    }
+    return a;
+  }
+  return void 0;
+}
+function splitImageTag(image) {
+  const colon = image.lastIndexOf(":");
+  if (colon > 0 && !image.slice(colon + 1).includes("/")) {
+    return { id: image.slice(0, colon), version: image.slice(colon + 1) };
+  }
+  return { id: image };
+}
+function parseMcpPackage(server) {
+  if (server.url) {
+    const t = (server.type ?? server.transport ?? "").toLowerCase();
+    return {
+      registry: "url",
+      id: server.url,
+      transport: t === "sse" ? "sse" : "http"
+    };
+  }
+  const command = server.command ? commandName(server.command) : "";
+  if (!command) return null;
+  const args = server.args ?? [];
+  if (command === "npx" || command === "bunx" || command === "pnpx") {
+    const spec = firstPositional(args);
+    return spec ? { registry: "npm", ...splitVersion(spec), transport: "stdio" } : null;
+  }
+  if ((command === "pnpm" || command === "yarn") && args[0] === "dlx") {
+    const spec = firstPositional(args, 1);
+    return spec ? { registry: "npm", ...splitVersion(spec), transport: "stdio" } : null;
+  }
+  if (command === "uvx") {
+    const spec = firstPositional(args);
+    return spec ? { registry: "pypi", ...splitVersion(spec), transport: "stdio" } : null;
+  }
+  if (command === "pipx" && args[0] === "run") {
+    const spec = firstPositional(args, 1);
+    return spec ? { registry: "pypi", ...splitVersion(spec), transport: "stdio" } : null;
+  }
+  if (command === "uv" && args[0] === "tool" && args[1] === "run") {
+    const spec = firstPositional(args, 2);
+    return spec ? { registry: "pypi", ...splitVersion(spec), transport: "stdio" } : null;
+  }
+  if (/^python[0-9.]*$/.test(command)) {
+    const i = args.indexOf("-m");
+    const mod = i >= 0 ? args[i + 1] : void 0;
+    return mod ? { registry: "pypi", id: mod, transport: "stdio" } : null;
+  }
+  if (command === "docker" || command === "podman") {
+    const image = containerImage(args);
+    if (!image) return null;
+    return { registry: "oci", ...splitImageTag(image), transport: "stdio" };
+  }
+  return null;
+}
+function buildMcpResource(name, group, pkg) {
+  return {
+    type: "mcp",
+    name,
+    group,
+    stableKey: `linked:pkg:${pkg.registry}:${pkg.id}`,
+    pkg
+  };
+}
+function readText(path2) {
   try {
-    session = await authStart();
-    s.stop("Session created");
-  } catch (err) {
-    s.stop("Failed to start authentication");
-    p2.log.error(err instanceof Error ? err.message : String(err));
-    outroError("error");
-    process.exit(1);
+    if (!existsSync3(path2)) return null;
+    return readFileSync3(path2, "utf-8");
+  } catch {
+    return null;
   }
-  p2.log.info(`${dim("CODE")} ${limeBold(session.userCode)}`);
-  p2.log.info(`${dim("OPEN")} ${dim(session.authUrl)}`);
+}
+function readParsed(path2, parse) {
+  const raw = readText(path2);
+  if (raw === null) return null;
   try {
-    await open(session.authUrl);
+    return parse(raw);
   } catch {
-    p2.log.warn(
-      "Could not open browser automatically. Please visit the URL above."
+    return null;
+  }
+}
+function readJson2(path2) {
+  return readParsed(path2, JSON.parse);
+}
+function readYaml(path2) {
+  return readParsed(path2, parseYaml);
+}
+function readToml(path2) {
+  return readParsed(path2, parseToml);
+}
+function continueListToMap(file) {
+  if (!file?.mcpServers?.length) return void 0;
+  const map = {};
+  file.mcpServers.forEach((s, i) => {
+    map[s.name ?? `server-${i}`] = s;
+  });
+  return map;
+}
+function vscodeGlobalStorageBases(home) {
+  const apps = ["Code", "Code - OSS", "VSCodium"];
+  let root;
+  if (platform() === "darwin") {
+    root = join3(home, "Library", "Application Support");
+  } else if (platform() === "win32") {
+    root = process.env.APPDATA ?? join3(home, "AppData", "Roaming");
+  } else {
+    root = process.env.XDG_CONFIG_HOME ?? join3(home, ".config");
+  }
+  return apps.map((app) => join3(root, app, "User", "globalStorage"));
+}
+function detectMcpServers(cwd, home = homedir3()) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (servers, group) => {
+    for (const [name, cfg] of Object.entries(servers ?? {})) {
+      const pkg = parseMcpPackage(cfg);
+      if (!pkg) continue;
+      const resource = buildMcpResource(name, group, pkg);
+      if (seen.has(resource.stableKey)) continue;
+      seen.add(resource.stableKey);
+      out.push(resource);
+    }
+  };
+  add(readJson2(join3(cwd, ".mcp.json"))?.mcpServers, "claude-code");
+  add(readJson2(join3(cwd, "mcp.json"))?.mcpServers, "generic");
+  add(
+    readJson2(join3(cwd, ".cursor", "mcp.json"))?.mcpServers,
+    "cursor"
+  );
+  add(readJson2(join3(cwd, ".vscode", "mcp.json"))?.servers, "generic");
+  add(
+    readJson2(join3(cwd, "claude_desktop_config.json"))?.mcpServers,
+    "claude-desktop"
+  );
+  for (const file of listYamlFiles(join3(cwd, ".continue", "mcpServers"))) {
+    add(continueListToMap(readYaml(file)), "continue");
+  }
+  add(readJson2(join3(cwd, ".roo", "mcp.json"))?.mcpServers, "roo");
+  const claudeJson = readJson2(join3(home, ".claude.json"));
+  add(claudeJson?.projects?.[cwd]?.mcpServers, "claude-code");
+  add(claudeJson?.mcpServers, "claude-code");
+  add(
+    readJson2(join3(home, ".cursor", "mcp.json"))?.mcpServers,
+    "cursor"
+  );
+  add(
+    readJson2(join3(home, ".codeium", "windsurf", "mcp_config.json"))?.mcpServers,
+    "windsurf"
+  );
+  for (const base of vscodeGlobalStorageBases(home)) {
+    add(
+      readJson2(
+        join3(
+          base,
+          "saoudrizwan.claude-dev",
+          "settings",
+          "cline_mcp_settings.json"
+        )
+      )?.mcpServers,
+      "cline"
+    );
+    add(
+      readJson2(
+        join3(
+          base,
+          "rooveterinaryinc.roo-cline",
+          "settings",
+          "mcp_settings.json"
+        )
+      )?.mcpServers,
+      "roo"
     );
   }
-  s.start("Waiting for approval...");
-  const maxAttempts = 36;
-  for (let i = 0; i < maxAttempts; i++) {
-    await new Promise((resolve) => setTimeout(resolve, 5e3));
-    try {
-      const result = await authPoll(session.secretId);
-      if (result.status === "approved" && result.token) {
-        s.stop(lime("Authenticated"));
-        saveToken(result.token, result.userId);
-        p2.log.success(
-          `Token saved. Run ${limeBold("npx @use-aistack/cli collect")} to get started.`
-        );
-        outro2(lime("done"));
-        return;
-      }
-      if (result.status === "expired") {
-        s.stop("Session expired");
-        p2.log.error("Authentication session expired. Please try again.");
-        outroError("expired");
-        process.exit(1);
-      }
-    } catch (err) {
-      s.stop("Error polling");
-      p2.log.error(err instanceof Error ? err.message : String(err));
-      outroError("error");
-      process.exit(1);
-    }
+  for (const file of listYamlFiles(join3(home, ".continue", "mcpServers"))) {
+    add(continueListToMap(readYaml(file)), "continue");
+  }
+  add(
+    readJson2(join3(home, ".gemini", "settings.json"))?.mcpServers,
+    "gemini"
+  );
+  add(
+    readToml(join3(home, ".codex", "config.toml"))?.mcp_servers,
+    "codex"
+  );
+  return out;
+}
+function listYamlFiles(dir) {
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => join3(dir, f));
+  } catch {
+    return [];
   }
-  s.stop("Timed out");
-  p2.log.error("Authentication timed out after 3 minutes. Please try again.");
-  outroError("timed out");
-  process.exit(1);
 }
 
-// src/commands/collect.ts
-import * as p3 from "@clack/prompts";
-import { basename as basename2 } from "path";
+// src/plugins.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function marketplaceRepoUrl(mp) {
+  const src = mp?.source;
+  if (!src) return null;
+  if (src.repo) return `https://github.com/${src.repo}`;
+  return src.url ?? null;
+}
+function resolveSource(entry, mpRepoUrl) {
+  const src = entry.source;
+  if (typeof src === "string") {
+    if (!mpRepoUrl) return null;
+    const path2 = src.replace(/^\.\//, "").replace(/\/+$/, "");
+    return { url: mpRepoUrl, path: path2 || void 0 };
+  }
+  if (src && typeof src === "object" && src.url) {
+    return { url: src.url, path: src.path, sha: src.sha };
+  }
+  const fallback = entry.repository ?? entry.homepage ?? mpRepoUrl;
+  return fallback ? { url: fallback } : null;
+}
+function resolvePluginLinks(installed, marketplaces, manifests) {
+  const out = [];
+  for (const [key, entries] of Object.entries(installed.plugins ?? {})) {
+    const at = key.lastIndexOf("@");
+    if (at <= 0) continue;
+    const pluginName = key.slice(0, at);
+    const marketplace = key.slice(at + 1);
+    const mpRepoUrl = marketplaceRepoUrl(marketplaces[marketplace]);
+    const entry = manifests[marketplace]?.plugins?.find(
+      (p8) => p8.name === pluginName
+    );
+    if (!entry) continue;
+    const resolved = resolveSource(entry, mpRepoUrl);
+    if (!resolved) continue;
+    const canonical = canonicalizeRepoUrl(resolved.url);
+    if (!canonical) continue;
+    out.push(
+      buildLinkResource({
+        canonical,
+        path: resolved.path,
+        name: pluginName,
+        type: "plugin",
+        group: "claude-code",
+        sha: resolved.sha ?? entries[0]?.gitCommitSha
+      })
+    );
+  }
+  return out;
+}
+function readJson3(path2) {
+  try {
+    if (!existsSync4(path2)) return null;
+    return JSON.parse(readFileSync4(path2, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectInstalledPlugins(pluginsDir = join4(homedir4(), ".claude", "plugins")) {
+  const installed = readJson3(
+    join4(pluginsDir, "installed_plugins.json")
+  );
+  if (!installed?.plugins) return [];
+  const marketplaces = readJson3(join4(pluginsDir, "known_marketplaces.json")) ?? {};
+  const manifests = {};
+  for (const key of Object.keys(installed.plugins)) {
+    const mp = key.slice(key.lastIndexOf("@") + 1);
+    if (!mp || manifests[mp]) continue;
+    const installLocation = marketplaces[mp]?.installLocation ?? join4(pluginsDir, "marketplaces", mp);
+    const manifest = readJson3(
+      join4(installLocation, ".claude-plugin", "marketplace.json")
+    );
+    if (manifest) manifests[mp] = manifest;
+  }
+  return resolvePluginLinks(installed, marketplaces, manifests);
+}
 
 // src/scanner.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join2, relative } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5, relative } from "path";
 import ignore from "ignore";
 var MAX_FILE_SIZE = 100 * 1024;
 var LOCAL_PATTERNS = [
   // Rules
   { path: "CLAUDE.md", type: "rule", group: "claude-code" },
   { path: "AGENTS.md", type: "rule", group: "claude-code" },
+  { path: "GEMINI.md", type: "rule", group: "gemini" },
   { path: ".cursorrules", type: "rule", group: "cursor" },
   { path: ".windsurfrules", type: "rule", group: "windsurf" },
   { path: ".clinerules", type: "rule", group: "cline" },
+  { path: ".roorules", type: "rule", group: "roo" },
   { path: ".github/copilot-instructions.md", type: "rule", group: "copilot" },
-  // MCP
-  { path: "mcp.json", type: "mcp", group: "generic" },
-  { path: ".cursor/mcp.json", type: "mcp", group: "cursor" },
-  {
-    path: "claude_desktop_config.json",
-    type: "mcp",
-    group: "claude-desktop"
-  },
+  // MCP servers are detected separately as pkg-reference links (see mcp.ts) —
+  // their config files are intentionally NOT collected as content here (which
+  // would also upload `env` secrets).
   // Config
   { path: ".aider.conf.yml", type: "config", group: "aider" },
   { path: ".continue/config.json", type: "config", group: "continue" },
+  { path: ".continue/config.yaml", type: "config", group: "continue" },
   { path: ".claude/settings.json", type: "config", group: "claude-code" },
   {
     path: ".claude/settings.local.json",
@@ -290,6 +759,11 @@ var LOCAL_PATTERNS = [
 ];
 var LOCAL_DIR_PATTERNS = [
   { dir: ".cursor/rules", type: "rule", group: "cursor" },
+  { dir: ".clinerules", type: "rule", group: "cline" },
+  { dir: ".windsurf/rules", type: "rule", group: "windsurf" },
+  { dir: ".roo/rules", type: "rule", group: "roo" },
+  { dir: ".github/instructions", type: "rule", group: "copilot" },
+  { dir: ".github/prompts", type: "prompt", group: "copilot" },
   { dir: ".claude/commands", type: "command", group: "claude-code" },
   { dir: ".claude/agents", type: "subagent", group: "claude-code" },
   { dir: ".claude/hooks", type: "hook", group: "claude-code" },
@@ -298,28 +772,28 @@ var LOCAL_DIR_PATTERNS = [
 ];
 function loadGitignore(cwd) {
   const ig = ignore();
-  const gitignorePath = join2(cwd, ".gitignore");
-  if (existsSync2(gitignorePath)) {
-    ig.add(readFileSync2(gitignorePath, "utf-8"));
+  const gitignorePath = join5(cwd, ".gitignore");
+  if (existsSync5(gitignorePath)) {
+    ig.add(readFileSync5(gitignorePath, "utf-8"));
   }
   ig.add(["node_modules", ".git", "dist", "build", ".next", ".output"]);
   return ig;
 }
 function readFileSafe(filePath) {
   try {
-    const stat = statSync(filePath);
-    if (stat.size > MAX_FILE_SIZE) return null;
-    return readFileSync2(filePath, "utf-8");
+    const stat2 = statSync(filePath);
+    if (stat2.size > MAX_FILE_SIZE) return null;
+    return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 function walkDir(dir, maxDepth = 3, currentDepth = 0) {
-  if (currentDepth >= maxDepth || !existsSync2(dir)) return [];
+  if (currentDepth >= maxDepth || !existsSync5(dir)) return [];
   const results = [];
   try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const fullPath = join2(dir, entry.name);
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      const fullPath = join5(dir, entry.name);
       if (entry.isFile()) {
         results.push(fullPath);
       } else if (entry.isDirectory()) {
@@ -334,7 +808,7 @@ function scanLocal(cwd) {
   const ig = loadGitignore(cwd);
   const results = [];
   for (const pattern of LOCAL_PATTERNS) {
-    const filePath = join2(cwd, pattern.path);
+    const filePath = join5(cwd, pattern.path);
     const content = readFileSafe(filePath);
     if (content !== null) {
       const rel = relative(cwd, filePath);
@@ -351,7 +825,7 @@ function scanLocal(cwd) {
     }
   }
   for (const { dir, type, group } of LOCAL_DIR_PATTERNS) {
-    const dirPath = join2(cwd, dir);
+    const dirPath = join5(cwd, dir);
     const files = walkDir(dirPath);
     for (const filePath of files) {
       const rel = relative(cwd, filePath);
@@ -370,11 +844,11 @@ function scanLocal(cwd) {
     }
   }
   try {
-    for (const entry of readdirSync(cwd, { withFileTypes: true }).filter(
+    for (const entry of readdirSync2(cwd, { withFileTypes: true }).filter(
       (e) => e.isDirectory()
     )) {
       if (ig.ignores(entry.name + "/")) continue;
-      scanSkillDirs(join2(cwd, entry.name), cwd, ig, results, 1);
+      scanSkillDirs(join5(cwd, entry.name), cwd, ig, results, 1);
     }
   } catch {
   }
@@ -382,8 +856,8 @@ function scanLocal(cwd) {
 }
 function scanSkillDirs(dir, cwd, ig, results, depth) {
   if (depth > 3) return;
-  const skillMd = join2(dir, "SKILL.md");
-  if (existsSync2(skillMd)) {
+  const skillMd = join5(dir, "SKILL.md");
+  if (existsSync5(skillMd)) {
     const files = walkDir(dir, 1);
     for (const filePath of files) {
       const rel = relative(cwd, filePath);
@@ -403,11 +877,11 @@ function scanSkillDirs(dir, cwd, ig, results, depth) {
     return;
   }
   try {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        const rel = relative(cwd, join2(dir, entry.name));
+        const rel = relative(cwd, join5(dir, entry.name));
         if (!ig.ignores(rel + "/")) {
-          scanSkillDirs(join2(dir, entry.name), cwd, ig, results, depth + 1);
+          scanSkillDirs(join5(dir, entry.name), cwd, ig, results, depth + 1);
         }
       }
     }
@@ -415,17 +889,25 @@ function scanSkillDirs(dir, cwd, ig, results, depth) {
   }
 }
 function scanGlobal() {
-  const home = homedir2();
+  const home = homedir5();
   const results = [];
   const globalPatterns = [
     { path: ".claude/CLAUDE.md", type: "rule", group: "claude-code" },
     { path: ".claude/settings.json", type: "config", group: "claude-code" },
-    { path: ".cursor/mcp.json", type: "mcp", group: "cursor" },
     { path: ".continue/config.json", type: "config", group: "continue" },
-    { path: ".aider.conf.yml", type: "config", group: "aider" }
+    { path: ".continue/config.yaml", type: "config", group: "continue" },
+    { path: ".aider.conf.yml", type: "config", group: "aider" },
+    { path: ".gemini/GEMINI.md", type: "rule", group: "gemini" },
+    { path: ".gemini/settings.json", type: "config", group: "gemini" },
+    { path: ".codex/config.toml", type: "config", group: "codex" },
+    {
+      path: ".codeium/windsurf/memories/global_rules.md",
+      type: "rule",
+      group: "windsurf"
+    }
   ];
   for (const pattern of globalPatterns) {
-    const filePath = join2(home, pattern.path);
+    const filePath = join5(home, pattern.path);
     const content = readFileSafe(filePath);
     if (content !== null) {
       results.push({
@@ -445,7 +927,7 @@ function scanGlobal() {
     { dir: ".cursor/rules", type: "rule", group: "cursor" }
   ];
   for (const { dir, type, group } of globalDirs) {
-    const dirPath = join2(home, dir);
+    const dirPath = join5(home, dir);
     const files = walkDir(dirPath, 2);
     for (const filePath of files) {
       const content = readFileSafe(filePath);
@@ -461,152 +943,166 @@ function scanGlobal() {
       }
     }
   }
+  const skillsRoot = join5(home, ".claude", "skills");
+  try {
+    for (const entry of readdirSync2(skillsRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillDir = join5(skillsRoot, entry.name);
+      if (!existsSync5(join5(skillDir, "SKILL.md"))) continue;
+      for (const filePath of walkDir(skillDir, 2)) {
+        const content = readFileSafe(filePath);
+        if (content !== null) {
+          results.push({
+            path: filePath,
+            relativePath: `~/${relative(home, filePath)}`,
+            content,
+            type: "skill",
+            source: "global",
+            group: "claude-code"
+          });
+        }
+      }
+    }
+  } catch {
+  }
   return results;
 }
 
-// src/classifier.ts
-import { basename, dirname } from "path";
-
-// src/stableKey.ts
-function computeStableKey(group, type, relPath) {
-  return `${group}:${type}:${relPath}`;
-}
-
-// src/classifier.ts
-function classify(files) {
-  const groups = /* @__PURE__ */ new Map();
-  const singletons = [];
-  const singletonRoots = /* @__PURE__ */ new Set([
-    ".",
-    "~",
-    "~/.claude",
-    "~/.cursor",
-    "~/.continue",
-    ".claude",
-    ".cursor",
-    ".github"
-  ]);
-  for (const file of files) {
-    const dir = dirname(file.relativePath);
-    const isSingleton = singletonRoots.has(dir);
-    if (isSingleton) {
-      singletons.push(file);
-    } else {
-      const key = `${file.group}:${file.source}:${file.type}:${dir}`;
-      const existing = groups.get(key) ?? [];
-      existing.push(file);
-      groups.set(key, existing);
-    }
-  }
-  const items = [];
-  const scope = (source) => source === "global" ? "global" : "project";
-  for (const file of singletons) {
-    const s = scope(file.source);
-    const relPath = file.relativePath.replace(/^~\/\.[^/]+\//, "").replace(/^\.[^/]+\//, "");
-    items.push({
-      type: file.type,
-      name: file.relativePath,
-      group: file.group,
-      scope: s,
-      stableKey: computeStableKey(file.group, file.type, relPath),
-      files: [
-        {
-          name: basename(file.relativePath),
-          content: file.content,
-          path: file.relativePath
-        }
-      ]
-    });
-  }
-  for (const [, groupFiles] of groups) {
-    const first = groupFiles[0];
-    const dir = dirname(first.relativePath);
-    const s = scope(first.source);
-    const relPath = dir.replace(/^~\/\.claude\//, "").replace(/^\.claude\//, "").replace(/^~\/\.cursor\//, "").replace(/^\.cursor\//, "");
-    const typeLabel = first.type === "subagent" ? "subagents" : `${first.type}s`;
-    items.push({
-      type: first.type,
-      name: dir,
-      description: `${groupFiles.length} ${typeLabel}`,
-      group: first.group,
-      scope: s,
-      stableKey: computeStableKey(first.group, first.type, relPath),
-      files: groupFiles.map((f) => ({
-        name: basename(f.relativePath),
-        content: f.content,
-        path: f.relativePath
-      }))
-    });
+// src/theme.ts
+import * as p from "@clack/prompts";
+var esc = (code) => `\x1B[${code}m`;
+var reset = esc("0");
+var LIME = "163;230;53";
+var BLACK = "0;0;0";
+var YELLOW = "250;204;21";
+var RED = "248;113;113";
+var MUTED = "120;120;120";
+var lime = (s) => `${esc(`38;2;${LIME}`)}${s}${reset}`;
+var limeBold = (s) => `${esc("1")}${esc(`38;2;${LIME}`)}${s}${reset}`;
+var bgLime = (s) => `${esc(`48;2;${LIME}`)}${esc(`38;2;${BLACK}`)}${s}${reset}`;
+var yellow = (s) => `${esc(`38;2;${YELLOW}`)}${s}${reset}`;
+var red = (s) => `${esc(`38;2;${RED}`)}${s}${reset}`;
+var dim = (s) => `${esc(`38;2;${MUTED}`)}${s}${reset}`;
+var bold = (s) => `${esc("1")}${s}${reset}`;
+var banner = (cmd) => `${lime("\u25A0")} ${bgLime(` AISTACK `)} ${bold(cmd.toUpperCase())}`;
+var BAR = `${esc(`38;2;${MUTED}`)}\u2502${reset}`;
+function lines(items) {
+  for (const item of items) {
+    console.log(`${BAR}  ${item}`);
   }
-  return items;
+}
+function section(label, count) {
+  console.log(`${BAR}`);
+  const countStr = count !== void 0 ? ` ${dim(String(count))}` : "";
+  console.log(`${BAR}  ${bold(label.toUpperCase())}${countStr}`);
+}
+function divider() {
+  console.log(`${BAR}  ${dim("\u2500".repeat(40))}`);
+}
+function intro2(cmd) {
+  console.log();
+  p.intro(banner(cmd));
+}
+function outro2(msg) {
+  p.outro(msg);
+  console.log();
+}
+function outroError(msg) {
+  p.outro(red(msg));
+  console.log();
+}
+function outroCancel(msg = "cancelled") {
+  p.cancel(dim(msg));
+  console.log();
+}
+function outroSkipped(msg) {
+  p.outro(dim(msg));
+  console.log();
 }
 
 // src/commands/collect.ts
+var REPO_LINK_KEY = "\0repo-link";
 async function collectCommand(options) {
   intro2("collect");
   const token = getToken();
   if (!token) {
-    p3.log.error(
+    p2.log.error(
       `Not authenticated. Run ${limeBold("npx @use-aistack/cli login")} first.`
     );
     outroError("not authenticated");
     process.exit(1);
   }
   const cwd = process.cwd();
-  const savedName = getProjectName(cwd);
   const savedExcluded = getExcludedPaths(cwd);
-  const s = p3.spinner();
+  const s = p2.spinner();
   s.start("Scanning...");
   const localFiles = scanLocal(cwd);
   const globalFiles = options.global ? scanGlobal() : [];
   s.stop("Scan complete");
   if (localFiles.length === 0 && globalFiles.length === 0) {
-    p3.log.warn("No AI configuration files found.");
+    p2.log.warn("No AI configuration files found.");
     outroSkipped("nothing to collect");
     return;
   }
-  let projectName;
-  if (savedName) {
-    p3.log.info(`${dim("PROJECT")} ${limeBold(savedName)}`);
-    projectName = savedName;
-  } else {
-    const defaultName = basename2(cwd);
-    const name = await p3.text({
-      message: "Project name:",
-      defaultValue: defaultName,
-      placeholder: defaultName
-    });
-    if (p3.isCancel(name)) {
-      outroCancel();
-      process.exit(0);
-    }
-    projectName = name || defaultName;
-  }
   const allFiles = [...localFiles, ...globalFiles];
   let selectedFiles = allFiles.filter(
     (f) => !savedExcluded.includes(f.relativePath)
   );
   let excluded = allFiles.filter((f) => savedExcluded.includes(f.relativePath));
-  p3.log.info(
+  p2.log.info(
     `${lime(String(selectedFiles.length))} included${excluded.length > 0 ? ` \xB7 ${dim(String(excluded.length) + " excluded")}` : ""}`
   );
-  let allResources = classify(selectedFiles);
-  let existingProject = null;
+  const detectedLinks = [];
+  const repoUrl = detectRepoUrl(cwd);
+  if (repoUrl) {
+    detectedLinks.push({
+      key: REPO_LINK_KEY,
+      resource: buildRepoLinkResource(repoUrl),
+      label: `repo \xB7 ${repoNameFromCanonical(repoUrl)}`
+    });
+  }
+  for (const resource of detectInstalledPlugins()) {
+    detectedLinks.push({
+      key: `\0plugin:${resource.stableKey}`,
+      resource,
+      label: `plugin \xB7 ${resource.name}`
+    });
+  }
+  for (const resource of detectMcpServers(cwd)) {
+    detectedLinks.push({
+      key: `\0mcp:${resource.stableKey}`,
+      resource,
+      label: `mcp \xB7 ${resource.name}`
+    });
+  }
+  for (const resource of detectHooks(cwd)) {
+    detectedLinks.push({
+      key: `\0hook:${resource.stableKey}`,
+      resource,
+      label: `hook \xB7 ${resource.name}`
+    });
+  }
+  const includedLinks = new Set(
+    detectedLinks.filter((l) => !savedExcluded.includes(l.key)).map((l) => l.key)
+  );
+  const withLinks = (base) => [
+    ...base,
+    ...detectedLinks.filter((l) => includedLinks.has(l.key)).map((l) => l.resource)
+  ];
+  let allResources = withLinks(classify(selectedFiles));
+  let existingStack = null;
   try {
-    const check = await projectsCheck(token, projectName);
-    if (check.exists && check.slug) {
-      const shortId = check.slug.includes("-") ? check.slug.slice(check.slug.lastIndexOf("-") + 1) : check.slug;
-      existingProject = await projectGet(shortId);
-    }
+    existingStack = await stackGet(token);
   } catch (err) {
-    p3.log.error(err instanceof Error ? err.message : String(err));
+    p2.log.error(err instanceof Error ? err.message : String(err));
     outroError("error");
     process.exit(1);
   }
-  if (existingProject) {
-    const diff = diffResources(allResources, existingProject.resources);
-    if (diff.changed === 0 && diff.added === 0 && diff.removed === 0) {
-      p3.log.info("No changes since last collect.");
+  if (existingStack) {
+    const diff = diffResources(allResources, existingStack.resources);
+    const changeCount = diff.added + diff.changed + diff.removed;
+    if (changeCount === 0) {
+      p2.log.info("No changes since last collect.");
       outroSkipped("nothing to upload");
       return;
     }
@@ -627,7 +1123,7 @@ async function collectCommand(options) {
     const local = selectedFiles.filter((f) => f.source === "local");
     const global = selectedFiles.filter((f) => f.source === "global");
     if (local.length > 0) {
-      p3.log.step(`${bold("LOCAL")} ${dim(String(local.length))}`);
+      p2.log.step(`${bold("LOCAL")} ${dim(String(local.length))}`);
       divider();
       for (const [type, files] of groupByType(local)) {
         lines([`${lime(type.toUpperCase())} ${dim(`${files.length}`)}`]);
@@ -636,7 +1132,7 @@ async function collectCommand(options) {
       divider();
     }
     if (global.length > 0) {
-      p3.log.step(`${bold("GLOBAL")} ${dim(String(global.length))}`);
+      p2.log.step(`${bold("GLOBAL")} ${dim(String(global.length))}`);
       divider();
       for (const [type, files] of groupByType(global)) {
         lines([`${lime(type.toUpperCase())} ${dim(`${files.length}`)}`]);
@@ -644,60 +1140,79 @@ async function collectCommand(options) {
       }
       divider();
     }
+    const shownLinks = detectedLinks.filter((l) => includedLinks.has(l.key));
+    if (shownLinks.length > 0) {
+      p2.log.step(`${bold("LINKS")} ${dim(String(shownLinks.length))}`);
+      divider();
+      lines(shownLinks.map((l) => dim(`  ${l.label}`)));
+      divider();
+    }
   }
-  const action = await p3.select({
-    message: existingProject ? "Upload changes?" : `Upload ${bold(String(selectedFiles.length))} files as ${limeBold(projectName)}?`,
+  const action = await p2.select({
+    message: existingStack ? "Upload changes?" : `Upload ${bold(String(selectedFiles.length))} files to your stack?`,
     options: [
       { value: "upload", label: "Upload" },
       { value: "customize", label: "Select files" },
       { value: "cancel", label: "Cancel" }
     ]
   });
-  if (p3.isCancel(action) || action === "cancel") {
+  if (p2.isCancel(action) || action === "cancel") {
     outroCancel();
     process.exit(0);
   }
   if (action === "customize") {
-    const selected = await p3.multiselect({
+    const linkOptions = detectedLinks.map((l) => ({
+      value: l.key,
+      label: l.label,
+      hint: "link"
+    }));
+    const selected = await p2.multiselect({
       message: "Select files to include:",
-      options: allFiles.map((f) => ({
-        value: f.relativePath,
-        label: f.relativePath,
-        hint: `${f.type}${f.source === "global" ? " \xB7 global" : ""}`
-      })),
-      initialValues: selectedFiles.map((f) => f.relativePath)
+      options: [
+        ...linkOptions,
+        ...allFiles.map((f) => ({
+          value: f.relativePath,
+          label: f.relativePath,
+          hint: `${f.type}${f.source === "global" ? " \xB7 global" : ""}`
+        }))
+      ],
+      initialValues: [
+        ...detectedLinks.filter((l) => includedLinks.has(l.key)).map((l) => l.key),
+        ...selectedFiles.map((f) => f.relativePath)
+      ]
     });
-    if (p3.isCancel(selected)) {
+    if (p2.isCancel(selected)) {
       outroCancel();
       process.exit(0);
     }
     const selectedSet = new Set(selected);
     selectedFiles = allFiles.filter((f) => selectedSet.has(f.relativePath));
     excluded = allFiles.filter((f) => !selectedSet.has(f.relativePath));
-    allResources = classify(selectedFiles);
-    if (selectedFiles.length === 0) {
-      p3.log.warn("No files selected.");
+    includedLinks.clear();
+    for (const l of detectedLinks) {
+      if (selectedSet.has(l.key)) includedLinks.add(l.key);
+    }
+    allResources = withLinks(classify(selectedFiles));
+    if (selectedFiles.length === 0 && includedLinks.size === 0) {
+      p2.log.warn("No files selected.");
       outroSkipped("nothing to collect");
       process.exit(0);
     }
   }
   s.start("Uploading...");
   try {
-    const result = await projectsCollect(token, {
-      name: projectName,
-      resources: allResources
-    });
+    const result = await stackCollect(token, { resources: allResources });
     s.stop(lime("Uploaded"));
-    saveProjectSettings(
-      cwd,
-      projectName,
-      excluded.map((f) => f.relativePath)
-    );
-    p3.log.success(dim(result.url));
+    const excludedKeys = excluded.map((f) => f.relativePath);
+    for (const l of detectedLinks) {
+      if (!includedLinks.has(l.key)) excludedKeys.push(l.key);
+    }
+    saveExcludedPaths(cwd, excludedKeys);
+    p2.log.success(dim(result.url));
     outro2(lime("done"));
   } catch (err) {
     s.stop("Upload failed");
-    p3.log.error(err instanceof Error ? err.message : String(err));
+    p2.log.error(err instanceof Error ? err.message : String(err));
     outroError("upload failed");
     process.exit(1);
   }
@@ -733,13 +1248,13 @@ function groupByType(files) {
 function diffResources(current, existing) {
   const existingMap = /* @__PURE__ */ new Map();
   for (const item of existing) {
-    for (const file of item.files) {
+    for (const file of item.files ?? []) {
       existingMap.set(file.path ?? file.name, file.content);
     }
   }
   const currentMap = /* @__PURE__ */ new Map();
   for (const item of current) {
-    for (const file of item.files) {
+    for (const file of item.files ?? []) {
       currentMap.set(file.path ?? file.name, file.content);
     }
   }
@@ -766,64 +1281,246 @@ function diffResources(current, existing) {
       details.push({ name: key, status: "removed" });
     }
   }
+  const linkLabel = (item) => {
+    if (item.upstream)
+      return `link: ${repoNameFromCanonical(item.upstream.repoUrl)}`;
+    if (item.pkg) return `link: ${item.pkg.id}`;
+    return `link: ${item.name}`;
+  };
+  const linkMap = (items) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      if ((item.upstream || item.pkg) && !item.files?.length) {
+        map.set(item.stableKey, item);
+      }
+    }
+    return map;
+  };
+  const existingLinks = linkMap(existing);
+  const currentLinks = linkMap(current);
+  for (const [key, item] of currentLinks) {
+    if (!existingLinks.has(key)) {
+      added++;
+      details.push({ name: linkLabel(item), status: "added" });
+    }
+  }
+  for (const [key, item] of existingLinks) {
+    if (!currentLinks.has(key)) {
+      removed++;
+      details.push({ name: linkLabel(item), status: "removed" });
+    }
+  }
   return { added, changed, removed, unchanged, details };
 }
 
-// src/commands/create.ts
-import * as p4 from "@clack/prompts";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-async function createCommand(slugOrShortId) {
-  intro2("create");
-  const s = p4.spinner();
-  s.start("Fetching project...");
-  const shortId = slugOrShortId.includes("-") ? slugOrShortId.slice(slugOrShortId.lastIndexOf("-") + 1) : slugOrShortId;
-  let project;
+// src/commands/connect.ts
+import { spawnSync } from "child_process";
+import { cpSync, existsSync as existsSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname3, join as join6 } from "path";
+import { fileURLToPath } from "url";
+import * as p3 from "@clack/prompts";
+var MANUAL_MCP_ADD = "claude mcp add --scope user aistack -- npx -y @use-aistack/cli mcp";
+var MCP_ADD_ARGS = [
+  "mcp",
+  "add",
+  "--scope",
+  "user",
+  "aistack",
+  "--",
+  "npx",
+  "-y",
+  "@use-aistack/cli",
+  "mcp"
+];
+var MCP_REMOVE_ARGS = ["mcp", "remove", "--scope", "user", "aistack"];
+var SKILL_DEST = join6(homedir6(), ".claude", "skills", "aistack-sync");
+function runClaude(args) {
+  const r = spawnSync("claude", args, { encoding: "utf-8" });
+  const notFound = r.error !== void 0 && r.error.code === "ENOENT";
+  return {
+    notFound,
+    status: r.status,
+    output: `${r.stdout ?? ""}${r.stderr ?? ""}`
+  };
+}
+function claudeOnPath(run = runClaude) {
+  return !run(["--version"]).notFound;
+}
+function findSkillSource(fromDir = dirname3(fileURLToPath(import.meta.url))) {
+  let dir = fromDir;
+  for (let i = 0; i < 4; i++) {
+    const candidate = join6(dir, "skills", "aistack-sync");
+    if (existsSync6(join6(candidate, "SKILL.md"))) return candidate;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function installClaudeConnect(run = runClaude, copySkill = (src, dest) => cpSync(src, dest, { recursive: true })) {
+  const source = findSkillSource();
+  if (source === null) {
+    return {
+      ok: false,
+      message: "this install is missing its bundled Skill (skills/aistack-sync) \u2014 nothing was installed"
+    };
+  }
+  const add = run(MCP_ADD_ARGS);
+  if (add.notFound) {
+    return {
+      ok: false,
+      message: `claude was not found on PATH \u2014 nothing was installed. Manual install:
+${MANUAL_MCP_ADD}`
+    };
+  }
+  const alreadyRegistered = add.status !== 0 && add.output.includes("already exists");
+  if (add.status !== 0 && !alreadyRegistered) {
+    return {
+      ok: false,
+      message: `claude mcp add failed \u2014 nothing was installed.
+${add.output.trim()}`
+    };
+  }
   try {
-    project = await projectGet(shortId);
-    if (!project) {
-      s.stop("Not found");
-      p4.log.error(`Project "${slugOrShortId}" not found.`);
-      outroError("not found");
-      process.exit(1);
-    }
-    s.stop(bold(project.name));
-  } catch (err) {
-    s.stop("Failed to fetch project");
-    p4.log.error(err instanceof Error ? err.message : String(err));
-    outroError("error");
-    process.exit(1);
+    copySkill(source, SKILL_DEST);
+  } catch (e) {
+    if (!alreadyRegistered) run(MCP_REMOVE_ARGS);
+    return {
+      ok: false,
+      message: `copying the Skill to ${SKILL_DEST} failed \u2014 the MCP registration was ${alreadyRegistered ? "left as it was" : "rolled back"}.
+${e instanceof Error ? e.message : String(e)}`
+    };
   }
-  const localFiles = [];
-  const globalFiles = [];
-  for (const item of project.resources) {
-    const isGlobal = item.scope === "global";
-    for (const file of item.files) {
-      const writePath = file.path ?? file.name;
-      if (isGlobal) {
-        globalFiles.push({ path: writePath, content: file.content });
-      } else {
-        localFiles.push({ path: writePath, content: file.content });
-      }
-    }
+  return {
+    ok: true,
+    message: `Installed. Say ${limeBold('"sync my stack"')} in any Claude Code session.`
+  };
+}
+async function connectCommand(harness) {
+  intro2("connect");
+  if (harness !== "claude") {
+    outroError(`unknown harness "${harness}" \u2014 supported: claude`);
+    process.exitCode = 1;
+    return;
   }
-  if (globalFiles.length > 0) {
-    section("global config", globalFiles.length);
-    lines([dim("view only")]);
-    lines(globalFiles.map((f) => dim(f.path)));
+  if (!claudeOnPath()) {
+    p3.log.warn(
+      `claude was not found on PATH. Manual install:
+${dim(MANUAL_MCP_ADD)}
+plus copy skills/aistack-sync from this package to ${dim(SKILL_DEST)}`
+    );
+    outroSkipped("nothing was installed");
+    return;
   }
-  if (localFiles.length === 0) {
-    p4.log.warn("No local files to write.");
-    outroSkipped("nothing to create");
+  const result = installClaudeConnect();
+  if (!result.ok) {
+    outroError(result.message);
+    process.exitCode = 1;
     return;
   }
-  const cwd = process.cwd();
-  const toWrite = [];
-  const skipped = [];
+  p3.log.success(result.message);
+  outro2("done");
+}
+async function offerConnectUpsell() {
+  if (getSettings().connectClaudeAnswered === true) return;
+  if (!claudeOnPath()) return;
+  const answer = await p3.select({
+    message: "Sync from inside Claude Code too?",
+    options: [
+      {
+        value: "later",
+        label: "Not now",
+        hint: "this question will not come back"
+      },
+      {
+        value: "install",
+        label: "Install",
+        hint: "adds the aistack MCP server + Skill to Claude Code"
+      }
+    ],
+    initialValue: "later"
+  });
+  if (p3.isCancel(answer)) return;
+  saveSettings({ connectClaudeAnswered: true });
+  if (answer === "install") {
+    const result = installClaudeConnect();
+    if (result.ok) {
+      p3.log.success(result.message);
+    } else {
+      p3.log.error(result.message);
+    }
+    return;
+  }
+  p3.log.message(
+    `If you change your mind: ${limeBold("npx @use-aistack/cli connect claude")}`
+  );
+}
+
+// src/commands/create.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import * as p4 from "@clack/prompts";
+async function createCommand() {
+  intro2("create");
+  const token = getToken();
+  if (!token) {
+    p4.log.error(
+      `Not authenticated. Run ${limeBold("npx @use-aistack/cli login")} first.`
+    );
+    outroError("not authenticated");
+    process.exit(1);
+  }
+  const s = p4.spinner();
+  s.start("Fetching stack...");
+  let stack;
+  try {
+    stack = await stackGet(token);
+    if (!stack) {
+      s.stop("Not found");
+      p4.log.error("No stack found. Create a stack on aistack.to first.");
+      outroError("not found");
+      process.exit(1);
+    }
+    s.stop(bold(stack.name));
+  } catch (err) {
+    s.stop("Failed to fetch stack");
+    p4.log.error(err instanceof Error ? err.message : String(err));
+    outroError("error");
+    process.exit(1);
+  }
+  const localFiles = [];
+  for (const item of stack.resources) {
+    for (const file of item.files ?? []) {
+      localFiles.push({ path: file.path ?? file.name, content: file.content });
+    }
+  }
+  const linked = stack.resources.filter(
+    (item) => (item.upstream || item.pkg) && !item.files?.length
+  );
+  if (linked.length > 0) {
+    section("linked", linked.length);
+    lines([dim("view only")]);
+    lines(
+      linked.map(
+        (item) => dim(
+          item.upstream?.repoUrl ?? (item.pkg ? `${item.pkg.registry}:${item.pkg.id}` : "")
+        )
+      )
+    );
+  }
+  if (localFiles.length === 0) {
+    p4.log.warn("No local files to write.");
+    outroSkipped("nothing to create");
+    return;
+  }
+  const cwd = process.cwd();
+  const toWrite = [];
+  const skipped = [];
   for (const f of localFiles) {
-    const fullPath = join3(cwd, f.path);
-    if (existsSync3(fullPath)) {
-      const existing = readFileSync3(fullPath, "utf-8");
+    const fullPath = join7(cwd, f.path);
+    if (existsSync7(fullPath)) {
+      const existing = readFileSync6(fullPath, "utf-8");
       skipped.push({ path: f.path, differs: existing !== f.content });
     } else {
       toWrite.push(f);
@@ -851,8 +1548,8 @@ async function createCommand(slugOrShortId) {
     process.exit(0);
   }
   for (const f of toWrite) {
-    const fullPath = join3(cwd, f.path);
-    const dir = dirname2(fullPath);
+    const fullPath = join7(cwd, f.path);
+    const dir = dirname4(fullPath);
     mkdirSync2(dir, { recursive: true });
     writeFileSync2(fullPath, f.content);
   }
@@ -862,11 +1559,1976 @@ async function createCommand(slugOrShortId) {
   outro2(lime("done"));
 }
 
+// src/commands/login.ts
+import { hostname } from "os";
+import * as p5 from "@clack/prompts";
+import open from "open";
+function proposedMachineName(read = hostname) {
+  try {
+    const name = read().trim().replace(/\.local$/i, "");
+    if (!name || name.length > 64) return void 0;
+    return name;
+  } catch {
+    return void 0;
+  }
+}
+async function loginCommand() {
+  intro2("login");
+  const s = p5.spinner();
+  s.start("Starting authentication...");
+  let session;
+  try {
+    session = await authStart(proposedMachineName());
+    s.stop("Session created");
+  } catch (err) {
+    s.stop("Failed to start authentication");
+    p5.log.error(err instanceof Error ? err.message : String(err));
+    outroError("error");
+    process.exit(1);
+  }
+  p5.log.info(`${dim("CODE")} ${limeBold(session.userCode)}`);
+  p5.log.info(`${dim("OPEN")} ${dim(session.authUrl)}`);
+  try {
+    await open(session.authUrl);
+  } catch {
+    p5.log.warn(
+      "Could not open browser automatically. Please visit the URL above."
+    );
+  }
+  s.start("Waiting for approval...");
+  const maxAttempts = 36;
+  for (let i = 0; i < maxAttempts; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+    try {
+      const result = await authPoll(session.secretId);
+      if (result.status === "approved" && result.token) {
+        s.stop(lime("Authenticated"));
+        saveToken(result.token, result.userId);
+        p5.log.success(
+          `Token saved. Run ${limeBold("npx @use-aistack/cli collect")} to get started.`
+        );
+        outro2(lime("done"));
+        return;
+      }
+      if (result.status === "expired") {
+        s.stop("Session expired");
+        p5.log.error("Authentication session expired. Please try again.");
+        outroError("expired");
+        process.exit(1);
+      }
+    } catch (err) {
+      s.stop("Error polling");
+      p5.log.error(err instanceof Error ? err.message : String(err));
+      outroError("error");
+      process.exit(1);
+    }
+  }
+  s.stop("Timed out");
+  p5.log.error("Authentication timed out after 3 minutes. Please try again.");
+  outroError("timed out");
+  process.exit(1);
+}
+
+// src/commands/sync.ts
+import * as p7 from "@clack/prompts";
+
+// src/autosync/optin.ts
+import * as p6 from "@clack/prompts";
+
+// src/autosync/hook.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname5, join as join8 } from "path";
+var CLAUDE_SETTINGS_FILE = join8(homedir7(), ".claude", "settings.json");
+var AUTO_SYNC_HOOK_COMMAND = "npx -y @use-aistack/cli@latest sync --auto || npx -y --prefer-offline @use-aistack/cli sync --auto";
+function isOurs(entry) {
+  return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
+}
+function readClaudeSettings(file) {
+  if (!existsSync8(file)) return { settings: {} };
+  try {
+    const raw = JSON.parse(readFileSync7(file, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return { settings: raw };
+    }
+    return { error: `${file} does not hold a JSON object` };
+  } catch {
+    return { error: `${file} is not valid JSON \u2014 fix it, then retry` };
+  }
+}
+function installAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  const read = readClaudeSettings(file);
+  if ("error" in read) return { ok: false, message: read.error };
+  const settings = read.settings;
+  const hooks = settings.hooks ?? {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  kept.push({
+    hooks: [{ type: "command", command: AUTO_SYNC_HOOK_COMMAND, async: true }]
+  });
+  settings.hooks = { ...hooks, SessionStart: kept };
+  mkdirSync3(dirname5(file), { recursive: true });
+  writeFileSync3(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `SessionStart hook written to ${file}` };
+}
+function removeAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  if (!existsSync8(file)) return { ok: true, message: "no hook to remove" };
+  const read = readClaudeSettings(file);
+  if ("error" in read) return { ok: false, message: read.error };
+  const settings = read.settings;
+  const sessionStart = settings.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) {
+    return { ok: true, message: "no hook to remove" };
+  }
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  const hooks = { ...settings.hooks };
+  if (kept.length > 0) {
+    hooks.SessionStart = kept;
+  } else {
+    delete hooks.SessionStart;
+  }
+  if (Object.keys(hooks).length > 0) {
+    settings.hooks = hooks;
+  } else {
+    delete settings.hooks;
+  }
+  writeFileSync3(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `hook removed from ${file}` };
+}
+
+// src/autosync/optin.ts
+function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {}) {
+  const install = deps.installHook ?? installAutoSyncHook;
+  const result = install();
+  if (!result.ok) return result;
+  saveSettings(
+    {
+      autoSyncAnswered: true,
+      autoSync: { enabled: true, frequencyHours }
+    },
+    deps.settingsFile
+  );
+  return {
+    ok: true,
+    message: `Auto-sync is on \u2014 about every ${frequencyHours}h when a Claude Code session starts. Turn it off any time: npx @use-aistack/cli sync --auto off`
+  };
+}
+function disableAutoSync(deps = {}) {
+  const remove = deps.removeHook ?? removeAutoSyncHook;
+  const settings = getSettings(deps.settingsFile);
+  saveSettings(
+    {
+      autoSyncAnswered: true,
+      autoSync: {
+        enabled: false,
+        frequencyHours: settings.autoSync?.frequencyHours ?? DEFAULT_FREQUENCY_HOURS
+      }
+    },
+    deps.settingsFile
+  );
+  const result = remove();
+  if (!result.ok) {
+    return {
+      ok: false,
+      message: `Auto-sync is off (nothing will publish), but the hook could not be removed: ${result.message}`
+    };
+  }
+  return { ok: true, message: "Auto-sync is off. The hook was removed." };
+}
+async function offerAutoSyncOptIn() {
+  if (getSettings().autoSyncAnswered === true) return false;
+  const answer = await p6.select({
+    message: "Keep this stack fresh automatically?",
+    options: [
+      {
+        value: "later",
+        label: "Not now",
+        hint: "this question will not come back"
+      },
+      {
+        value: "enable",
+        label: "Enable",
+        hint: "a silent daily sync when a Claude Code session starts"
+      }
+    ],
+    initialValue: "later"
+  });
+  if (p6.isCancel(answer)) return true;
+  if (answer === "enable") {
+    const result = enableAutoSync();
+    if (result.ok) {
+      p6.log.success(result.message);
+    } else {
+      p6.log.error(result.message);
+    }
+    return true;
+  }
+  saveSettings({ autoSyncAnswered: true });
+  p6.log.message(
+    `If you change your mind: ${limeBold("npx @use-aistack/cli sync --auto on")} ${dim(
+      "(and --auto off to revoke)"
+    )}`
+  );
+  return true;
+}
+
+// src/autosync/run.ts
+import {
+  appendFileSync,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname6, join as join9 } from "path";
+
+// src/sync/stage.ts
+import { createHash } from "crypto";
+
+// src/transcripts/pricing.ts
+var PRICING_TABLE_VERSION = "anthropic-list-2026-07-25";
+var CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var CACHE_WRITE_1H_MULTIPLIER = 2;
+var CACHE_READ_MULTIPLIER = 0.1;
+var SONNET_5_INTRO_ENDS_MS = Date.UTC(2026, 8, 1);
+var PRICES = {
+  "claude-fable-5": [{ from: null, to: null, input: 10, output: 50 }],
+  "claude-mythos-5": [{ from: null, to: null, input: 10, output: 50 }],
+  "claude-opus-5": [{ from: null, to: null, input: 5, output: 25 }],
+  "claude-opus-4-8": [{ from: null, to: null, input: 5, output: 25 }],
+  "claude-opus-4-7": [{ from: null, to: null, input: 5, output: 25 }],
+  "claude-opus-4-6": [{ from: null, to: null, input: 5, output: 25 }],
+  "claude-sonnet-5": [
+    { from: null, to: SONNET_5_INTRO_ENDS_MS, input: 2, output: 10 },
+    { from: SONNET_5_INTRO_ENDS_MS, to: null, input: 3, output: 15 }
+  ],
+  "claude-sonnet-4-6": [{ from: null, to: null, input: 3, output: 15 }],
+  "claude-haiku-4-5": [{ from: null, to: null, input: 1, output: 5 }],
+  // Fast mode (research preview) — Claude API only, Opus 5 / Opus 4.8 only.
+  // Opus 4.7 fast mode was removed, so there is deliberately no 4-7 entry.
+  "claude-opus-5#fast": [{ from: null, to: null, input: 10, output: 50 }],
+  "claude-opus-4-8#fast": [{ from: null, to: null, input: 10, output: 50 }]
+};
+function normalizeModel(model) {
+  const [base, suffix] = model.split("#");
+  const stripped = base.replace(/-\d{8}$/, "");
+  return suffix ? `${stripped}#${suffix}` : stripped;
+}
+function baseModelId(modelKey) {
+  return modelKey.split("#")[0];
+}
+function priceAt(modelKey, atMs) {
+  if (atMs === null) return null;
+  const periods = PRICES[modelKey];
+  if (!periods) return null;
+  for (const p8 of periods) {
+    if ((p8.from === null || atMs >= p8.from) && (p8.to === null || atMs < p8.to)) {
+      return p8;
+    }
+  }
+  return null;
+}
+function isPricedModel(modelKey) {
+  return PRICES[modelKey] !== void 0;
+}
+function apiEquivalentCost(modelKey, t, atMs) {
+  const p8 = priceAt(modelKey, atMs);
+  if (!p8) return null;
+  const M = 1e6;
+  return (t.input * p8.input + t.output * p8.output + (t.cacheWrite5m + t.cacheWriteUnsplit) * p8.input * CACHE_WRITE_5M_MULTIPLIER + t.cacheWrite1h * p8.input * CACHE_WRITE_1H_MULTIPLIER + t.cacheRead * p8.input * CACHE_READ_MULTIPLIER) / M;
+}
+
+// src/transcripts/analyzer.ts
+var asObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+var asStr = (v) => typeof v === "string" && v.length > 0 ? v : null;
+var asNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var asArr = (v) => Array.isArray(v) ? v : [];
+var NAME_UNSAFE_RE = (
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping them is the point
+  /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b-\u200f\u2028-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g
+);
+var NAME_MAX = 64;
+function cleanName(s) {
+  const stripped = s.replace(NAME_UNSAFE_RE, "\uFFFD").trim();
+  if (stripped.length === 0) return "(unnamed)";
+  return stripped.length > NAME_MAX ? `${stripped.slice(0, NAME_MAX - 1)}\u2026` : stripped;
+}
+function isDisplaySafeName(s) {
+  if (s.length === 0 || s.trim().length === 0) return false;
+  if (s.length > NAME_MAX) return false;
+  return !new RegExp(NAME_UNSAFE_RE.source).test(s);
+}
+var asName = (v) => {
+  const s = asStr(v);
+  return s === null ? null : cleanName(s);
+};
+function createAggregate() {
+  return {
+    files: 0,
+    lines: 0,
+    parseErrors: 0,
+    records: 0,
+    assistantRecords: 0,
+    distinctResponses: 0,
+    continuationsFolded: 0,
+    realReplaysFolded: 0,
+    supersededByLarger: 0,
+    unkeyedResponses: 0,
+    syntheticRecords: 0,
+    syntheticTokens: 0,
+    toolBlocksWithoutId: 0,
+    fallbackAttempts: 0,
+    untypedMirrors: 0,
+    untimestampedResponses: 0,
+    projectDirs: /* @__PURE__ */ new Set(),
+    ccVersions: /* @__PURE__ */ new Set(),
+    mirroredIterationTypes: /* @__PURE__ */ new Map(),
+    byModel: /* @__PURE__ */ new Map(),
+    sidechainTokens: 0,
+    mainTokens: 0,
+    sessions: /* @__PURE__ */ new Set(),
+    activeDays: /* @__PURE__ */ new Set(),
+    firstTs: null,
+    lastTs: null,
+    toolCalls: /* @__PURE__ */ new Map(),
+    skillCalls: /* @__PURE__ */ new Map(),
+    mcpServerCalls: /* @__PURE__ */ new Map(),
+    mcpToolCalls: /* @__PURE__ */ new Map(),
+    subagentCalls: /* @__PURE__ */ new Map(),
+    slashCommands: /* @__PURE__ */ new Map(),
+    toolCallDedup: /* @__PURE__ */ new Set(),
+    thinkingBlocks: 0,
+    textBlocks: 0,
+    webSearchRequests: 0,
+    webFetchRequests: 0,
+    seen: /* @__PURE__ */ new Map()
+  };
+}
+var bump = (m, k, n = 1) => m.set(k, (m.get(k) ?? 0) + n);
+function emptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: 0,
+    cacheRead: 0,
+    messages: 0,
+    costUSD: 0,
+    unpricedTokens: 0
+  };
+}
+var countsTotal = (t) => t.input + t.output + t.cacheWrite5m + t.cacheWrite1h + t.cacheWriteUnsplit + t.cacheRead;
+function ingestRecord(agg, raw, ctx) {
+  const rec = asObj(raw);
+  if (!rec) return;
+  agg.records++;
+  agg.projectDirs.add(ctx.projectDir);
+  const version = asStr(rec.version);
+  if (version) agg.ccVersions.add(cleanName(version));
+  const sessionId = asStr(rec.sessionId);
+  if (sessionId) agg.sessions.add(sessionId);
+  let tsMs = null;
+  const timestamp = asStr(rec.timestamp);
+  if (timestamp) {
+    const ts = Date.parse(timestamp);
+    if (!Number.isNaN(ts)) {
+      tsMs = ts;
+      agg.activeDays.add(timestamp.slice(0, 10));
+      agg.firstTs = agg.firstTs === null ? ts : Math.min(agg.firstTs, ts);
+      agg.lastTs = agg.lastTs === null ? ts : Math.max(agg.lastTs, ts);
+    }
+  }
+  const type = asStr(rec.type);
+  if (type === "assistant") ingestAssistant(agg, rec, tsMs);
+  else if (type === "user") ingestUser(agg, rec);
+}
+function ingestAssistant(agg, rec, tsMs) {
+  agg.assistantRecords++;
+  const msg = asObj(rec.message);
+  if (!msg) return;
+  const messageId = asStr(msg.id);
+  const requestId = asStr(rec.requestId);
+  const existing = messageId === null ? void 0 : agg.seen.get(messageId);
+  const isReplay = existing !== void 0 && existing.requestId !== requestId;
+  if (!isReplay) ingestContentBlocks(agg, msg.content);
+  const usage = asObj(msg.usage);
+  if (!usage) return;
+  const model = asName(msg.model) ?? "(unknown)";
+  if (model.startsWith("<")) {
+    agg.syntheticRecords++;
+    agg.syntheticTokens += countsTotal(readCounts(usage));
+    return;
+  }
+  if (tsMs === null) agg.untimestampedResponses++;
+  const sidechain = rec.isSidechain === true;
+  const contribution = buildContribution(usage, model, sidechain, tsMs);
+  if (messageId === null) {
+    agg.unkeyedResponses++;
+    acceptContribution(agg, contribution);
+    return;
+  }
+  if (existing === void 0) {
+    agg.distinctResponses++;
+    acceptContribution(agg, contribution);
+    agg.seen.set(messageId, { requestId, contribution });
+    return;
+  }
+  if (isReplay) agg.realReplaysFolded++;
+  else agg.continuationsFolded++;
+  if (!supersedes(contribution, existing.contribution)) return;
+  agg.supersededByLarger++;
+  retractContribution(agg, existing.contribution);
+  acceptContribution(agg, contribution);
+  agg.seen.set(messageId, { requestId: existing.requestId, contribution });
+}
+function acceptContribution(agg, c) {
+  applyContribution(agg, c, 1);
+}
+function retractContribution(agg, c) {
+  applyContribution(agg, c, -1);
+}
+function supersedes(next, prev) {
+  if (prev.sidechain !== next.sidechain)
+    return prev.sidechain && !next.sidechain;
+  return next.total > prev.total;
+}
+function readCounts(usage) {
+  const t = {
+    input: asNum(usage.input_tokens),
+    output: asNum(usage.output_tokens),
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: 0,
+    cacheRead: asNum(usage.cache_read_input_tokens)
+  };
+  const cacheWriteTotal = asNum(usage.cache_creation_input_tokens);
+  const cc = asObj(usage.cache_creation);
+  if (cc) {
+    t.cacheWrite5m = asNum(cc.ephemeral_5m_input_tokens);
+    t.cacheWrite1h = asNum(cc.ephemeral_1h_input_tokens);
+    const residual = cacheWriteTotal - (t.cacheWrite5m + t.cacheWrite1h);
+    if (residual > 0) t.cacheWriteUnsplit = residual;
+  } else {
+    t.cacheWriteUnsplit = cacheWriteTotal;
+  }
+  return t;
+}
+function modelKeyFor(model, speed) {
+  return normalizeModel(speed === "fast" ? `${model}#fast` : model);
+}
+function makeEntry(modelKey, counts, tsMs) {
+  return {
+    modelKey,
+    counts,
+    costUSD: apiEquivalentCost(modelKey, counts, tsMs)
+  };
+}
+function buildContribution(usage, model, sidechain, tsMs) {
+  const modelKey = modelKeyFor(model, asStr(usage.speed));
+  const entries = [makeEntry(modelKey, readCounts(usage), tsMs)];
+  const mirrored = /* @__PURE__ */ new Map();
+  let fallbackAttempts = 0;
+  let untypedMirrors = 0;
+  for (const rawIt of asArr(usage.iterations)) {
+    const it = asObj(rawIt);
+    if (!it) continue;
+    const itType = asName(it.type) ?? "(untyped)";
+    const itModel = asName(it.model);
+    const itKey = itModel === null ? null : modelKeyFor(itModel, asStr(it.speed));
+    if (itType === "advisor_message") {
+      entries.push(makeEntry(itKey ?? modelKey, readCounts(it), tsMs));
+      continue;
+    }
+    if (itKey === null) {
+      untypedMirrors++;
+      bump(mirrored, itType);
+      continue;
+    }
+    if (itKey === modelKey) {
+      bump(mirrored, itType);
+      continue;
+    }
+    entries.push(makeEntry(itKey, readCounts(it), tsMs));
+    fallbackAttempts++;
+  }
+  const serverTools = asObj(usage.server_tool_use);
+  return {
+    entries,
+    total: entries.reduce((a, e) => a + countsTotal(e.counts), 0),
+    sidechain,
+    webSearch: serverTools ? asNum(serverTools.web_search_requests) : 0,
+    webFetch: serverTools ? asNum(serverTools.web_fetch_requests) : 0,
+    mirroredIterationTypes: [...mirrored],
+    fallbackAttempts,
+    untypedMirrors
+  };
+}
+function applyContribution(agg, c, sign) {
+  c.entries.forEach(({ modelKey, counts, costUSD }, i) => {
+    let m = agg.byModel.get(modelKey);
+    if (!m) {
+      m = emptyUsage();
+      agg.byModel.set(modelKey, m);
+    }
+    if (i === 0) m.messages += sign;
+    m.input += sign * counts.input;
+    m.output += sign * counts.output;
+    m.cacheWrite5m += sign * counts.cacheWrite5m;
+    m.cacheWrite1h += sign * counts.cacheWrite1h;
+    m.cacheWriteUnsplit += sign * counts.cacheWriteUnsplit;
+    m.cacheRead += sign * counts.cacheRead;
+    if (costUSD === null) m.unpricedTokens += sign * countsTotal(counts);
+    else m.costUSD += sign * costUSD;
+  });
+  if (c.sidechain) agg.sidechainTokens += sign * c.total;
+  else agg.mainTokens += sign * c.total;
+  agg.webSearchRequests += sign * c.webSearch;
+  agg.webFetchRequests += sign * c.webFetch;
+  agg.fallbackAttempts += sign * c.fallbackAttempts;
+  agg.untypedMirrors += sign * c.untypedMirrors;
+  for (const [type, count] of c.mirroredIterationTypes) {
+    bump(agg.mirroredIterationTypes, type, sign * count);
+  }
+}
+function ingestContentBlocks(agg, content) {
+  for (const rawBlock of asArr(content)) {
+    const block = asObj(rawBlock);
+    if (!block) continue;
+    const type = asStr(block.type);
+    if (type === "thinking") agg.thinkingBlocks++;
+    else if (type === "text") agg.textBlocks++;
+    else if (type === "tool_use") ingestToolUse(agg, block);
+  }
+}
+function ingestToolUse(agg, block) {
+  const name = asName(block.name);
+  if (!name) return;
+  const blockId = asStr(block.id);
+  if (!blockId) {
+    agg.toolBlocksWithoutId++;
+    return;
+  }
+  if (agg.toolCallDedup.has(blockId)) return;
+  agg.toolCallDedup.add(blockId);
+  const input = asObj(block.input) ?? {};
+  if (name.startsWith("mcp__")) {
+    const parts = name.slice("mcp__".length).split("__");
+    bump(agg.mcpServerCalls, parts[0] || "(unknown)");
+    bump(agg.mcpToolCalls, name);
+    return;
+  }
+  if (name === "Skill") {
+    bump(agg.skillCalls, asName(input.skill) ?? "(unnamed)");
+    bump(agg.toolCalls, "Skill");
+    return;
+  }
+  if (name === "Agent" || name === "Task") {
+    bump(agg.subagentCalls, asName(input.subagent_type) ?? "(default)");
+    bump(agg.toolCalls, "Agent");
+    return;
+  }
+  bump(agg.toolCalls, name);
+}
+var SLASH_RE = /<command-name>\/?([^<\n\r]{1,64})<\/command-name>/g;
+function ingestUser(agg, rec) {
+  const msg = asObj(rec.message);
+  if (!msg) return;
+  const content = msg.content;
+  let text = "";
+  if (typeof content === "string") text = content;
+  else {
+    for (const rawBlock of asArr(content)) {
+      const block = asObj(rawBlock);
+      if (!block) continue;
+      if (asStr(block.type) === "text") text += asStr(block.text) ?? "";
+    }
+  }
+  if (!text.includes("<command-name>")) return;
+  for (const match of text.matchAll(SLASH_RE)) {
+    bump(agg.slashCommands, cleanName(match[1]));
+  }
+}
+function buildModelRows(agg) {
+  const rows = [];
+  let totalTokens = 0;
+  let totalCostUSD = 0;
+  const unpricedModels = [];
+  let unpricedTokens = 0;
+  for (const [modelKey, u] of agg.byModel) {
+    const tokens = {
+      input: u.input,
+      output: u.output,
+      cacheWrite5m: u.cacheWrite5m,
+      cacheWrite1h: u.cacheWrite1h,
+      cacheWriteUnsplit: u.cacheWriteUnsplit,
+      cacheRead: u.cacheRead
+    };
+    const sum = countsTotal(tokens);
+    totalTokens += sum;
+    if (u.unpricedTokens > 0) {
+      unpricedModels.push(modelKey);
+      unpricedTokens += u.unpricedTokens;
+    }
+    totalCostUSD += u.costUSD;
+    rows.push({
+      modelKey,
+      tokens,
+      totalTokens: sum,
+      messages: u.messages,
+      share: 0,
+      // A model we hold no rate for at all reports null rather than $0.00,
+      // so "we can't price this" never reads as "this was free".
+      costUSD: isPricedModel(modelKey) ? u.costUSD : null,
+      unpricedTokens: u.unpricedTokens
+    });
+  }
+  for (const r of rows) r.share = totalTokens ? r.totalTokens / totalTokens : 0;
+  rows.sort(
+    (a, b) => b.totalTokens - a.totalTokens || a.modelKey.localeCompare(b.modelKey)
+  );
+  return { rows, totalTokens, totalCostUSD, unpricedModels, unpricedTokens };
+}
+function computeCacheHitShare(rows) {
+  let cacheRead = 0;
+  let inputClass = 0;
+  for (const r of rows) {
+    cacheRead += r.tokens.cacheRead;
+    inputClass += r.tokens.input + r.tokens.cacheRead + r.tokens.cacheWrite5m + r.tokens.cacheWrite1h + r.tokens.cacheWriteUnsplit;
+  }
+  return inputClass ? cacheRead / inputClass : 0;
+}
+function newestVersion(versions) {
+  let best = null;
+  let bestParts = [];
+  for (const v of versions) {
+    const parts = v.split(".").map((p8) => Number.parseInt(p8, 10));
+    if (parts.some((n) => !Number.isFinite(n))) continue;
+    if (best === null || compareParts(parts, bestParts) > 0) {
+      best = v;
+      bestParts = parts;
+    }
+  }
+  return best;
+}
+function compareParts(a, b) {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const d = (a[i] ?? 0) - (b[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function finalize(agg) {
+  const { rows, totalTokens, totalCostUSD, unpricedModels, unpricedTokens } = buildModelRows(agg);
+  const byCount = (m) => [...m.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+  let totalToolCalls = 0;
+  for (const v of agg.toolCalls.values()) totalToolCalls += v;
+  for (const v of agg.mcpToolCalls.values()) totalToolCalls += v;
+  const sideTotal = agg.sidechainTokens + agg.mainTokens;
+  return {
+    models: rows,
+    totalTokens,
+    totalCostUSD,
+    unpricedModels,
+    unpricedTokens,
+    cacheHitShare: computeCacheHitShare(rows),
+    sidechainShare: sideTotal ? agg.sidechainTokens / sideTotal : 0,
+    activeDays: agg.activeDays.size,
+    firstTs: agg.firstTs,
+    lastTs: agg.lastTs,
+    sessions: agg.sessions.size,
+    projects: agg.projectDirs.size,
+    tools: byCount(agg.toolCalls),
+    skills: byCount(agg.skillCalls),
+    mcpServers: byCount(agg.mcpServerCalls),
+    subagents: byCount(agg.subagentCalls),
+    slashCommands: byCount(agg.slashCommands),
+    totalToolCalls,
+    harnessVersion: newestVersion(agg.ccVersions)
+  };
+}
+
+// src/transcripts/bundled-allowlist.ts
+var BUILTIN_SUBAGENTS = [
+  "(default)",
+  "claude",
+  "claude-code-guide",
+  "Explore",
+  "fork",
+  "general-purpose",
+  "Plan",
+  "statusline-setup"
+];
+var BUILTIN_SKILLS = [
+  "artifact-capabilities",
+  "artifact-design",
+  "claude-api",
+  "code-review",
+  "codebase-design",
+  "dataviz",
+  "diagnosing-bugs",
+  "domain-modeling",
+  "fewer-permission-prompts",
+  "grilling",
+  "init",
+  "keybindings-help",
+  "loop",
+  "prototype",
+  "research",
+  "review",
+  "run",
+  "schedule",
+  "security-review",
+  "simplify",
+  "tdd",
+  "update-config"
+];
+var BUILTIN_SLASH_COMMANDS = [
+  "add-dir",
+  "agents",
+  "bug",
+  "clear",
+  "compact",
+  "config",
+  "context",
+  "cost",
+  "doctor",
+  "effort",
+  "exit",
+  "export",
+  "fast",
+  "help",
+  "hooks",
+  "ide",
+  "init",
+  "login",
+  "logout",
+  "mcp",
+  "memory",
+  "model",
+  "output-style",
+  "permissions",
+  "plugin",
+  "privacy-settings",
+  "release-notes",
+  "resume",
+  "review",
+  "rewind",
+  "security-review",
+  "status",
+  "statusline",
+  "terminal-setup",
+  "todos",
+  "upgrade",
+  "usage",
+  "vim",
+  "workflows"
+];
+var PUBLIC_MCP_SERVERS = [
+  "chrome-devtools",
+  "context7",
+  "deepwiki",
+  "figma",
+  "filesystem",
+  "git",
+  "github",
+  "huggingface",
+  "ide",
+  "linear",
+  "notion",
+  "playwright",
+  "puppeteer",
+  "sentry",
+  "slack",
+  "stripe"
+];
+var BUNDLED_CURATED_ALLOWLIST = {
+  mcpServers: PUBLIC_MCP_SERVERS,
+  skills: BUILTIN_SKILLS,
+  subagents: BUILTIN_SUBAGENTS,
+  slashCommands: BUILTIN_SLASH_COMMANDS
+};
+
+// src/transcripts/allowlist.ts
+var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "Agent",
+  "Artifact",
+  "AskUserQuestion",
+  "Bash",
+  "BashOutput",
+  "CronCreate",
+  "CronDelete",
+  "CronList",
+  "DesignSync",
+  "Edit",
+  "EndConversation",
+  "EnterPlanMode",
+  "EnterWorktree",
+  "ExitPlanMode",
+  "ExitWorktree",
+  "Glob",
+  "Grep",
+  "KillBash",
+  "KillShell",
+  "ListMcpResourcesTool",
+  "LS",
+  "Monitor",
+  "MultiEdit",
+  "NotebookEdit",
+  "NotebookRead",
+  "PushNotification",
+  "Read",
+  "ReadMcpResourceDirTool",
+  "ReadMcpResourceTool",
+  "RemoteTrigger",
+  "ReportFindings",
+  "ScheduleWakeup",
+  "SendMessage",
+  "SendUserFile",
+  "Skill",
+  "SlashCommand",
+  "Task",
+  "TaskCreate",
+  "TaskGet",
+  "TaskList",
+  "TaskOutput",
+  "TaskStop",
+  "TaskUpdate",
+  "TodoWrite",
+  "ToolSearch",
+  "WebFetch",
+  "WebSearch",
+  "Workflow",
+  "Write"
+]);
+var NAME_CATEGORIES = [
+  "builtinTools",
+  "mcpServers",
+  "skills",
+  "subagents",
+  "slashCommands"
+];
+var EMPTY_OPT_INS = {
+  builtinTools: [],
+  mcpServers: [],
+  skills: [],
+  subagents: [],
+  slashCommands: []
+};
+var BUNDLED_SYNC_CONFIG = {
+  allowlist: BUNDLED_CURATED_ALLOWLIST,
+  publishCost: false,
+  // Empty for the same reason, and it is the load-bearing half of #42
+  // decision 2: a failed config fetch reverts every ticked name to
+  // kept-private. Losing the network publishes LESS, never more.
+  optIns: EMPTY_OPT_INS,
+  // Same direction again (#48): a machine that cannot read the switch does not
+  // upload the names it is holding back. The default is ON server-side, so this
+  // costs the owner one retry and never costs them a name.
+  reviewKeptPrivate: false,
+  // No fetch, no destination — and the gate refuses to publish without one.
+  stack: null
+};
+var SYNC_CONFIG_PATH = "/api/sync-config";
+var FETCH_TIMEOUT_MS = 5e3;
+var CURATED_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9 ._:@/-]{0,63}$/;
+function readNameList(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const item of v) {
+    if (typeof item === "string" && CURATED_NAME_RE.test(item)) out.push(item);
+  }
+  return out;
+}
+function readOptInList(v) {
+  if (!Array.isArray(v)) return [];
+  const out = [];
+  for (const item of v) {
+    if (typeof item === "string" && isDisplaySafeName(item)) out.push(item);
+  }
+  return out;
+}
+function readOptIns(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v))
+    return EMPTY_OPT_INS;
+  const obj = v;
+  return {
+    builtinTools: readOptInList(obj.builtinTools),
+    mcpServers: readOptInList(obj.mcpServers),
+    skills: readOptInList(obj.skills),
+    subagents: readOptInList(obj.subagents),
+    slashCommands: readOptInList(obj.slashCommands)
+  };
+}
+var STACK_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+function readStack(v) {
+  if (typeof v !== "object" || v === null || Array.isArray(v)) return null;
+  const obj = v;
+  if (typeof obj.name !== "string" || !isDisplaySafeName(obj.name)) return null;
+  if (typeof obj.slug !== "string" || !STACK_SLUG_RE.test(obj.slug))
+    return null;
+  return { name: obj.name, slug: obj.slug };
+}
+function readSyncConfig(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    return null;
+  const obj = raw;
+  const listRaw = obj.allowlist;
+  if (typeof listRaw !== "object" || listRaw === null) return null;
+  const list = listRaw;
+  return {
+    allowlist: {
+      mcpServers: readNameList(list.mcpServers),
+      skills: readNameList(list.skills),
+      subagents: readNameList(list.subagents),
+      slashCommands: readNameList(list.slashCommands)
+    },
+    // Anything other than an explicit `true` fails closed.
+    publishCost: obj.publishCost === true,
+    // Absent means "no stack resolved" — an anonymous fetch, or a token bound
+    // to nothing. Both fail closed to publishing no user-chosen names.
+    optIns: readOptIns(obj.optIns),
+    // Anything other than an explicit `true` keeps the names on the machine.
+    reviewKeptPrivate: obj.reviewKeptPrivate === true,
+    stack: readStack(obj.stack)
+  };
+}
+async function loadSyncConfig(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  try {
+    const res = await doFetch(`${opts.baseUrl}${SYNC_CONFIG_PATH}`, {
+      signal: AbortSignal.timeout(opts.timeoutMs ?? FETCH_TIMEOUT_MS),
+      headers: {
+        Accept: "application/json",
+        ...opts.token ? { Authorization: `Bearer ${opts.token}` } : {}
+      }
+    });
+    if (!res.ok) {
+      return {
+        config: BUNDLED_SYNC_CONFIG,
+        source: "bundled",
+        error: `sync-config returned ${res.status}`
+      };
+    }
+    const parsed = readSyncConfig(await res.json());
+    if (!parsed) {
+      return {
+        config: BUNDLED_SYNC_CONFIG,
+        source: "bundled",
+        error: "sync-config response was not the expected shape"
+      };
+    }
+    return { config: parsed, source: "fetched" };
+  } catch (err) {
+    return {
+      config: BUNDLED_SYNC_CONFIG,
+      source: "bundled",
+      error: err instanceof Error ? err.message : "sync-config fetch failed"
+    };
+  }
+}
+var PLUGIN_MCP_RE = /^plugin_([^_]+)_(.+)$/;
+var PLUGIN_PREFIX_RE = /^([^:\s]+):(.+)$/;
+function pluginGroup(name) {
+  return PLUGIN_MCP_RE.exec(name)?.[1] ?? PLUGIN_PREFIX_RE.exec(name)?.[1] ?? null;
+}
+function publishedName(name, sets) {
+  if (sets.publishable.has(name)) return name;
+  const inner = PLUGIN_MCP_RE.exec(name)?.[2];
+  if (inner && sets.curated.has(inner)) return inner;
+  return null;
+}
+function filterAtoms(atoms, sets) {
+  const merged = /* @__PURE__ */ new Map();
+  const keptPrivate = [];
+  for (const atom of atoms) {
+    const published = publishedName(atom.name, sets);
+    if (published === null) {
+      keptPrivate.push({
+        name: atom.name,
+        count: atom.count,
+        group: pluginGroup(atom.name)
+      });
+      continue;
+    }
+    merged.set(published, (merged.get(published) ?? 0) + atom.count);
+  }
+  const allowed = [...merged].map(([name, count]) => ({ name, count }));
+  allowed.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  keptPrivate.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  return { allowed, keptPrivate, withheld: keptPrivate.length };
+}
+
+// src/transcripts/scan.ts
+import { createReadStream } from "fs";
+import { readdir, realpath, stat } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import path from "path";
+import readline from "readline";
+function transcriptRoots() {
+  const env = process.env.CLAUDE_CONFIG_DIR;
+  if (env) {
+    return env.split(",").map((s) => s.trim()).filter(Boolean).map((s) => path.join(s, "projects"));
+  }
+  const roots = [path.join(homedir8(), ".claude", "projects")];
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(homedir8(), ".config");
+  roots.push(path.join(xdg, "claude", "projects"));
+  return roots;
+}
+function windowStartMs(now, days) {
+  const startOfToday = Date.UTC(
+    new Date(now).getUTCFullYear(),
+    new Date(now).getUTCMonth(),
+    new Date(now).getUTCDate()
+  );
+  return startOfToday - (days - 1) * 864e5;
+}
+async function* walkJsonl(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) yield* walkJsonl(full);
+    else if (e.isFile() && e.name.endsWith(".jsonl")) yield full;
+  }
+}
+async function scan(agg, opts = {}) {
+  const stats = {
+    filesFound: 0,
+    filesRead: 0,
+    filesSkippedByMtime: 0,
+    filesSkippedAsDuplicate: 0,
+    filesUnreadable: 0
+  };
+  const visited = /* @__PURE__ */ new Set();
+  for (const root of opts.roots ?? transcriptRoots()) {
+    if (!await exists(root)) continue;
+    for await (const file of walkJsonl(root)) {
+      stats.filesFound++;
+      let resolved;
+      try {
+        resolved = await realpath(file);
+      } catch {
+        resolved = file;
+      }
+      if (visited.has(resolved)) {
+        stats.filesSkippedAsDuplicate++;
+        continue;
+      }
+      visited.add(resolved);
+      if (opts.sinceMs !== void 0) {
+        try {
+          const st = await stat(file);
+          if (st.mtimeMs < opts.sinceMs) {
+            stats.filesSkippedByMtime++;
+            continue;
+          }
+        } catch {
+        }
+      }
+      const rel = path.relative(root, file);
+      const projectDir = rel.split(path.sep)[0] ?? "(root)";
+      agg.files++;
+      stats.filesRead++;
+      if (opts.onProgress && agg.files % 200 === 0) opts.onProgress(agg.files);
+      try {
+        await ingestFile(agg, file, projectDir, opts.sinceMs);
+      } catch {
+        stats.filesUnreadable++;
+        stats.filesRead--;
+      }
+    }
+  }
+  return stats;
+}
+async function exists(p8) {
+  try {
+    await stat(p8);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ingestFile(agg, file, projectDir, sinceMs) {
+  const rl = readline.createInterface({
+    input: createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (!line) continue;
+    agg.lines++;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      agg.parseErrors++;
+      continue;
+    }
+    if (sinceMs !== void 0) {
+      const ts = rec && typeof rec === "object" && "timestamp" in rec && typeof rec.timestamp === "string" ? Date.parse(rec.timestamp) : Number.NaN;
+      if (Number.isNaN(ts) || ts < sinceMs) continue;
+    }
+    ingestRecord(agg, rec, { projectDir });
+  }
+}
+
+// src/transcripts/payload.ts
+var SCHEMA_VERSION = 1;
+var HARNESS_NAME = "claude-code";
+var MODEL_ID_UNSAFE_RE = /[^A-Za-z0-9._:-]+/g;
+var MODEL_ID_MAX = 64;
+function sanitizeModelId(id) {
+  const collapsed = cleanName(id).replace(MODEL_ID_UNSAFE_RE, "-").replace(/^-+|-+$/g, "");
+  if (collapsed.length === 0) return "unknown";
+  return collapsed.length > MODEL_ID_MAX ? collapsed.slice(0, MODEL_ID_MAX) : collapsed;
+}
+var round4 = (n) => Math.round(n * 1e4) / 1e4;
+var round2 = (n) => Math.round(n * 100) / 100;
+var utcDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+var toAtoms = (pairs) => pairs.map(([name, count]) => ({ name, count }));
+function buildCategory(observed, curated, optIns, denominator) {
+  const publishable = /* @__PURE__ */ new Set([...curated, ...optIns]);
+  const {
+    allowed: kept,
+    keptPrivate,
+    withheld
+  } = filterAtoms(toAtoms(observed), { publishable, curated });
+  return {
+    atoms: kept.map((a) => ({
+      name: a.name,
+      callShare: denominator ? round4(a.count / denominator) : 0
+    })),
+    withheld,
+    keptPrivate
+  };
+}
+var sumCounts = (pairs) => {
+  let n = 0;
+  for (const [, c] of pairs) n += c;
+  return n;
+};
+function groupModels(rows) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const id = sanitizeModelId(baseModelId(r.modelKey));
+    let g = groups.get(id);
+    if (!g) {
+      g = {
+        id,
+        totalTokens: 0,
+        input: 0,
+        output: 0,
+        cacheWrite: 0,
+        cacheRead: 0,
+        costUSD: 0,
+        unpricedTokens: 0,
+        anyUnpriceable: false
+      };
+      groups.set(id, g);
+    }
+    g.totalTokens += r.totalTokens;
+    g.input += r.tokens.input;
+    g.output += r.tokens.output;
+    g.cacheWrite += r.tokens.cacheWrite5m + r.tokens.cacheWrite1h + r.tokens.cacheWriteUnsplit;
+    g.cacheRead += r.tokens.cacheRead;
+    g.costUSD += r.costUSD ?? 0;
+    g.unpricedTokens += r.unpricedTokens;
+    if (r.costUSD === null) g.anyUnpriceable = true;
+  }
+  return [...groups.values()].sort(
+    (a, b) => b.totalTokens - a.totalTokens || a.id.localeCompare(b.id)
+  );
+}
+function buildModels(rows, totalTokens, publishCost) {
+  return groupModels(rows).map((g) => {
+    const model = {
+      id: g.id,
+      tokenShare: totalTokens ? round4(g.totalTokens / totalTokens) : 0,
+      tokens: {
+        input: g.input,
+        output: g.output,
+        cacheWrite: g.cacheWrite,
+        cacheRead: g.cacheRead
+      }
+    };
+    if (publishCost && !g.anyUnpriceable && g.unpricedTokens === 0) {
+      model.apiEquivalentUSD = round2(g.costUSD);
+    }
+    return model;
+  });
+}
+function buildPayload(input) {
+  const { aggregate: agg, stats, syncConfig, now, windowDays } = input;
+  const finalized = finalize(agg);
+  const { publishCost, allowlist, optIns } = syncConfig;
+  const fromMs = windowStartMs(now, windowDays);
+  const from = utcDate(fromMs);
+  const to = utcDate(now);
+  let activeDays = 0;
+  for (const d of agg.activeDays) if (d >= from && d <= to) activeDays++;
+  const totalToolCalls = finalized.totalToolCalls;
+  const builtins = buildCategory(
+    finalized.tools,
+    BUILTIN_TOOLS,
+    optIns.builtinTools,
+    totalToolCalls
+  );
+  const mcp = buildCategory(
+    finalized.mcpServers,
+    new Set(allowlist.mcpServers),
+    optIns.mcpServers,
+    sumCounts(finalized.mcpServers)
+  );
+  const skills = buildCategory(
+    finalized.skills,
+    new Set(allowlist.skills),
+    optIns.skills,
+    sumCounts(finalized.skills)
+  );
+  const subagents = buildCategory(
+    finalized.subagents,
+    new Set(allowlist.subagents),
+    optIns.subagents,
+    sumCounts(finalized.subagents)
+  );
+  const slash = buildCategory(
+    finalized.slashCommands,
+    new Set(allowlist.slashCommands),
+    optIns.slashCommands,
+    sumCounts(finalized.slashCommands)
+  );
+  const payload = {
+    schemaVersion: SCHEMA_VERSION,
+    capturedAt: now,
+    window: { days: windowDays, from, to },
+    harness: {
+      name: HARNESS_NAME,
+      version: finalized.harnessVersion === null ? null : sanitizeModelId(finalized.harnessVersion)
+    },
+    pricingTable: publishCost ? PRICING_TABLE_VERSION : null,
+    activity: {
+      sessions: finalized.sessions,
+      activeDays,
+      projects: finalized.projects,
+      totalTokens: finalized.totalTokens,
+      cacheHitShare: round4(finalized.cacheHitShare),
+      subagentShare: round4(finalized.sidechainShare)
+    },
+    models: buildModels(finalized.models, finalized.totalTokens, publishCost),
+    inventory: {
+      builtinTools: builtins.atoms,
+      mcpServers: mcp.atoms,
+      skills: skills.atoms,
+      subagents: subagents.atoms,
+      slashCommands: slash.atoms,
+      withheld: {
+        builtinTools: builtins.withheld,
+        mcpServers: mcp.withheld,
+        skills: skills.withheld,
+        subagents: subagents.withheld,
+        slashCommands: slash.withheld
+      }
+    },
+    coverage: {
+      filesScanned: stats.filesRead,
+      filesUnreadable: stats.filesUnreadable,
+      linesParsed: agg.lines - agg.parseErrors,
+      linesFailed: agg.parseErrors
+    },
+    excludedTokens: {
+      unpriced: finalized.unpricedTokens,
+      synthetic: agg.syntheticTokens
+    }
+  };
+  return {
+    payload,
+    finalized,
+    keptPrivate: {
+      builtinTools: builtins.keptPrivate,
+      mcpServers: mcp.keptPrivate,
+      skills: skills.keptPrivate,
+      subagents: subagents.keptPrivate,
+      slashCommands: slash.keptPrivate
+    }
+  };
+}
+function buildSyncBody(built, syncConfig) {
+  if (!syncConfig.reviewKeptPrivate) return { payload: built.payload };
+  return { payload: built.payload, keptPrivate: built.keptPrivate };
+}
+
+// src/transcripts/index.ts
+var DEFAULT_WINDOW_DAYS = 30;
+
+// src/sync/summary.ts
+function fmtTokens(n) {
+  const sig = (v) => {
+    const s = v.toPrecision(3);
+    return s.includes(".") ? s.replace(/\.?0+$/, "") : s;
+  };
+  if (n >= 1e9) return `${sig(n / 1e9)}B`;
+  if (n >= 1e6) return `${sig(n / 1e6)}M`;
+  if (n >= 1e3) return `${sig(n / 1e3)}k`;
+  return String(n);
+}
+function fmtUSD(n) {
+  return `\u2248$${Math.round(n).toLocaleString("en-US")}`;
+}
+var fmtPct = (share) => `${(share * 100).toFixed(1)}%`;
+function totalUSD(payload) {
+  if (payload.pricingTable === null) return null;
+  let sum = 0;
+  let any = false;
+  for (const m of payload.models) {
+    if (m.apiEquivalentUSD !== void 0) {
+      sum += m.apiEquivalentUSD;
+      any = true;
+    }
+  }
+  return any ? sum : null;
+}
+function withheldCount(payload) {
+  const w = payload.inventory.withheld;
+  return w.builtinTools + w.mcpServers + w.skills + w.subagents + w.slashCommands;
+}
+function buildGateDialog(ctx) {
+  const { payload, keptPrivate } = ctx.body;
+  const usd = totalUSD(payload);
+  const facts = [
+    `${fmtTokens(payload.activity.totalTokens)} tokens`,
+    `${payload.window.days} days`,
+    ...usd === null ? [] : [fmtUSD(usd)]
+  ].join(" \xB7 ");
+  const n = withheldCount(payload);
+  const lines2 = [`Publish to aistack? ${facts}`];
+  if (n > 0) {
+    lines2.push(
+      keptPrivate === void 0 ? `${n} name${n === 1 ? "" : "s"} stay${n === 1 ? "s" : ""} on this machine` : `${n} name${n === 1 ? "" : "s"} go${n === 1 ? "es" : ""} up for you to review`
+    );
+  }
+  return lines2.join("\n");
+}
+var CATEGORY_LABEL = {
+  builtinTools: "tools",
+  mcpServers: "mcp",
+  skills: "skills",
+  subagents: "agents",
+  slashCommands: "commands"
+};
+function keptPrivateRows(keptPrivate) {
+  const groups = /* @__PURE__ */ new Map();
+  const singles = [];
+  for (const category of NAME_CATEGORIES) {
+    for (const atom of keptPrivate[category]) {
+      if (atom.group === null) singles.push(atom.name);
+      else groups.set(atom.group, (groups.get(atom.group) ?? 0) + 1);
+    }
+  }
+  const rows = [...groups].map(([label, names]) => ({ label, names }));
+  for (const name of singles) rows.push({ label: name, names: 1 });
+  rows.sort((a, b) => b.names - a.names || a.label.localeCompare(b.label));
+  return rows;
+}
+var KEPT_PRIVATE_ROWS_SHOWN = 6;
+function buildGateSummary(ctx) {
+  const { body, keptPrivate, config, source, baseUrl } = ctx;
+  const { payload } = body;
+  const host = baseUrl.replace(/^https?:\/\//, "");
+  const out = [];
+  out.push("from your machine \u2014 sync preview");
+  out.push("");
+  if (config.stack === null) {
+    out.push("to        (no linked stack \u2014 publish is unavailable)");
+  } else {
+    out.push(
+      `to        ${config.stack.name} \xB7 ${host}/stacks/${config.stack.slug}`
+    );
+  }
+  out.push(
+    `window    ${payload.window.days} days \xB7 ${payload.window.from} \u2192 ${payload.window.to}`
+  );
+  out.push(
+    `activity  ${payload.activity.sessions} sessions \xB7 ${payload.activity.activeDays} active days \xB7 ${fmtTokens(payload.activity.totalTokens)} tokens`
+  );
+  const usd = totalUSD(payload);
+  out.push(
+    usd === null ? "cost      not published" : `cost      ${fmtUSD(usd)} at API prices`
+  );
+  const cov = payload.coverage;
+  if (cov.filesUnreadable > 0 || cov.linesFailed > 0) {
+    out.push(
+      `coverage  ${cov.filesUnreadable} files unreadable \xB7 ${cov.linesFailed} lines failed \u2014 this reading is a floor`
+    );
+  }
+  out.push("");
+  out.push("models");
+  for (const m of payload.models) {
+    const dollars = usd !== null && m.apiEquivalentUSD !== void 0 ? `   ${fmtUSD(m.apiEquivalentUSD)}` : "";
+    out.push(`  ${m.id.padEnd(28)} ${fmtPct(m.tokenShare)}${dollars}`);
+  }
+  out.push("");
+  out.push("what publishes");
+  for (const category of NAME_CATEGORIES) {
+    const atoms = payload.inventory[category];
+    if (atoms.length === 0) continue;
+    const names = atoms.map((a) => a.name).join(", ");
+    out.push(`  ${CATEGORY_LABEL[category].padEnd(9)} ${names}`);
+  }
+  const n = withheldCount(payload);
+  if (n > 0) {
+    out.push("");
+    out.push(`kept private: ${n} name${n === 1 ? "" : "s"}`);
+    const rows = keptPrivateRows(keptPrivate);
+    const shown = rows.slice(0, KEPT_PRIVATE_ROWS_SHOWN);
+    const width = Math.max(...shown.map((r) => r.label.length));
+    for (const row of shown) {
+      out.push(`  ${row.label.padEnd(width)}  ${row.names}`);
+    }
+    if (rows.length > shown.length) {
+      out.push(`  ...${rows.length - shown.length} more`);
+    }
+    if (body.keptPrivate !== void 0 && config.stack !== null) {
+      out.push(`  publish them at ${host}/stacks/${config.stack.slug}/changes`);
+      out.push(
+        "  (they go up for you to review \u2014 turn off: Review kept-private names, on your stack)"
+      );
+    } else {
+      out.push("  they stay on this machine");
+    }
+  }
+  if (source === "bundled") {
+    out.push("");
+    out.push(
+      "! could not fetch your settings from aistack \u2014 using the bundled list."
+    );
+    out.push(
+      "  This publishes less: no cost, no ticked names, nothing staged for review."
+    );
+  }
+  return out.join("\n");
+}
+
+// src/sync/stage.ts
+function stageId(bodyJson) {
+  return createHash("sha256").update(bodyJson).digest("hex").slice(0, 12);
+}
+async function stageSync(deps) {
+  const now = (deps.now ?? Date.now)();
+  const token = (deps.getTokenImpl ?? getToken)();
+  const loadConfig = deps.loadConfigImpl ?? loadSyncConfig;
+  const doScan = deps.scanImpl ?? scan;
+  const windowDays = deps.windowDays ?? DEFAULT_WINDOW_DAYS;
+  const { config, source } = await loadConfig({
+    baseUrl: deps.baseUrl,
+    ...token ? { token } : {}
+  });
+  const aggregate = createAggregate();
+  const stats = await doScan(aggregate, {
+    sinceMs: windowStartMs(now, windowDays)
+  });
+  const built = buildPayload({
+    aggregate,
+    stats,
+    syncConfig: config,
+    now,
+    windowDays
+  });
+  const body = buildSyncBody(built, config);
+  const bodyJson = JSON.stringify(body);
+  const ctx = {
+    body,
+    keptPrivate: built.keptPrivate,
+    config,
+    source,
+    baseUrl: deps.baseUrl
+  };
+  let blockedReason = null;
+  if (token === null) {
+    blockedReason = "This machine is not linked. Run `npx @use-aistack/cli login` first.";
+  } else if (config.stack === null) {
+    blockedReason = source === "bundled" ? "Could not fetch your settings from aistack, so the destination stack is unknown. Publish needs it. Check the network and preview again." : "The token resolves no destination stack. Run `npx @use-aistack/cli login` again to re-link this machine.";
+  }
+  return {
+    id: stageId(bodyJson),
+    bodyJson,
+    body,
+    keptPrivate: built.keptPrivate,
+    summary: buildGateSummary(ctx),
+    dialog: buildGateDialog(ctx),
+    config,
+    token,
+    stagedAt: now,
+    blockedReason
+  };
+}
+
+// src/autosync/run.ts
+var SYNC_LOG_FILE = join9(homedir9(), ".config", "aistack", "sync.log");
+var SYNC_LOG_MAX_LINES = 200;
+var FIX_COMMAND = "npx @use-aistack/cli sync";
+function appendLogLine(file, line) {
+  mkdirSync4(dirname6(file), { recursive: true });
+  appendFileSync(file, `${line}
+`);
+  const lines2 = readFileSync8(file, "utf-8").split("\n").filter(Boolean);
+  if (lines2.length > SYNC_LOG_MAX_LINES) {
+    writeFileSync4(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
+`);
+  }
+}
+async function runAutoSync(deps) {
+  const now = (deps.now ?? Date.now)();
+  const settingsFile = deps.settingsFile;
+  const logFile = deps.logFile ?? SYNC_LOG_FILE;
+  const emit = deps.emit ?? ((line) => process.stdout.write(`${line}
+`));
+  const stamp = new Date(now).toISOString();
+  const settings = getSettings(settingsFile);
+  const config = settings.autoSync;
+  if (config?.enabled !== true) {
+    appendLogLine(logFile, `${stamp} skipped \u2014 auto-sync is not enabled`);
+    return;
+  }
+  const frequencyHours = config.frequencyHours || DEFAULT_FREQUENCY_HOURS;
+  const state = settings.autoSyncState ?? {};
+  const lastRunAt = state.lastRunAt ?? 0;
+  if (now - lastRunAt < frequencyHours * 36e5) return;
+  const stage = deps.stageImpl ?? stageSync;
+  const publish = deps.publishImpl ?? syncPublish;
+  let failure2 = null;
+  let url;
+  try {
+    const staged = await stage({ baseUrl: deps.baseUrl, now: () => now });
+    if (staged.blockedReason !== null) {
+      failure2 = staged.blockedReason;
+    } else {
+      const res = await publish(staged.token, staged.bodyJson);
+      url = res.url;
+    }
+  } catch (e) {
+    failure2 = e instanceof Error ? e.message : String(e);
+  }
+  if (failure2 === null) {
+    saveSettings(
+      {
+        autoSyncState: {
+          lastRunAt: now,
+          lastSuccessAt: now,
+          lastResult: `ok \u2014 published at ${stamp}`,
+          consecutiveFailures: 0,
+          failureWarned: false
+        }
+      },
+      settingsFile
+    );
+    appendLogLine(logFile, `${stamp} ok \u2014 published${url ? ` ${url}` : ""}`);
+    return;
+  }
+  const consecutiveFailures = (state.consecutiveFailures ?? 0) + 1;
+  const shouldWarn = consecutiveFailures >= 3 && state.failureWarned !== true;
+  saveSettings(
+    {
+      autoSyncState: {
+        ...state,
+        lastRunAt: now,
+        lastResult: `failed at ${stamp} \u2014 ${failure2}`,
+        consecutiveFailures,
+        failureWarned: state.failureWarned === true || shouldWarn
+      }
+    },
+    settingsFile
+  );
+  appendLogLine(
+    logFile,
+    `${stamp} fail (${consecutiveFailures} in a row) \u2014 ${failure2}`
+  );
+  if (shouldWarn) {
+    emit(
+      JSON.stringify({
+        systemMessage: `aistack auto-sync failed ${consecutiveFailures} times in a row (${failure2}). Run \`${FIX_COMMAND}\` in a terminal to fix it, or \`${FIX_COMMAND} --auto off\` to stop these runs.`
+      })
+    );
+  }
+}
+
+// src/commands/sync.ts
+async function syncCommand(options = {}) {
+  if (options.auto === true) {
+    await runAutoSync({ baseUrl: BASE_URL });
+    return;
+  }
+  if (options.auto === "on" || options.auto === "off") {
+    intro2("sync");
+    const result = options.auto === "on" ? enableAutoSync(
+      options.every ? Number.parseInt(options.every, 10) || DEFAULT_FREQUENCY_HOURS : DEFAULT_FREQUENCY_HOURS
+    ) : disableAutoSync();
+    if (result.ok) {
+      p7.log.success(result.message);
+      outro2("done");
+    } else {
+      outroError(result.message);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (options.auto !== void 0) {
+    intro2("sync");
+    outroError(`unknown --auto value "${options.auto}" \u2014 use on or off`);
+    process.exitCode = 1;
+    return;
+  }
+  intro2("sync");
+  const lastAuto = getSettings().autoSyncState?.lastResult;
+  if (lastAuto !== void 0) {
+    p7.log.message(dim(`auto-sync: ${lastAuto}`));
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    outroError("sync needs an interactive terminal \u2014 nothing was sent");
+    process.exitCode = 1;
+    return;
+  }
+  const s = p7.spinner();
+  s.start("Scanning local Claude Code transcripts");
+  let staged;
+  try {
+    staged = await stageSync({ baseUrl: BASE_URL });
+  } catch (e) {
+    s.stop("Scan failed");
+    outroError(e instanceof Error ? e.message : String(e));
+    process.exitCode = 1;
+    return;
+  }
+  s.stop("Scan complete");
+  p7.log.message(staged.summary.split("\n").join("\n"));
+  if (staged.blockedReason !== null) {
+    outroError(staged.blockedReason);
+    process.exitCode = 1;
+    return;
+  }
+  const decision = await p7.select({
+    message: staged.dialog.split("\n").join(dim(" \xB7 ")),
+    options: [
+      { value: "cancel", label: "Cancel", hint: "nothing leaves this machine" },
+      { value: "publish", label: "Publish" }
+    ],
+    initialValue: "cancel"
+  });
+  if (p7.isCancel(decision) || decision !== "publish") {
+    outroCancel("nothing was sent");
+    return;
+  }
+  s.start("Publishing");
+  try {
+    const res = await syncPublish(staged.token, staged.bodyJson);
+    s.stop("Published");
+    const lines2 = [
+      `Snapshot received at ${new Date(res.receivedAt).toISOString()}`,
+      lime(res.url)
+    ];
+    if (res.keptPrivate.refused && staged.body.keptPrivate !== void 0) {
+      lines2.push(
+        "Note: the kept-private names were refused by the server \u2014 the review switch is off there now. They stayed on this machine."
+      );
+    } else if (res.keptPrivate.stored > 0) {
+      lines2.push(
+        `${res.keptPrivate.stored} kept-private names went up for your review at ${res.url}/changes`
+      );
+    }
+    p7.log.message(lines2.join("\n"));
+    const asked = await offerAutoSyncOptIn();
+    if (!asked) await offerConnectUpsell();
+    outro2("done");
+  } catch (e) {
+    s.stop("Publish failed");
+    outroError(e instanceof Error ? e.message : String(e));
+    process.exitCode = 1;
+  }
+}
+
+// src/sync/server.ts
+var SERVER_NAME = "aistack";
+var SERVER_VERSION = "0.3.0";
+var STAGE_TTL_MS = 10 * 60 * 1e3;
+var ELICIT_TIMEOUT_MS = 10 * 60 * 1e3;
+var PREVIEW_TOOL = {
+  name: "sync_preview",
+  description: "Scan local Claude Code transcripts and stage a measured-usage snapshot for aistack. Returns the full preview of exactly what would publish. Show the returned text to the user VERBATIM \u2014 it is the review surface. Nothing is sent.",
+  inputSchema: { type: "object", properties: {} },
+  annotations: {
+    title: "aistack \u2014 preview sync (sends nothing)",
+    readOnlyHint: true,
+    openWorldHint: true
+  }
+};
+var PUBLISH_TOOL = {
+  name: "sync_publish",
+  description: "Publish the staged aistack snapshot named by preview_id. Asks the user for confirmation during the call; only their explicit choice sends anything. Call sync_preview first and show its output.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      preview_id: {
+        type: "string",
+        description: "The `preview id` line from sync_preview's output."
+      }
+    },
+    required: ["preview_id"]
+  },
+  annotations: {
+    title: "aistack \u2014 publish measured usage (asks the user first)",
+    destructiveHint: false,
+    openWorldHint: true
+  }
+};
+var textResult = (text, isError = false) => ({
+  content: [{ type: "text", text }],
+  ...isError ? { isError: true } : {}
+});
+function createSyncServer(deps, send) {
+  const now = deps.now ?? Date.now;
+  const stage = deps.stageImpl ?? stageSync;
+  const publish = deps.publishImpl ?? syncPublish;
+  const log7 = deps.log ?? (() => {
+  });
+  const elicitTimeoutMs = deps.elicitTimeoutMs ?? ELICIT_TIMEOUT_MS;
+  let clientSupportsElicitation = false;
+  let staged = null;
+  let nextRequestId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
+  const err = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+  const request2 = (method, params, onReply) => {
+    const id = `aistack-${nextRequestId++}`;
+    pending.set(id, onReply);
+    send({ jsonrpc: "2.0", id, method, params });
+    const timer = setTimeout(() => {
+      if (pending.delete(id)) onReply(null);
+    }, elicitTimeoutMs);
+    timer.unref?.();
+  };
+  const runPreview = async (id) => {
+    try {
+      staged = await stage({ baseUrl: deps.baseUrl, now });
+    } catch (e) {
+      staged = null;
+      const message = e instanceof Error ? e.message : String(e);
+      return ok(id, textResult(`Preview failed: ${message}`, true));
+    }
+    const lines2 = [staged.summary, ""];
+    if (staged.blockedReason === null) {
+      lines2.push(`preview id: ${staged.id}`);
+      lines2.push(
+        "To publish, call sync_publish with this preview id. The user confirms in a dialog during that call."
+      );
+    } else {
+      lines2.push(`publish unavailable: ${staged.blockedReason}`);
+    }
+    return ok(id, textResult(lines2.join("\n")));
+  };
+  const runPublish = (id, args) => {
+    if (!clientSupportsElicitation) {
+      return ok(
+        id,
+        textResult(
+          "Not published: this Claude Code version did not declare the elicitation capability, so the approve dialog cannot be shown. The gate never degrades silently \u2014 update Claude Code and try again.",
+          true
+        )
+      );
+    }
+    const previewId = args?.preview_id;
+    if (staged === null) {
+      return ok(
+        id,
+        textResult(
+          "Not published: nothing is staged. Run sync_preview first and show its output to the user.",
+          true
+        )
+      );
+    }
+    if (typeof previewId !== "string" || previewId !== staged.id) {
+      return ok(
+        id,
+        textResult(
+          "Not published: preview_id does not match the staged preview. Run sync_preview again.",
+          true
+        )
+      );
+    }
+    if (staged.blockedReason !== null) {
+      return ok(id, textResult(`Not published: ${staged.blockedReason}`, true));
+    }
+    if (now() - staged.stagedAt > STAGE_TTL_MS) {
+      staged = null;
+      return ok(
+        id,
+        textResult(
+          "Not published: the staged preview is older than 10 minutes. Run sync_preview again so the user reviews current bytes.",
+          true
+        )
+      );
+    }
+    const approvedStage = staged;
+    log7(`elicitation raised for stage ${approvedStage.id}`);
+    request2(
+      "elicitation/create",
+      {
+        message: approvedStage.dialog,
+        requestedSchema: {
+          type: "object",
+          properties: {
+            decision: {
+              type: "string",
+              // The enum widget is the one that works (#35, 1G). Never a boolean.
+              enum: ["publish", "cancel"],
+              description: "Publish the snapshot described above?"
+            }
+          },
+          required: ["decision"]
+        }
+      },
+      (reply) => {
+        const result = reply?.result;
+        const approved = result?.action === "accept" && result?.content?.decision === "publish";
+        if (!approved) {
+          const outcome = reply === null ? "timed out" : result?.action ?? "error";
+          log7(`elicitation resolved without consent: ${outcome}`);
+          return ok(
+            id,
+            textResult(
+              `Not published: the confirmation was not accepted (${outcome}). Nothing left this machine.`
+            )
+          );
+        }
+        log7(`consent received, sending stage ${approvedStage.id}`);
+        publish(approvedStage.token, approvedStage.bodyJson).then(
+          (res) => {
+            if (staged?.id === approvedStage.id) staged = null;
+            const lines2 = [
+              `Published. Snapshot received at ${new Date(res.receivedAt).toISOString()}.`,
+              res.url
+            ];
+            const kp = approvedStage.body.keptPrivate;
+            if (res.keptPrivate.refused && kp !== void 0) {
+              lines2.push(
+                "Note: the kept-private names were refused by the server \u2014 the review switch is off there now. They stayed on this machine."
+              );
+            } else if (res.keptPrivate.stored > 0) {
+              lines2.push(
+                `${res.keptPrivate.stored} kept-private names went up for your review at ${res.url}/changes`
+              );
+            }
+            ok(id, textResult(lines2.join("\n")));
+          },
+          (e) => {
+            const message = e instanceof Error ? e.message : String(e);
+            ok(
+              id,
+              textResult(`Publish failed after consent: ${message}`, true)
+            );
+          }
+        );
+      }
+    );
+  };
+  const handle = (msg) => {
+    const { id, method, params } = msg;
+    if (method === void 0 && id !== void 0 && pending.has(String(id))) {
+      const onReply = pending.get(String(id));
+      pending.delete(String(id));
+      onReply?.(msg);
+      return;
+    }
+    switch (method) {
+      case "initialize": {
+        const capabilities = params?.capabilities ?? {};
+        clientSupportsElicitation = "elicitation" in capabilities;
+        log7(
+          `initialize: elicitation ${clientSupportsElicitation ? "declared" : "ABSENT"}`
+        );
+        return ok(id, {
+          protocolVersion: params?.protocolVersion ?? "2025-06-18",
+          capabilities: { tools: { listChanged: false } },
+          serverInfo: { name: SERVER_NAME, version: SERVER_VERSION }
+        });
+      }
+      case "ping":
+        return ok(id, {});
+      case "tools/list":
+        return ok(id, { tools: [PREVIEW_TOOL, PUBLISH_TOOL] });
+      case "tools/call": {
+        const name = params?.name;
+        const args = params?.arguments;
+        if (name === "sync_preview") return void runPreview(id);
+        if (name === "sync_publish") return runPublish(id, args);
+        return err(id, -32602, `Unknown tool: ${String(name)}`);
+      }
+      default:
+        if (method?.startsWith("notifications/")) return;
+        if (method !== void 0)
+          return err(id, -32601, `Method not found: ${method}`);
+    }
+  };
+  return { handle, staged: () => staged };
+}
+function runStdioSyncServer(deps) {
+  const server = createSyncServer(deps, (msg) => {
+    process.stdout.write(`${JSON.stringify(msg)}
+`);
+  });
+  let buffer = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    let nl = buffer.indexOf("\n");
+    while (nl !== -1) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (line) {
+        try {
+          server.handle(JSON.parse(line));
+        } catch (e) {
+          deps.log?.(`parse error: ${String(e)}`);
+        }
+      }
+      nl = buffer.indexOf("\n");
+    }
+  });
+}
+
 // src/index.ts
 var program = new Command();
-program.name("aistack").description("Share and clone AI development configurations").version("0.1.0");
+program.name("aistack").description("Measure and share your AI stack from your terminal").version("0.5.0");
 program.command("login").description("Authenticate with AI Stack").action(loginCommand);
 program.command("collect").description("Scan and upload AI config files from your project").option("--no-global", "Exclude global config files (~/.claude, etc.)").action((options) => collectCommand({ global: options.global ?? true }));
-program.command("create").description("Download and write AI config files from a shared project").argument("<slug>", "Project slug or short ID").action(createCommand);
+program.command("create").description("Download and write your stack's AI config files").action(createCommand);
+program.command("mcp").description(
+  "Run the aistack MCP server on stdio (sync preview + gated publish)"
+).action(() => {
+  runStdioSyncServer({
+    baseUrl: BASE_URL,
+    log: (line) => process.stderr.write(`[aistack-mcp] ${line}
+`)
+  });
+});
+program.command("sync").description("Scan, preview, and publish measured usage (rolling 30 days)").option(
+  "--auto [state]",
+  "silent background sync; 'on' enables the SessionStart hook, 'off' revokes it"
+).option(
+  "--every <hours>",
+  "with --auto on: hours between auto-syncs (default 24)"
+).action((options) => syncCommand(options));
+program.command("connect").description("Install the in-session sync surface (MCP server + Skill)").argument("<harness>", 'the harness to connect ("claude")').action(connectCommand);
 program.parse();
 //# sourceMappingURL=index.js.map