@use-aistack/cli 0.4.0 → 0.6.0

package/dist/index.js

@@ -5,8 +5,8 @@ import { Command } from "commander";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
-async function request(path2, options = {}) {
-  return fetch(`${BASE_URL}${path2}`, {
+async function request(path3, options = {}) {
+  return fetch(`${BASE_URL}${path3}`, {
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -182,39 +182,67 @@ function classify(files) {
 // 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");
-function getSettings() {
-  if (!existsSync(SETTINGS_FILE)) return {};
+var DEFAULT_FREQUENCY_HOURS = 24;
+function getSettings(file = SETTINGS_FILE) {
+  if (!existsSync(file)) return {};
   try {
-    const raw = JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
   }
 }
-function saveSettings(patch) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
+function saveSettings(patch, file = SETTINGS_FILE) {
+  mkdirSync(dirname2(file), { recursive: true });
   writeFileSync(
-    SETTINGS_FILE,
-    JSON.stringify({ ...getSettings(), ...patch }, null, 2)
+    file,
+    JSON.stringify({ ...getSettings(file), ...patch }, null, 2)
   );
 }
 var PROJECTS_FILE = join(CONFIG_DIR, "projects.json");
@@ -291,9 +319,9 @@ function canonicalizeRepoUrl(input) {
 function repoNameFromCanonical(canonical) {
   return parseRepo(canonical)?.repo ?? "";
 }
-function normalizeUpstreamPath(path2) {
-  if (!path2) return "";
-  return path2.split("/").filter(Boolean).join("/");
+function normalizeUpstreamPath(path3) {
+  if (!path3) return "";
+  return path3.split("/").filter(Boolean).join("/");
 }
 
 // src/git.ts
@@ -339,16 +367,16 @@ function buildRepoLinkResource(canonical) {
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-function readJson(path2) {
+function readJson(path3) {
   try {
-    if (!existsSync2(path2)) return null;
-    return JSON.parse(readFileSync2(path2, "utf-8"));
+    if (!existsSync2(path3)) return null;
+    return JSON.parse(readFileSync2(path3, "utf-8"));
   } catch {
     return null;
   }
 }
-function hooksFrom(path2, source, out, seen) {
-  const hooks = readJson(path2)?.hooks;
+function hooksFrom(path3, source, out, seen) {
+  const hooks = readJson(path3)?.hooks;
   if (!hooks || typeof hooks !== "object") return;
   for (const [event, config] of Object.entries(hooks)) {
     const stableKey = `hooks:${source}:${event}`;
@@ -488,16 +516,16 @@ function buildMcpResource(name, group, pkg) {
     pkg
   };
 }
-function readText(path2) {
+function readText(path3) {
   try {
-    if (!existsSync3(path2)) return null;
-    return readFileSync3(path2, "utf-8");
+    if (!existsSync3(path3)) return null;
+    return readFileSync3(path3, "utf-8");
   } catch {
     return null;
   }
 }
-function readParsed(path2, parse) {
-  const raw = readText(path2);
+function readParsed(path3, parse) {
+  const raw = readText(path3);
   if (raw === null) return null;
   try {
     return parse(raw);
@@ -505,14 +533,14 @@ function readParsed(path2, parse) {
     return null;
   }
 }
-function readJson2(path2) {
-  return readParsed(path2, JSON.parse);
+function readJson2(path3) {
+  return readParsed(path3, JSON.parse);
 }
-function readYaml(path2) {
-  return readParsed(path2, parseYaml);
+function readYaml(path3) {
+  return readParsed(path3, parseYaml);
 }
-function readToml(path2) {
-  return readParsed(path2, parseToml);
+function readToml(path3) {
+  return readParsed(path3, parseToml);
 }
 function continueListToMap(file) {
   if (!file?.mcpServers?.length) return void 0;
@@ -632,8 +660,8 @@ 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 };
+    const path3 = src.replace(/^\.\//, "").replace(/\/+$/, "");
+    return { url: mpRepoUrl, path: path3 || void 0 };
   }
   if (src && typeof src === "object" && src.url) {
     return { url: src.url, path: src.path, sha: src.sha };
@@ -650,7 +678,7 @@ function resolvePluginLinks(installed, marketplaces, manifests) {
     const marketplace = key.slice(at + 1);
     const mpRepoUrl = marketplaceRepoUrl(marketplaces[marketplace]);
     const entry = manifests[marketplace]?.plugins?.find(
-      (p7) => p7.name === pluginName
+      (p8) => p8.name === pluginName
     );
     if (!entry) continue;
     const resolved = resolveSource(entry, mpRepoUrl);
@@ -670,10 +698,10 @@ function resolvePluginLinks(installed, marketplaces, manifests) {
   }
   return out;
 }
-function readJson3(path2) {
+function readJson3(path3) {
   try {
-    if (!existsSync4(path2)) return null;
-    return JSON.parse(readFileSync4(path2, "utf-8"));
+    if (!existsSync4(path3)) return null;
+    return JSON.parse(readFileSync4(path3, "utf-8"));
   } catch {
     return null;
   }
@@ -753,8 +781,8 @@ function loadGitignore(cwd) {
 }
 function readFileSafe(filePath) {
   try {
-    const stat2 = statSync(filePath);
-    if (stat2.size > MAX_FILE_SIZE) return null;
+    const stat5 = statSync(filePath);
+    if (stat5.size > MAX_FILE_SIZE) return null;
     return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
@@ -1289,7 +1317,7 @@ function diffResources(current, existing) {
 import { spawnSync } from "child_process";
 import { cpSync, existsSync as existsSync6 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+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";
@@ -1319,12 +1347,12 @@ function runClaude(args) {
 function claudeOnPath(run = runClaude) {
   return !run(["--version"]).notFound;
 }
-function findSkillSource(fromDir = dirname2(fileURLToPath(import.meta.url))) {
+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 = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -1431,7 +1459,7 @@ async function offerConnectUpsell() {
 
 // src/commands/create.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 import * as p4 from "@clack/prompts";
 async function createCommand() {
   intro2("create");
@@ -1521,7 +1549,7 @@ async function createCommand() {
   }
   for (const f of toWrite) {
     const fullPath = join7(cwd, f.path);
-    const dir = dirname3(fullPath);
+    const dir = dirname4(fullPath);
     mkdirSync2(dir, { recursive: true });
     writeFileSync2(fullPath, f.content);
   }
@@ -1602,13 +1630,289 @@ async function loginCommand() {
 }
 
 // src/commands/sync.ts
+import * as p7 from "@clack/prompts";
+
+// src/autosync/codexHook.ts
+import { createHash } from "crypto";
+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";
+function codexHome() {
+  return process.env.CODEX_HOME || join8(homedir7(), ".codex");
+}
+function codexHooksFile() {
+  return join8(codexHome(), "hooks.json");
+}
+function codexPresent() {
+  return existsSync8(codexHome());
+}
+function codexConfigFile() {
+  return join8(codexHome(), "config.toml");
+}
+var CODEX_HOOK_COMMAND = `sh -c 'setsid nohup sh -c "npx -y @use-aistack/cli@latest sync --auto || npx -y --prefer-offline @use-aistack/cli sync --auto" >/dev/null 2>&1 &'`;
+function isOurs(entry) {
+  return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
+}
+function readHooksJson(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` };
+  }
+}
+var CODEX_TRUST_INSTRUCTION = "Codex hook written \u2014 open Codex and run /hooks once to trust it, or it will not run.";
+function installCodexAutoSyncHook(file = codexHooksFile()) {
+  const read = readHooksJson(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({
+    matcher: "startup",
+    hooks: [{ type: "command", command: CODEX_HOOK_COMMAND, timeout: 30 }]
+  });
+  settings.hooks = { ...hooks, SessionStart: kept };
+  mkdirSync3(dirname5(file), { recursive: true });
+  writeFileSync3(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: CODEX_TRUST_INSTRUCTION };
+}
+function removeCodexAutoSyncHook(file = codexHooksFile()) {
+  if (!existsSync8(file))
+    return { ok: true, message: "no Codex hook to remove" };
+  const read = readHooksJson(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 Codex 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}` };
+}
+function codexAutoSyncHookInstalled(file = codexHooksFile()) {
+  const read = readHooksJson(file);
+  if ("error" in read) return false;
+  const sessionStart = read.settings.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) return false;
+  return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs(h)));
+}
+function codexHookTrusted(configFile = codexConfigFile()) {
+  let text;
+  try {
+    text = readFileSync7(configFile, "utf-8");
+  } catch {
+    return null;
+  }
+  const hash = createHash("sha256").update(CODEX_HOOK_COMMAND).digest("hex");
+  return text.includes(hash);
+}
+
+// src/autosync/optin.ts
 import * as p6 from "@clack/prompts";
 
+// src/autosync/hook.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname6, join as join9 } from "path";
+var CLAUDE_SETTINGS_FILE = join9(homedir8(), ".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 isOurs2(entry) {
+  return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
+}
+function readClaudeSettings(file) {
+  if (!existsSync9(file)) return { settings: {} };
+  try {
+    const raw = JSON.parse(readFileSync8(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) => !isOurs2(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 };
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync4(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `SessionStart hook written to ${file}` };
+}
+function removeAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  if (!existsSync9(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) => !isOurs2(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;
+  }
+  writeFileSync4(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;
+  const hasCodex = (deps.codexPresentImpl ?? codexPresent)();
+  let trustLine = null;
+  if (hasCodex) {
+    const codexResult = (deps.installCodexHook ?? installCodexAutoSyncHook)();
+    if (!codexResult.ok) return codexResult;
+    trustLine = codexResult.message;
+  }
+  saveSettings(
+    {
+      autoSyncAnswered: true,
+      autoSync: { enabled: true, frequencyHours }
+    },
+    deps.settingsFile
+  );
+  const sessionWord = hasCodex ? "Claude Code or Codex" : "Claude Code";
+  return {
+    ok: true,
+    message: [
+      `Auto-sync is on \u2014 about every ${frequencyHours}h when a ${sessionWord} session starts. Turn it off any time: npx @use-aistack/cli sync --auto off`,
+      ...trustLine ? [trustLine] : []
+    ].join("\n")
+  };
+}
+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();
+  const codexResult = (deps.codexPresentImpl ?? codexPresent)() ? (deps.removeCodexHook ?? removeCodexAutoSyncHook)() : { ok: true, message: "" };
+  const failures = [result, codexResult].filter((r) => !r.ok).map((r) => r.message);
+  if (failures.length > 0) {
+    return {
+      ok: false,
+      message: `Auto-sync is off (nothing will publish), but a hook could not be removed: ${failures.join("; ")}`
+    };
+  }
+  return { ok: true, message: "Auto-sync is off. The hooks were 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 mkdirSync5,
+  readFileSync as readFileSync10,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname7, join as join10 } from "path";
+
 // src/sync/stage.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 
-// src/transcripts/pricing.ts
+// src/harness/claude/adapter.ts
+import { stat as stat2 } from "fs/promises";
+
+// src/harness/shared/pricing.ts
 var PRICING_TABLE_VERSION = "anthropic-list-2026-07-25";
+var OPENAI_PRICING_TABLE_VERSION = "openai-list-2026-08-01";
 var CACHE_WRITE_5M_MULTIPLIER = 1.25;
 var CACHE_WRITE_1H_MULTIPLIER = 2;
 var CACHE_READ_MULTIPLIER = 0.1;
@@ -1629,7 +1933,13 @@ var PRICES = {
   // 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 }]
+  "claude-opus-4-8#fast": [{ from: null, to: null, input: 10, output: 50 }],
+  // OpenAI (Codex) — standard-context tier (<272K; observed context window is
+  // 258,400). gpt-5.3-codex and the 5.6 line have NO published price yet, so
+  // they are deliberately absent and surface as unpriced (#66 decision 6).
+  "gpt-5.5": [{ from: null, to: null, input: 5, output: 30 }],
+  "gpt-5.4": [{ from: null, to: null, input: 2.5, output: 15 }],
+  "gpt-5.4-mini": [{ from: null, to: null, input: 0.75, output: 4.5 }]
 };
 function normalizeModel(model) {
   const [base, suffix] = model.split("#");
@@ -1643,9 +1953,9 @@ function priceAt(modelKey, atMs) {
   if (atMs === null) return null;
   const periods = PRICES[modelKey];
   if (!periods) return null;
-  for (const p7 of periods) {
-    if ((p7.from === null || atMs >= p7.from) && (p7.to === null || atMs < p7.to)) {
-      return p7;
+  for (const p8 of periods) {
+    if ((p8.from === null || atMs >= p8.from) && (p8.to === null || atMs < p8.to)) {
+      return p8;
     }
   }
   return null;
@@ -1654,13 +1964,13 @@ function isPricedModel(modelKey) {
   return PRICES[modelKey] !== void 0;
 }
 function apiEquivalentCost(modelKey, t, atMs) {
-  const p7 = priceAt(modelKey, atMs);
-  if (!p7) return null;
+  const p8 = priceAt(modelKey, atMs);
+  if (!p8) return null;
   const M = 1e6;
-  return (t.input * p7.input + t.output * p7.output + (t.cacheWrite5m + t.cacheWriteUnsplit) * p7.input * CACHE_WRITE_5M_MULTIPLIER + t.cacheWrite1h * p7.input * CACHE_WRITE_1H_MULTIPLIER + t.cacheRead * p7.input * CACHE_READ_MULTIPLIER) / M;
+  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
+// src/harness/shared/aggregate.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;
@@ -1741,313 +2051,99 @@ function emptyUsage() {
   };
 }
 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);
+function addModelUsage(agg, modelKey, counts, costUSD, messages = 1) {
+  let m = agg.byModel.get(modelKey);
+  if (!m) {
+    m = emptyUsage();
+    agg.byModel.set(modelKey, m);
+  }
+  m.messages += messages;
+  m.input += counts.input;
+  m.output += counts.output;
+  m.cacheWrite5m += counts.cacheWrite5m;
+  m.cacheWrite1h += counts.cacheWrite1h;
+  m.cacheWriteUnsplit += counts.cacheWriteUnsplit;
+  m.cacheRead += counts.cacheRead;
+  if (costUSD === null) m.unpricedTokens += countsTotal(counts);
+  else m.costUSD += costUSD;
+}
+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
+    });
   }
-  const type = asStr(rec.type);
-  if (type === "assistant") ingestAssistant(agg, rec, tsMs);
-  else if (type === "user") ingestUser(agg, rec);
+  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 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;
+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;
   }
-  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;
+  return inputClass ? cacheRead / inputClass : 0;
 }
-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;
+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 t;
+  return best;
 }
-function modelKeyFor(model, speed) {
-  return normalizeModel(speed === "fast" ? `${model}#fast` : model);
+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 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((p7) => Number.parseInt(p7, 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;
+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,
@@ -2071,7 +2167,7 @@ function finalize(agg) {
   };
 }
 
-// src/transcripts/bundled-allowlist.ts
+// src/harness/shared/bundled-allowlist.ts
 var BUILTIN_SUBAGENTS = [
   "(default)",
   "claude",
@@ -2172,7 +2268,7 @@ var BUNDLED_CURATED_ALLOWLIST = {
   slashCommands: BUILTIN_SLASH_COMMANDS
 };
 
-// src/transcripts/allowlist.ts
+// src/harness/shared/allowlist.ts
 var BUILTIN_TOOLS = /* @__PURE__ */ new Set([
   "Agent",
   "Artifact",
@@ -2382,30 +2478,279 @@ function filterAtoms(atoms, sets) {
   return { allowed, keptPrivate, withheld: keptPrivate.length };
 }
 
-// src/transcripts/scan.ts
-import { createReadStream } from "fs";
-import { readdir, realpath, stat } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import path from "path";
-import readline from "readline";
+// src/harness/claude/analyzer.ts
+function createAggregate2() {
+  return createAggregate();
+}
+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]));
+  }
+}
+
+// src/harness/claude/scan.ts
+import { createReadStream } from "fs";
+import { readdir, realpath, stat } from "fs/promises";
+import { homedir as homedir9 } from "os";
+import path from "path";
+import readline from "readline";
+
+// src/harness/shared/window.ts
+var DEFAULT_WINDOW_DAYS = 30;
+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;
+}
+function emptyScanStats() {
+  return {
+    filesFound: 0,
+    filesRead: 0,
+    filesSkippedByMtime: 0,
+    filesSkippedAsDuplicate: 0,
+    filesUnreadable: 0
+  };
+}
+
+// src/harness/claude/scan.ts
 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(homedir7(), ".claude", "projects")];
-  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(homedir7(), ".config");
+  const roots = [path.join(homedir9(), ".claude", "projects")];
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(homedir9(), ".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 {
@@ -2420,13 +2765,7 @@ async function* walkJsonl(dir) {
   }
 }
 async function scan(agg, opts = {}) {
-  const stats = {
-    filesFound: 0,
-    filesRead: 0,
-    filesSkippedByMtime: 0,
-    filesSkippedAsDuplicate: 0,
-    filesUnreadable: 0
-  };
+  const stats = emptyScanStats();
   const visited = /* @__PURE__ */ new Set();
   for (const root of opts.roots ?? transcriptRoots()) {
     if (!await exists(root)) continue;
@@ -2468,9 +2807,9 @@ async function scan(agg, opts = {}) {
   }
   return stats;
 }
-async function exists(p7) {
+async function exists(p8) {
   try {
-    await stat(p7);
+    await stat(p8);
     return true;
   } catch {
     return false;
@@ -2499,9 +2838,321 @@ async function ingestFile(agg, file, projectDir, sinceMs) {
   }
 }
 
-// src/transcripts/payload.ts
+// src/harness/claude/adapter.ts
+var CLAUDE_HARNESS_NAME = "claude-code";
+async function exists2(p8) {
+  try {
+    await stat2(p8);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var claudeAdapter = {
+  name: CLAUDE_HARNESS_NAME,
+  builtinTools: BUILTIN_TOOLS,
+  pricingTableVersion: PRICING_TABLE_VERSION,
+  async detect() {
+    for (const root of transcriptRoots()) {
+      if (await exists2(root)) return true;
+    }
+    return false;
+  },
+  async scan(opts) {
+    const aggregate = createAggregate2();
+    const stats = await scan(aggregate, {
+      sinceMs: opts.sinceMs,
+      ...opts.onProgress ? { onProgress: opts.onProgress } : {}
+    });
+    return { aggregate, stats };
+  }
+};
+
+// src/harness/codex/adapter.ts
+import { stat as stat4 } from "fs/promises";
+
+// src/harness/codex/analyzer.ts
+function createAggregate3() {
+  return createAggregate();
+}
+function createFileState() {
+  return {
+    sessionId: null,
+    cliVersion: null,
+    cwd: null,
+    modelKey: null,
+    counted: false
+  };
+}
+function ingestLine(agg, raw, state, sinceMs) {
+  const rec = asObj(raw);
+  if (!rec) return;
+  agg.records++;
+  let tsMs = null;
+  const timestamp = asStr(rec.timestamp);
+  if (timestamp) {
+    const ts = Date.parse(timestamp);
+    if (!Number.isNaN(ts)) tsMs = ts;
+  }
+  const inWindow = sinceMs === void 0 || tsMs !== null && tsMs >= sinceMs;
+  const type = asStr(rec.type);
+  const payload = asObj(rec.payload);
+  if (type === "session_meta" && payload) {
+    state.sessionId = asStr(payload.id) ?? asStr(payload.session_id) ?? state.sessionId;
+    state.cliVersion = asStr(payload.cli_version) ?? state.cliVersion;
+    state.cwd = asStr(payload.cwd) ?? state.cwd;
+  } else if (type === "turn_context" && payload) {
+    const model = asName(payload.model);
+    if (model) state.modelKey = normalizeModel(model);
+  }
+  if (!inWindow) return;
+  if (tsMs !== null && timestamp) {
+    agg.activeDays.add(timestamp.slice(0, 10));
+    agg.firstTs = agg.firstTs === null ? tsMs : Math.min(agg.firstTs, tsMs);
+    agg.lastTs = agg.lastTs === null ? tsMs : Math.max(agg.lastTs, tsMs);
+  }
+  noteActivity(agg, state);
+  if (type === "event_msg" && payload) ingestEvent(agg, payload, state, tsMs);
+  else if (type === "response_item" && payload) ingestItem(agg, payload);
+}
+function noteActivity(agg, state) {
+  if (state.counted) return;
+  state.counted = true;
+  if (state.sessionId) agg.sessions.add(state.sessionId);
+  if (state.cliVersion) agg.ccVersions.add(cleanName(state.cliVersion));
+  agg.projectDirs.add(state.cwd ?? "(unknown)");
+}
+function ingestEvent(agg, payload, state, tsMs) {
+  if (asStr(payload.type) !== "token_count") return;
+  const info = asObj(payload.info);
+  const last = info ? asObj(info.last_token_usage) : null;
+  if (!last) return;
+  const inputTotal = asNum(last.input_tokens);
+  const cached = Math.min(asNum(last.cached_input_tokens), inputTotal);
+  const counts = {
+    input: inputTotal - cached,
+    output: asNum(last.output_tokens),
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: 0,
+    cacheRead: cached
+  };
+  const total = countsTotal(counts);
+  if (total === 0) return;
+  if (tsMs === null) agg.untimestampedResponses++;
+  agg.distinctResponses++;
+  const modelKey = state.modelKey ?? "(unknown)";
+  addModelUsage(
+    agg,
+    modelKey,
+    counts,
+    apiEquivalentCost(modelKey, counts, tsMs)
+  );
+  agg.mainTokens += total;
+}
+function ingestCall(agg, name, callId) {
+  if (callId) {
+    if (agg.toolCallDedup.has(callId)) return;
+    agg.toolCallDedup.add(callId);
+  }
+  const sep = name.indexOf("__");
+  if (sep > 0) {
+    bump(agg.mcpServerCalls, cleanName(name.slice(0, sep)));
+    bump(agg.mcpToolCalls, cleanName(name));
+    return;
+  }
+  bump(agg.toolCalls, cleanName(name));
+}
+function ingestItem(agg, payload) {
+  const type = asStr(payload.type);
+  if (type === "function_call" || type === "custom_tool_call") {
+    const name = asName(payload.name);
+    if (!name) return;
+    ingestCall(agg, name, asStr(payload.call_id) ?? asStr(payload.id));
+    return;
+  }
+  if (type === "local_shell_call") {
+    ingestCall(agg, "local_shell", asStr(payload.call_id) ?? asStr(payload.id));
+  } else if (type === "web_search_call") {
+    agg.webSearchRequests++;
+    ingestCall(agg, "web_search", asStr(payload.id));
+  } else if (type === "tool_search_call") {
+    ingestCall(agg, "tool_search", asStr(payload.id));
+  }
+}
+function noteConfiguredMcpServers(agg, serverNames) {
+  for (const raw of serverNames) {
+    const name = cleanName(raw);
+    if (!agg.mcpServerCalls.has(name)) agg.mcpServerCalls.set(name, 0);
+  }
+}
+
+// src/harness/codex/scan.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { readdir as readdir2, realpath as realpath2, stat as stat3 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import path2 from "path";
+import * as zlib from "zlib";
+import { parse as parseToml2 } from "smol-toml";
+function codexHome2() {
+  return process.env.CODEX_HOME || path2.join(homedir10(), ".codex");
+}
+function rolloutRoots() {
+  return [path2.join(codexHome2(), "sessions")];
+}
+var ROLLOUT_RE = /^rollout-.*\.jsonl(\.zst)?$/;
+async function* walkRollouts(dir) {
+  let entries;
+  try {
+    entries = await readdir2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const full = path2.join(dir, e.name);
+    if (e.isDirectory()) yield* walkRollouts(full);
+    else if (e.isFile() && ROLLOUT_RE.test(e.name)) yield full;
+  }
+}
+var zstdDecompress = typeof zlib.zstdDecompressSync === "function" ? (buf) => zlib.zstdDecompressSync(buf) : null;
+async function scan2(agg, opts = {}) {
+  const stats = emptyScanStats();
+  const visited = /* @__PURE__ */ new Set();
+  for (const root of opts.roots ?? rolloutRoots()) {
+    if (!await exists3(root)) continue;
+    for await (const file of walkRollouts(root)) {
+      stats.filesFound++;
+      let resolved;
+      try {
+        resolved = await realpath2(file);
+      } catch {
+        resolved = file;
+      }
+      if (visited.has(resolved)) {
+        stats.filesSkippedAsDuplicate++;
+        continue;
+      }
+      visited.add(resolved);
+      if (opts.sinceMs !== void 0) {
+        try {
+          const st = await stat3(file);
+          if (st.mtimeMs < opts.sinceMs) {
+            stats.filesSkippedByMtime++;
+            continue;
+          }
+        } catch {
+        }
+      }
+      agg.files++;
+      stats.filesRead++;
+      if (opts.onProgress && agg.files % 200 === 0) opts.onProgress(agg.files);
+      try {
+        ingestFile2(agg, file, opts.sinceMs);
+      } catch {
+        stats.filesUnreadable++;
+        stats.filesRead--;
+      }
+    }
+  }
+  readConfiguredMcpServers(agg, opts.configFile);
+  return stats;
+}
+async function exists3(p8) {
+  try {
+    await stat3(p8);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ingestFile2(agg, file, sinceMs) {
+  let text;
+  if (file.endsWith(".zst")) {
+    if (zstdDecompress === null) {
+      throw new Error("zstd not supported by this Node runtime");
+    }
+    text = zstdDecompress(readFileSync9(file)).toString("utf8");
+  } else {
+    text = readFileSync9(file, "utf8");
+  }
+  const state = createFileState();
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    agg.lines++;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      agg.parseErrors++;
+      continue;
+    }
+    ingestLine(agg, rec, state, sinceMs);
+  }
+}
+function readConfiguredMcpServers(agg, configFile) {
+  const file = configFile ?? path2.join(codexHome2(), "config.toml");
+  let names = [];
+  try {
+    const parsed = parseToml2(readFileSync9(file, "utf8"));
+    const servers = parsed.mcp_servers;
+    if (servers && typeof servers === "object" && !Array.isArray(servers)) {
+      names = Object.keys(servers);
+    }
+  } catch {
+    return;
+  }
+  noteConfiguredMcpServers(agg, names);
+}
+
+// src/harness/codex/adapter.ts
+var CODEX_HARNESS_NAME = "codex";
+var CODEX_BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "apply_patch",
+  "exec_command",
+  "grep_command",
+  "list_dir",
+  "read_file",
+  "request_user_input",
+  "shell",
+  "unified_exec",
+  "update_plan",
+  "view_image",
+  "write_stdin",
+  // synthetic names for non-function_call response items
+  "local_shell",
+  "web_search",
+  "tool_search"
+]);
+async function exists4(p8) {
+  try {
+    await stat4(p8);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var codexAdapter = {
+  name: CODEX_HARNESS_NAME,
+  builtinTools: CODEX_BUILTIN_TOOLS,
+  pricingTableVersion: OPENAI_PRICING_TABLE_VERSION,
+  async detect() {
+    for (const root of rolloutRoots()) {
+      if (await exists4(root)) return true;
+    }
+    return false;
+  },
+  async scan(opts) {
+    const aggregate = createAggregate3();
+    const stats = await scan2(aggregate, {
+      sinceMs: opts.sinceMs,
+      ...opts.onProgress ? { onProgress: opts.onProgress } : {}
+    });
+    return { aggregate, stats };
+  }
+};
+
+// src/harness/shared/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) {
@@ -2585,7 +3236,16 @@ function buildModels(rows, totalTokens, publishCost) {
   });
 }
 function buildPayload(input) {
-  const { aggregate: agg, stats, syncConfig, now, windowDays } = input;
+  const {
+    aggregate: agg,
+    stats,
+    syncConfig,
+    now,
+    windowDays,
+    harnessName,
+    builtinTools,
+    pricingTableVersion
+  } = input;
   const finalized = finalize(agg);
   const { publishCost, allowlist, optIns } = syncConfig;
   const fromMs = windowStartMs(now, windowDays);
@@ -2596,7 +3256,7 @@ function buildPayload(input) {
   const totalToolCalls = finalized.totalToolCalls;
   const builtins = buildCategory(
     finalized.tools,
-    BUILTIN_TOOLS,
+    builtinTools,
     optIns.builtinTools,
     totalToolCalls
   );
@@ -2629,10 +3289,10 @@ function buildPayload(input) {
     capturedAt: now,
     window: { days: windowDays, from, to },
     harness: {
-      name: HARNESS_NAME,
+      name: harnessName,
       version: finalized.harnessVersion === null ? null : sanitizeModelId(finalized.harnessVersion)
     },
-    pricingTable: publishCost ? PRICING_TABLE_VERSION : null,
+    pricingTable: publishCost ? pricingTableVersion : null,
     activity: {
       sessions: finalized.sessions,
       activeDays,
@@ -2679,13 +3339,44 @@ function buildPayload(input) {
     }
   };
 }
+function mergeKeptPrivate(halves) {
+  const out = {};
+  for (const category of NAME_CATEGORIES) {
+    const merged = /* @__PURE__ */ new Map();
+    for (const half of halves) {
+      for (const atom of half[category]) {
+        const held = merged.get(atom.name);
+        if (held) held.count += atom.count;
+        else merged.set(atom.name, { ...atom });
+      }
+    }
+    out[category] = [...merged.values()].sort(
+      (a, b) => b.count - a.count || a.name.localeCompare(b.name)
+    );
+  }
+  return out;
+}
 function buildSyncBody(built, syncConfig) {
-  if (!syncConfig.reviewKeptPrivate) return { payload: built.payload };
-  return { payload: built.payload, keptPrivate: built.keptPrivate };
+  const payloads = built.map((b) => b.payload);
+  if (!syncConfig.reviewKeptPrivate) return { payloads };
+  return {
+    payloads,
+    keptPrivate: mergeKeptPrivate(built.map((b) => b.keptPrivate))
+  };
 }
 
-// src/transcripts/index.ts
-var DEFAULT_WINDOW_DAYS = 30;
+// src/harness/index.ts
+var HARNESS_ADAPTERS = [
+  claudeAdapter,
+  codexAdapter
+];
+async function detectedAdapters() {
+  const out = [];
+  for (const adapter of HARNESS_ADAPTERS) {
+    if (await adapter.detect()) out.push(adapter);
+  }
+  return out;
+}
 
 // src/sync/summary.ts
 function fmtTokens(n) {
@@ -2719,14 +3410,17 @@ function withheldCount(payload) {
   return w.builtinTools + w.mcpServers + w.skills + w.subagents + w.slashCommands;
 }
 function buildGateDialog(ctx) {
-  const { payload, keptPrivate } = ctx.body;
-  const usd = totalUSD(payload);
+  const { payloads, keptPrivate } = ctx.body;
+  const tokens = payloads.reduce((a, p8) => a + p8.activity.totalTokens, 0);
+  const usds = payloads.map((p8) => totalUSD(p8)).filter((u) => u !== null);
+  const usd = usds.length > 0 ? usds.reduce((a, b) => a + b, 0) : null;
+  const days = payloads[0]?.window.days ?? 0;
   const facts = [
-    `${fmtTokens(payload.activity.totalTokens)} tokens`,
-    `${payload.window.days} days`,
+    `${fmtTokens(tokens)} tokens`,
+    `${days} days`,
     ...usd === null ? [] : [fmtUSD(usd)]
   ].join(" \xB7 ");
-  const n = withheldCount(payload);
+  const n = payloads.reduce((a, p8) => a + withheldCount(p8), 0);
   const lines2 = [`Publish to aistack? ${facts}`];
   if (n > 0) {
     lines2.push(
@@ -2757,18 +3451,16 @@ function keptPrivateRows(keptPrivate) {
   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?:\/\//, "");
+function harnessLabel(name) {
+  if (name === "claude-code") return "Claude Code";
+  if (name === "codex") return "Codex";
+  return name;
+}
+function payloadBlock(payload, showHeader) {
   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 {
+  if (showHeader) {
     out.push(
-      `to        ${config.stack.name} \xB7 ${host}/stacks/${config.stack.slug}`
+      `\u2014 ${harnessLabel(payload.harness.name)}${payload.harness.version ? ` ${payload.harness.version}` : ""}`
     );
   }
   out.push(
@@ -2801,7 +3493,28 @@ function buildGateSummary(ctx) {
     const names = atoms.map((a) => a.name).join(", ");
     out.push(`  ${CATEGORY_LABEL[category].padEnd(9)} ${names}`);
   }
-  const n = withheldCount(payload);
+  return out;
+}
+function buildGateSummary(ctx) {
+  const { body, keptPrivate, config, source, baseUrl } = ctx;
+  const { payloads } = 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}`
+    );
+  }
+  for (const payload of payloads) {
+    out.push(...payloadBlock(payload, payloads.length > 1));
+    out.push("");
+  }
+  if (out[out.length - 1] === "") out.pop();
+  const n = payloads.reduce((a, p8) => a + withheldCount(p8), 0);
   if (n > 0) {
     out.push("");
     out.push(`kept private: ${n} name${n === 1 ? "" : "s"}`);
@@ -2837,40 +3550,49 @@ function buildGateSummary(ctx) {
 
 // src/sync/stage.ts
 function stageId(bodyJson) {
-  return createHash("sha256").update(bodyJson).digest("hex").slice(0, 12);
+  return createHash2("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 adapters = deps.adaptersImpl ?? detectedAdapters;
   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 built = [];
+  const sinceMs = windowStartMs(now, windowDays);
+  for (const adapter of await adapters()) {
+    const { aggregate, stats } = await adapter.scan({ sinceMs });
+    built.push(
+      buildPayload({
+        aggregate,
+        stats,
+        syncConfig: config,
+        now,
+        windowDays,
+        harnessName: adapter.name,
+        builtinTools: adapter.builtinTools,
+        pricingTableVersion: adapter.pricingTableVersion
+      })
+    );
+  }
   const body = buildSyncBody(built, config);
   const bodyJson = JSON.stringify(body);
+  const keptPrivate = mergeKeptPrivate(built.map((b) => b.keptPrivate));
   const ctx = {
     body,
-    keptPrivate: built.keptPrivate,
+    keptPrivate,
     config,
     source,
     baseUrl: deps.baseUrl
   };
   let blockedReason = null;
-  if (token === null) {
+  if (built.length === 0) {
+    blockedReason = "No supported harness was found on this machine \u2014 no Claude Code and no Codex logs to read.";
+  } else 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.";
@@ -2879,7 +3601,7 @@ async function stageSync(deps) {
     id: stageId(bodyJson),
     bodyJson,
     body,
-    keptPrivate: built.keptPrivate,
+    keptPrivate,
     summary: buildGateSummary(ctx),
     dialog: buildGateDialog(ctx),
     config,
@@ -2889,16 +3611,136 @@ async function stageSync(deps) {
   };
 }
 
+// src/autosync/run.ts
+var SYNC_LOG_FILE = join10(homedir11(), ".config", "aistack", "sync.log");
+var SYNC_LOG_MAX_LINES = 200;
+var FIX_COMMAND = "npx @use-aistack/cli sync";
+function appendLogLine(file, line) {
+  mkdirSync5(dirname7(file), { recursive: true });
+  appendFileSync(file, `${line}
+`);
+  const lines2 = readFileSync10(file, "utf-8").split("\n").filter(Boolean);
+  if (lines2.length > SYNC_LOG_MAX_LINES) {
+    writeFileSync5(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() {
+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 (codexAutoSyncHookInstalled() && codexHookTrusted() === false) {
+    p7.log.warn(CODEX_TRUST_INSTRUCTION);
+  }
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     outroError("sync needs an interactive terminal \u2014 nothing was sent");
     process.exitCode = 1;
     return;
   }
-  const s = p6.spinner();
-  s.start("Scanning local Claude Code transcripts");
+  const s = p7.spinner();
+  s.start("Scanning local agent transcripts");
   let staged;
   try {
     staged = await stageSync({ baseUrl: BASE_URL });
@@ -2909,13 +3751,13 @@ async function syncCommand() {
     return;
   }
   s.stop("Scan complete");
-  p6.log.message(staged.summary.split("\n").join("\n"));
+  p7.log.message(staged.summary.split("\n").join("\n"));
   if (staged.blockedReason !== null) {
     outroError(staged.blockedReason);
     process.exitCode = 1;
     return;
   }
-  const decision = await p6.select({
+  const decision = await p7.select({
     message: staged.dialog.split("\n").join(dim(" \xB7 ")),
     options: [
       { value: "cancel", label: "Cancel", hint: "nothing leaves this machine" },
@@ -2923,7 +3765,7 @@ async function syncCommand() {
     ],
     initialValue: "cancel"
   });
-  if (p6.isCancel(decision) || decision !== "publish") {
+  if (p7.isCancel(decision) || decision !== "publish") {
     outroCancel("nothing was sent");
     return;
   }
@@ -2944,8 +3786,9 @@ async function syncCommand() {
         `${res.keptPrivate.stored} kept-private names went up for your review at ${res.url}/changes`
       );
     }
-    p6.log.message(lines2.join("\n"));
-    await offerConnectUpsell();
+    p7.log.message(lines2.join("\n"));
+    const asked = await offerAutoSyncOptIn();
+    if (!asked) await offerConnectUpsell();
     outro2("done");
   } catch (e) {
     s.stop("Publish failed");
@@ -2961,7 +3804,7 @@ 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.",
+  description: "Scan local agent transcripts (Claude Code, Codex) 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)",
@@ -2996,7 +3839,7 @@ function createSyncServer(deps, send) {
   const now = deps.now ?? Date.now;
   const stage = deps.stageImpl ?? stageSync;
   const publish = deps.publishImpl ?? syncPublish;
-  const log6 = deps.log ?? (() => {
+  const log7 = deps.log ?? (() => {
   });
   const elicitTimeoutMs = deps.elicitTimeoutMs ?? ELICIT_TIMEOUT_MS;
   let clientSupportsElicitation = false;
@@ -3076,7 +3919,7 @@ function createSyncServer(deps, send) {
       );
     }
     const approvedStage = staged;
-    log6(`elicitation raised for stage ${approvedStage.id}`);
+    log7(`elicitation raised for stage ${approvedStage.id}`);
     request2(
       "elicitation/create",
       {
@@ -3099,7 +3942,7 @@ function createSyncServer(deps, send) {
         const approved = result?.action === "accept" && result?.content?.decision === "publish";
         if (!approved) {
           const outcome = reply === null ? "timed out" : result?.action ?? "error";
-          log6(`elicitation resolved without consent: ${outcome}`);
+          log7(`elicitation resolved without consent: ${outcome}`);
           return ok(
             id,
             textResult(
@@ -3107,7 +3950,7 @@ function createSyncServer(deps, send) {
             )
           );
         }
-        log6(`consent received, sending stage ${approvedStage.id}`);
+        log7(`consent received, sending stage ${approvedStage.id}`);
         publish(approvedStage.token, approvedStage.bodyJson).then(
           (res) => {
             if (staged?.id === approvedStage.id) staged = null;
@@ -3150,7 +3993,7 @@ function createSyncServer(deps, send) {
       case "initialize": {
         const capabilities = params?.capabilities ?? {};
         clientSupportsElicitation = "elicitation" in capabilities;
-        log6(
+        log7(
           `initialize: elicitation ${clientSupportsElicitation ? "declared" : "ABSENT"}`
         );
         return ok(id, {
@@ -3205,7 +4048,7 @@ function runStdioSyncServer(deps) {
 
 // src/index.ts
 var program = new Command();
-program.name("aistack").description("Measure and share your AI stack from your terminal").version("0.4.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 your stack's AI config files").action(createCommand);
@@ -3218,7 +4061,13 @@ program.command("mcp").description(
 `)
   });
 });
-program.command("sync").description("Scan, preview, and publish measured usage (rolling 30 days)").action(syncCommand);
+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