@use-aistack/cli 0.12.4 → 0.14.0

package/dist/index.js

@@ -9,7 +9,11 @@ var LOCAL_PRICING_TABLE_VERSION = "local-no-charge";
 var PROVIDER_VENDOR = {
   anthropic: "anthropic",
   openai: "openai",
-  google: "google"
+  google: "google",
+  xai: "xai"
+};
+var PRICING_ALIASES = {
+  "grok-4.6-build": "grok-4.6"
 };
 var LOCAL_PROVIDERS = /* @__PURE__ */ new Set([
   "ollama",
@@ -105,6 +109,11 @@ var Pricer = class {
   firstLayerWith(slug, provider) {
     return this.layers.find((l) => l.has(slug, provider)) ?? null;
   }
+  lookupSlug(slug, provider) {
+    if (this.firstLayerWith(slug, provider)) return slug;
+    const alias = PRICING_ALIASES[slug];
+    return alias && this.firstLayerWith(alias, provider) ? alias : null;
+  }
   /**
    * Every period that applies to a pricing key, or an empty list when none
    * can be cited.
@@ -117,14 +126,19 @@ var Pricer = class {
   periodsFor(modelKey) {
     const { provider, model } = splitModelKey(modelKey);
     if (provider === null) {
-      return this.firstLayerWith(model, null)?.rowsFor(model, null) ?? [];
+      const slug = this.lookupSlug(model, null);
+      return slug ? this.firstLayerWith(slug, null)?.rowsFor(slug, null) ?? [] : [];
     }
     if (LOCAL_PROVIDERS.has(provider)) return [FREE_PERIOD];
-    const own = this.firstLayerWith(model, provider);
-    if (own) return own.rowsFor(model, provider);
+    const ownSlug = this.lookupSlug(model, provider);
+    if (ownSlug) {
+      return this.firstLayerWith(ownSlug, provider)?.rowsFor(ownSlug, provider) ?? [];
+    }
     const vendor = PROVIDER_VENDOR[provider];
-    if (!vendor || this.vendorOf(model) !== vendor) return [];
-    return this.firstLayerWith(model, null)?.rowsFor(model, null) ?? [];
+    const vendorSlug = this.lookupSlug(model, null);
+    if (!vendor || !vendorSlug || this.vendorOf(vendorSlug) !== vendor)
+      return [];
+    return this.firstLayerWith(vendorSlug, null)?.rowsFor(vendorSlug, null) ?? [];
   }
   isLocal(modelKey) {
     const { provider } = splitModelKey(modelKey);
@@ -176,7 +190,7 @@ function parsePriceTable(body) {
     if (typeof r?.modelSlug !== "string" || r.modelSlug.length === 0 || !num(r.from) || !num(r.input) || !num(r.output) || typeof r.source !== "string") {
       continue;
     }
-    const vendor = r.vendor === "anthropic" || r.vendor === "openai" || r.vendor === "google" || r.vendor === "local" ? r.vendor : void 0;
+    const vendor = r.vendor === "anthropic" || r.vendor === "openai" || r.vendor === "google" || r.vendor === "xai" || r.vendor === "local" ? r.vendor : void 0;
     rows.push({
       modelSlug: r.modelSlug,
       ...typeof r.provider === "string" && r.provider.length > 0 ? { provider: r.provider } : {},
@@ -198,7 +212,8 @@ function parsePriceTable(body) {
 var PRICING_TABLE_VERSION = "anthropic-list-2026-07-25";
 var OPENAI_PRICING_TABLE_VERSION = "openai-list-2026-08-02";
 var GOOGLE_PRICING_TABLE_VERSION = "google-list-2026-08-09";
-var BUNDLED_PRICE_TABLE_ID = "bundled-2026-08-29";
+var XAI_PRICING_TABLE_VERSION = "models.dev@2026-08-29";
+var BUNDLED_PRICE_TABLE_ID = "bundled-2026-09-10";
 var CACHE_WRITE_5M_MULTIPLIER = 1.25;
 var CACHE_WRITE_1H_MULTIPLIER = 2;
 var CACHE_READ_MULTIPLIER = 0.1;
@@ -213,6 +228,11 @@ var GOOGLE_CACHE_MULTIPLIERS = {
   write1h: 1,
   read: 0.1
 };
+var XAI_CACHE_MULTIPLIERS = {
+  write5m: 0,
+  write1h: 0,
+  read: 0.25
+};
 var anthropic = (periods) => ({
   vendor: "anthropic",
   table: PRICING_TABLE_VERSION,
@@ -231,6 +251,12 @@ var google = (periods) => ({
   periods,
   cache: GOOGLE_CACHE_MULTIPLIERS
 });
+var xai = (periods) => ({
+  vendor: "xai",
+  table: XAI_PRICING_TABLE_VERSION,
+  periods,
+  cache: XAI_CACHE_MULTIPLIERS
+});
 var flat = (input, output) => [
   { from: null, input, output }
 ];
@@ -288,7 +314,10 @@ var PRICES = {
   "gemini-3-pro-preview": google(flat(2, 12)),
   // A real Anthropic model with no row until #123. Measured in #122 as
   // `claude-opus-4-5-20251101`, which the dated-suffix rule strips to this key.
-  "claude-opus-4-5": anthropic(flat(5, 25))
+  "claude-opus-4-5": anthropic(flat(5, 25)),
+  // models.dev's xAI row mirrored into the live table on 2026-08-29. Grok
+  // Build's explicit `grok-4.6-build` pricing alias reaches this base rate.
+  "grok-4.6": xai(flat(2, 6))
 };
 function bundledPriceTable() {
   const rows = [];
@@ -348,12 +377,12 @@ function apiEquivalentCost(modelKey, t, atMs) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.12.4" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.14.0" : "0.0.0-dev";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
-async function request(path7, options = {}) {
-  return fetch(`${BASE_URL}${path7}`, {
+async function request(path9, options = {}) {
+  return fetch(`${BASE_URL}${path9}`, {
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -771,9 +800,9 @@ function canonicalizeRepoUrl(input) {
 function repoNameFromCanonical(canonical) {
   return parseRepo(canonical)?.repo ?? "";
 }
-function normalizeUpstreamPath(path7) {
-  if (!path7) return "";
-  return path7.split("/").filter(Boolean).join("/");
+function normalizeUpstreamPath(path9) {
+  if (!path9) return "";
+  return path9.split("/").filter(Boolean).join("/");
 }
 
 // src/git.ts
@@ -819,16 +848,16 @@ function buildRepoLinkResource(canonical) {
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
-function readJson(path7) {
+function readJson(path9) {
   try {
-    if (!existsSync2(path7)) return null;
-    return JSON.parse(readFileSync2(path7, "utf-8"));
+    if (!existsSync2(path9)) return null;
+    return JSON.parse(readFileSync2(path9, "utf-8"));
   } catch {
     return null;
   }
 }
-function hooksFrom(path7, source, out, seen) {
-  const hooks = readJson(path7)?.hooks;
+function hooksFrom(path9, source, out, seen) {
+  const hooks = readJson(path9)?.hooks;
   if (!hooks || typeof hooks !== "object") return;
   for (const [event, config] of Object.entries(hooks)) {
     const stableKey = `hooks:${source}:${event}`;
@@ -917,10 +946,19 @@ function splitImageTag(image) {
 }
 function parseMcpPackage(server) {
   if (server.url) {
+    let safeUrl;
+    try {
+      const parsed = new URL(server.url);
+      parsed.username = "";
+      parsed.password = "";
+      safeUrl = parsed.toString();
+    } catch {
+      return null;
+    }
     const t = (server.type ?? server.transport ?? "").toLowerCase();
     return {
       registry: "url",
-      id: server.url,
+      id: safeUrl,
       transport: t === "sse" ? "sse" : "http"
     };
   }
@@ -968,16 +1006,16 @@ function buildMcpResource(name, group, pkg) {
     pkg
   };
 }
-function readText(path7) {
+function readText(path9) {
   try {
-    if (!existsSync3(path7)) return null;
-    return readFileSync3(path7, "utf-8");
+    if (!existsSync3(path9)) return null;
+    return readFileSync3(path9, "utf-8");
   } catch {
     return null;
   }
 }
-function readParsed(path7, parse2) {
-  const raw = readText(path7);
+function readParsed(path9, parse2) {
+  const raw = readText(path9);
   if (raw === null) return null;
   try {
     return parse2(raw);
@@ -985,14 +1023,14 @@ function readParsed(path7, parse2) {
     return null;
   }
 }
-function readJson2(path7) {
-  return readParsed(path7, JSON.parse);
+function readJson2(path9) {
+  return readParsed(path9, JSON.parse);
 }
-function readYaml(path7) {
-  return readParsed(path7, parseYaml);
+function readYaml(path9) {
+  return readParsed(path9, parseYaml);
 }
-function readToml(path7) {
-  return readParsed(path7, parseToml);
+function readToml(path9) {
+  return readParsed(path9, parseToml);
 }
 function continueListToMap(file) {
   if (!file?.mcpServers?.length) return void 0;
@@ -1027,6 +1065,25 @@ function detectMcpServers(cwd, home = homedir3()) {
       out.push(resource);
     }
   };
+  const grokHome = process.env.GROK_HOME ?? join3(home, ".grok");
+  const grokGlobal = readToml(join3(grokHome, "config.toml"));
+  const grokProject = readToml(join3(cwd, ".grok", "config.toml"));
+  const disabled = /* @__PURE__ */ new Set([
+    ...grokGlobal?.disabled_mcp_servers ?? [],
+    ...grokProject?.disabled_mcp_servers ?? []
+  ]);
+  const effectiveGrok = {
+    ...grokGlobal?.mcp_servers ?? {},
+    ...grokProject?.mcp_servers ?? {}
+  };
+  add(
+    Object.fromEntries(
+      Object.entries(effectiveGrok).filter(
+        ([name, config]) => config.enabled !== false && !disabled.has(name)
+      )
+    ),
+    "grok-build"
+  );
   add(readJson2(join3(cwd, ".mcp.json"))?.mcpServers, "claude-code");
   add(readJson2(join3(cwd, "mcp.json"))?.mcpServers, "generic");
   add(
@@ -1112,8 +1169,8 @@ function resolveSource(entry, mpRepoUrl) {
   const src = entry.source;
   if (typeof src === "string") {
     if (!mpRepoUrl) return null;
-    const path7 = src.replace(/^\.\//, "").replace(/\/+$/, "");
-    return { url: mpRepoUrl, path: path7 || void 0 };
+    const path9 = src.replace(/^\.\//, "").replace(/\/+$/, "");
+    return { url: mpRepoUrl, path: path9 || void 0 };
   }
   if (src && typeof src === "object" && src.url) {
     return { url: src.url, path: src.path, sha: src.sha };
@@ -1150,10 +1207,10 @@ function resolvePluginLinks(installed, marketplaces, manifests) {
   }
   return out;
 }
-function readJson3(path7) {
+function readJson3(path9) {
   try {
-    if (!existsSync4(path7)) return null;
-    return JSON.parse(readFileSync4(path7, "utf-8"));
+    if (!existsSync4(path9)) return null;
+    return JSON.parse(readFileSync4(path9, "utf-8"));
   } catch {
     return null;
   }
@@ -1187,6 +1244,7 @@ var LOCAL_PATTERNS = [
   // Rules
   { path: "CLAUDE.md", type: "rule", group: "claude-code" },
   { path: "AGENTS.md", type: "rule", group: "claude-code" },
+  { path: "GROK.md", type: "rule", group: "grok-build" },
   { path: "GEMINI.md", type: "rule", group: "gemini" },
   { path: ".cursorrules", type: "rule", group: "cursor" },
   { path: ".windsurfrules", type: "rule", group: "windsurf" },
@@ -1217,8 +1275,16 @@ var LOCAL_DIR_PATTERNS = [
   { dir: ".github/instructions", type: "rule", group: "copilot" },
   { dir: ".github/prompts", type: "prompt", group: "copilot" },
   { dir: ".claude/commands", type: "command", group: "claude-code" },
+  { dir: ".claude/skills", type: "skill", group: "claude-code" },
   { dir: ".claude/agents", type: "subagent", group: "claude-code" },
   { dir: ".claude/hooks", type: "hook", group: "claude-code" },
+  { dir: ".grok/skills", type: "skill", group: "grok-build" },
+  { dir: ".grok/commands", type: "command", group: "grok-build" },
+  { dir: ".grok/agents", type: "subagent", group: "grok-build" },
+  { dir: ".grok/hooks", type: "hook", group: "grok-build" },
+  { dir: ".cursor/skills", type: "skill", group: "cursor" },
+  { dir: ".agents/skills", type: "skill", group: "generic" },
+  { dir: ".agents/commands", type: "command", group: "generic" },
   { dir: "prompts", type: "prompt", group: "generic" },
   { dir: ".ai", type: "custom", group: "generic" }
 ];
@@ -1233,8 +1299,8 @@ function loadGitignore(cwd) {
 }
 function readFileSafe(filePath) {
   try {
-    const stat6 = statSync(filePath);
-    if (stat6.size > MAX_FILE_SIZE) return null;
+    const stat7 = statSync(filePath);
+    if (stat7.size > MAX_FILE_SIZE) return null;
     return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
@@ -1299,7 +1365,9 @@ function scanLocal(cwd) {
     for (const entry of readdirSync2(cwd, { withFileTypes: true }).filter(
       (e) => e.isDirectory()
     )) {
-      if (ig.ignores(entry.name + "/")) continue;
+      if ([".grok", ".claude", ".cursor", ".agents"].includes(entry.name))
+        continue;
+      if (ig.ignores(`${entry.name}/`)) continue;
       scanSkillDirs(join5(cwd, entry.name), cwd, ig, results, 1);
     }
   } catch {
@@ -1332,7 +1400,7 @@ function scanSkillDirs(dir, cwd, ig, results, depth) {
     for (const entry of readdirSync2(dir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         const rel = relative(cwd, join5(dir, entry.name));
-        if (!ig.ignores(rel + "/")) {
+        if (!ig.ignores(`${rel}/`)) {
           scanSkillDirs(join5(dir, entry.name), cwd, ig, results, depth + 1);
         }
       }
@@ -1345,6 +1413,7 @@ function scanGlobal() {
   const results = [];
   const globalPatterns = [
     { path: ".claude/CLAUDE.md", type: "rule", group: "claude-code" },
+    { path: ".grok/GROK.md", type: "rule", group: "grok-build" },
     { path: ".claude/settings.json", type: "config", group: "claude-code" },
     { path: ".continue/config.json", type: "config", group: "continue" },
     { path: ".continue/config.yaml", type: "config", group: "continue" },
@@ -1376,7 +1445,14 @@ function scanGlobal() {
     { dir: ".claude/commands", type: "command", group: "claude-code" },
     { dir: ".claude/agents", type: "subagent", group: "claude-code" },
     { dir: ".claude/hooks", type: "hook", group: "claude-code" },
-    { dir: ".cursor/rules", type: "rule", group: "cursor" }
+    { dir: ".grok/skills", type: "skill", group: "grok-build" },
+    { dir: ".grok/commands", type: "command", group: "grok-build" },
+    { dir: ".grok/agents", type: "subagent", group: "grok-build" },
+    { dir: ".grok/hooks", type: "hook", group: "grok-build" },
+    { dir: ".cursor/rules", type: "rule", group: "cursor" },
+    { dir: ".cursor/skills", type: "skill", group: "cursor" },
+    { dir: ".agents/skills", type: "skill", group: "generic" },
+    { dir: ".agents/commands", type: "command", group: "generic" }
   ];
   for (const { dir, type, group } of globalDirs) {
     const dirPath = join5(home, dir);
@@ -1768,7 +1844,7 @@ function diffResources(current, existing) {
 // src/commands/connect.ts
 import { spawnSync } from "node:child_process";
 import { cpSync, existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
+import { homedir as homedir11 } from "node:os";
 import { dirname as dirname3, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as p3 from "@clack/prompts";
@@ -1914,12 +1990,12 @@ function emptyUsage() {
   };
 }
 var countsTotal = (t) => t.input + t.output + t.cacheWrite5m + t.cacheWrite1h + t.cacheWriteUnsplit + t.cacheRead;
-function addModelUsage(agg, modelKey, counts, costUSD, messages = 1, at) {
+function addModelUsage(agg, modelKey, counts2, costUSD, messages = 1, at) {
   if (at) {
     noteUsageResponse(agg, {
       tsMs: at.tsMs,
       modelKey,
-      counts,
+      counts: counts2,
       costUSD,
       ...at.sidechain ? { sidechain: true } : {}
     });
@@ -1930,13 +2006,13 @@ function addModelUsage(agg, modelKey, counts, costUSD, messages = 1, at) {
     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);
+  m.input += counts2.input;
+  m.output += counts2.output;
+  m.cacheWrite5m += counts2.cacheWrite5m;
+  m.cacheWrite1h += counts2.cacheWrite1h;
+  m.cacheWriteUnsplit += counts2.cacheWriteUnsplit;
+  m.cacheRead += counts2.cacheRead;
+  if (costUSD === null) m.unpricedTokens += countsTotal(counts2);
   else m.costUSD += costUSD;
 }
 function buildModelRows(agg) {
@@ -2408,8 +2484,9 @@ async function hasRecentFile(roots, matches, sinceMs, opts = {}) {
 }
 
 // ../workflow-rules/src/daily.ts
-var WORKFLOW_AGGREGATES_V2 = "workflow-aggregates/v2";
+var WORKFLOW_AGGREGATES_V3 = "workflow-aggregates/v3";
 var LOG_BUCKETS_V1 = "log-buckets/v1";
+var LOG_BUCKETS_V2 = "log-buckets/v2";
 var EMPTY_PHASE_TOTALS = Object.freeze({
   scout: 0,
   build: 0,
@@ -2463,6 +2540,10 @@ function medianBucket(buckets) {
   }
   return sorted[sorted.length - 1]?.bucket;
 }
+function logBucketV2(value) {
+  if (!(value >= 1)) return 0;
+  return Math.floor(2 * Math.log2(value)) + 1;
+}
 function median(values) {
   if (values.length === 0) return void 0;
   const sorted = [...values].sort((a, b) => a - b);
@@ -2505,6 +2586,52 @@ function foldModels(rows) {
     (row) => ({ ...row })
   ).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
 }
+function foldCountBuckets(rows, field) {
+  return sumBy(
+    rows,
+    (row) => String(row.bucket),
+    (into, from) => {
+      into[field] += from[field];
+    },
+    (row) => ({ ...row })
+  ).sort((a, b) => a.bucket - b.bucket);
+}
+function foldContextDays(days) {
+  const versions = [...new Set(days.map((d) => d.bucketRuleVersion))].sort().join(" \xB7 ");
+  const windows = days.map((d) => d.window).filter((w) => w !== void 0);
+  const window = windows[windows.length - 1];
+  return {
+    bucketRuleVersion: versions,
+    calls: {
+      main: foldCountBuckets(
+        days.flatMap((d) => d.calls.main),
+        "calls"
+      ),
+      subagents: foldCountBuckets(
+        days.flatMap((d) => d.calls.subagents),
+        "calls"
+      )
+    },
+    firstCalls: {
+      main: foldCountBuckets(
+        days.flatMap((d) => d.firstCalls.main),
+        "sessions"
+      )
+    },
+    firstCallHarnessTokens: days.reduce(
+      (sum, d) => sum + d.firstCallHarnessTokens,
+      0
+    ),
+    firstCallInstructionsTokens: days.reduce(
+      (sum, d) => sum + d.firstCallInstructionsTokens,
+      0
+    ),
+    firstCallCount: days.reduce((sum, d) => sum + d.firstCallCount, 0),
+    maxContext: Math.max(0, ...days.map((d) => d.maxContext)),
+    compactions: days.reduce((sum, d) => sum + d.compactions, 0),
+    ...window === void 0 ? {} : { window }
+  };
+}
 function foldLengths(rows) {
   return sumBy(
     rows,
@@ -2641,6 +2768,8 @@ function foldHarnessDays(days) {
       0
     );
   }
+  const contexts = days.flatMap((day) => day.context ? [day.context] : []);
+  if (contexts.length > 0) out.context = foldContextDays(contexts);
   return out;
 }
 var MAX_CHANGED_LINES_PER_COMMIT = 4096;
@@ -2690,8 +2819,9 @@ function foldGitDays(days) {
 }
 function foldWorkflowDays(days, options) {
   if (days.length === 0) return void 0;
+  const dated = [...days].sort((a, b) => a.date.localeCompare(b.date));
   const byHarness = /* @__PURE__ */ new Map();
-  for (const day of days) {
+  for (const day of dated) {
     for (const harness of day.harnesses) {
       const held = byHarness.get(harness.harness) ?? [];
       held.push(harness);
@@ -2727,13 +2857,13 @@ function playbookHarnesses(reading) {
   return reading.harnesses.filter((harness) => harness.phase !== void 0);
 }
 function startHoursUtc(reading) {
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const harness of reading.harnesses) {
     for (const cell of harness.startHours) {
-      counts.set(cell.hourUtc, (counts.get(cell.hourUtc) ?? 0) + cell.sessions);
+      counts2.set(cell.hourUtc, (counts2.get(cell.hourUtc) ?? 0) + cell.sessions);
     }
   }
-  return counts;
+  return counts2;
 }
 function ownerLocalHour(hourUtc, offsetMinutes) {
   return Math.floor(((hourUtc * 60 + offsetMinutes) / 60 % 24 + 24) % 24);
@@ -2741,13 +2871,13 @@ function ownerLocalHour(hourUtc, offsetMinutes) {
 function modalStartHour(reading) {
   const offsetMinutes = reading.utcOffsetMinutes;
   if (offsetMinutes === void 0) return void 0;
-  const counts = /* @__PURE__ */ new Map();
+  const counts2 = /* @__PURE__ */ new Map();
   for (const [hourUtc, sessions] of startHoursUtc(reading)) {
     const hour = ownerLocalHour(hourUtc, offsetMinutes);
-    counts.set(hour, (counts.get(hour) ?? 0) + sessions);
+    counts2.set(hour, (counts2.get(hour) ?? 0) + sessions);
   }
-  if (counts.size === 0) return void 0;
-  return [...counts.entries()].sort(
+  if (counts2.size === 0) return void 0;
+  return [...counts2.entries()].sort(
     (a, b) => b[1] - a[1] || a[0] - b[0]
   )[0]?.[0];
 }
@@ -2755,10 +2885,10 @@ function modalStartHour(reading) {
 // ../workflow-rules/src/componentRules.ts
 var COMPONENT_RULES_V2 = "component-rules/v2";
 var gitCoverage = () => 1;
-function harnessShare(input, counts) {
+function harnessShare(input, counts2) {
   const synced = input.reading.harnesses.length;
   if (synced === 0) return 0;
-  return counts(input) / synced;
+  return counts2(input) / synced;
 }
 function topShare(entries) {
   const total = entries.reduce((sum, entry) => sum + entry.value, 0);
@@ -3069,6 +3199,7 @@ var HANDOFF_MARKERS = {
     "mcp__curia__request_review"
   ],
   codex: ["request_user_input"],
+  "grok-build": ["ask_user_question", "request_user_input"],
   opencode: ["question"],
   "pi-mono": []
 };
@@ -3099,7 +3230,11 @@ var SCOUT_TOOLS = [
   "web_search",
   "tool_search",
   "codebase_search",
-  "find"
+  "find",
+  "search_tool",
+  "search_files",
+  "list_dir",
+  "read_file"
 ];
 var EDIT_TOOLS = [
   "Edit",
@@ -3110,11 +3245,20 @@ var EDIT_TOOLS = [
   "write",
   "patch",
   "multiedit",
-  "apply_patch"
+  "apply_patch",
+  "write_file",
+  "edit_file"
 ];
 var REVIEW_SKILLS = ["code-review", "security-review", "review"];
 var SCOUT_AGENTS = ["Explore", "Plan", "research"];
-var SHELL_TOOLS = ["Bash", "bash", "shell", "local_shell", "exec_command"];
+var SHELL_TOOLS = [
+  "Bash",
+  "bash",
+  "shell",
+  "local_shell",
+  "exec_command",
+  "run_terminal_command"
+];
 var SKILL_TOOLS = ["Skill", "skill"];
 var AGENT_TOOLS = ["Agent", "Task", "task", "agent"];
 var BOOKKEEPING_TOOLS = [
@@ -3863,7 +4007,7 @@ function buildSyncBody(built, syncConfig, autoSync, trigger = "manual", measured
 }
 
 // src/workflow/reducer.ts
-var WORKFLOW_AGGREGATE_VERSION = WORKFLOW_AGGREGATES_V2;
+var WORKFLOW_AGGREGATE_VERSION = WORKFLOW_AGGREGATES_V3;
 function createWorkflowLocalSources() {
   return { projectWorkspaces: /* @__PURE__ */ new Set(), activeProjectDays: /* @__PURE__ */ new Map() };
 }
@@ -3879,6 +4023,11 @@ var bump2 = (map, key2, amount = 1) => {
   map.set(key2, (map.get(key2) ?? 0) + amount);
 };
 var utcDateOf2 = (ms) => new Date(ms).toISOString().slice(0, 10);
+function asBuckets(map, field) {
+  return [...map].map(
+    ([bucket, count]) => ({ bucket, [field]: count })
+  ).sort((a, b) => a.bucket - b.bucket);
+}
 var PHASE_RANK = {
   verify: 4,
   handoff: 3,
@@ -3976,13 +4125,25 @@ function dayState() {
     questions: { asked: 0, turns: 0 },
     hasQuestions: false,
     webSearches: 0,
-    hasWebSearches: false
+    hasWebSearches: false,
+    context: {
+      calls: { main: /* @__PURE__ */ new Map(), subagents: /* @__PURE__ */ new Map() },
+      firstCalls: /* @__PURE__ */ new Map(),
+      firstCallHarnessTokens: 0,
+      firstCallInstructionsTokens: 0,
+      firstCallCount: 0,
+      maxContext: 0,
+      compactions: 0,
+      window: void 0
+    },
+    hasContext: false
   };
 }
 function createHarnessWorkflowReducer(harness, localSources = createWorkflowLocalSources()) {
   const sessions = /* @__PURE__ */ new Map();
   const eventCells = /* @__PURE__ */ new Map();
   const webSearchesByDate = /* @__PURE__ */ new Map();
+  const compactionsByDate = /* @__PURE__ */ new Map();
   const eventDates = /* @__PURE__ */ new Set();
   let finished;
   const getSession = (key2) => {
@@ -4023,22 +4184,39 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
       } else if (observation.type === "response") {
         const responseId = observation.responseId ?? `anonymous:${state.nextAnonymousResponse++}`;
         const duration = finiteNonnegative(observation.durationSec);
+        const contextTokens = finiteNonnegative(observation.contextTokens);
+        const contextWindow = finiteNonnegative(observation.contextWindow);
         const response = {
+          tsMs: observation.tsMs,
           ...observation.model ? { model: observation.model } : {},
           ...observation.thinkingTokens !== void 0 ? { thinkingTokens: finiteNonnegative(observation.thinkingTokens) } : {},
           ...observation.responseTokens !== void 0 ? { responseTokens: finiteNonnegative(observation.responseTokens) } : {},
           ...observation.routingTokens !== void 0 ? { routingTokens: finiteNonnegative(observation.routingTokens) } : {},
           ...observation.effort ? { effort: observation.effort } : {},
-          ...duration > 0 ? { durationSec: duration } : {}
+          ...duration > 0 ? { durationSec: duration } : {},
+          ...observation.contextTokens !== void 0 ? { contextTokens } : {},
+          ...contextWindow > 0 ? { contextWindow } : {},
+          ...observation.firstCall ? {
+            firstCall: {
+              harnessTokens: finiteNonnegative(
+                observation.firstCall.harnessTokens
+              ),
+              instructionsTokens: finiteNonnegative(
+                observation.firstCall.instructionsTokens
+              )
+            }
+          } : {}
         };
         const existing = state.responses.get(responseId);
         const magnitude = (value) => value.routingTokens ?? (value.thinkingTokens ?? 0) + (value.responseTokens ?? 0);
         if (!existing || magnitude(response) > magnitude(existing)) {
           state.responses.set(responseId, response);
         }
-      } else {
+      } else if (observation.type === "turn") {
         const turnId = observation.turnId ?? `anonymous:${state.nextAnonymousTurn++}`;
         state.turns.set(turnId, observation.questionBack);
+      } else {
+        bump2(compactionsByDate, date);
       }
     },
     finish() {
@@ -4144,6 +4322,33 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
             Boolean
           ).length;
         }
+        for (const response of responses) {
+          if (response.contextTokens === void 0) continue;
+          day.hasContext = true;
+          const context = day.context;
+          bump2(context.calls[routing], logBucketV2(response.contextTokens));
+          context.maxContext = Math.max(
+            context.maxContext,
+            response.contextTokens
+          );
+          if (response.contextWindow !== void 0 && (context.window === void 0 || response.tsMs >= context.window.tsMs)) {
+            context.window = {
+              tsMs: response.tsMs,
+              window: response.contextWindow
+            };
+          }
+          if (response.firstCall && routing === "main") {
+            bump2(context.firstCalls, logBucketV2(response.contextTokens));
+            context.firstCallHarnessTokens += response.firstCall.harnessTokens;
+            context.firstCallInstructionsTokens += response.firstCall.instructionsTokens;
+            context.firstCallCount++;
+          }
+        }
+      }
+      for (const [date, compactions] of compactionsByDate) {
+        const day = dayOf(date);
+        day.hasContext = true;
+        day.context.compactions += compactions;
       }
       for (const date of eventDates) {
         const day = dayOf(date);
@@ -4205,7 +4410,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
         0
       );
       const unknown = attributed === 0 ? 0 : windowPhaseSec.unknown / attributed;
-      const routesModels = harness === "claude-code" || harness === "opencode";
+      const routesModels = harness === "claude-code" || harness === "opencode" || harness === "grok-build";
       const asRows = (map) => {
         const safe = /* @__PURE__ */ new Map();
         for (const [model, tokens] of map) {
@@ -4276,12 +4481,34 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
             }
           } : {},
           ...day.hasQuestions ? { questions: day.questions } : {},
-          ...day.hasWebSearches ? { webSearches: day.webSearches } : {}
+          ...day.hasWebSearches ? { webSearches: day.webSearches } : {},
+          ...day.hasContext ? {
+            context: {
+              bucketRuleVersion: LOG_BUCKETS_V2,
+              calls: {
+                main: asBuckets(day.context.calls.main, "calls"),
+                subagents: asBuckets(
+                  day.context.calls.subagents,
+                  "calls"
+                )
+              },
+              firstCalls: {
+                main: asBuckets(day.context.firstCalls, "sessions")
+              },
+              firstCallHarnessTokens: day.context.firstCallHarnessTokens,
+              firstCallInstructionsTokens: day.context.firstCallInstructionsTokens,
+              firstCallCount: day.context.firstCallCount,
+              maxContext: day.context.maxContext,
+              compactions: day.context.compactions,
+              ...day.context.window ? { window: day.context.window.window } : {}
+            }
+          } : {}
         }))
       };
       sessions.clear();
       eventCells.clear();
       webSearchesByDate.clear();
+      compactionsByDate.clear();
       eventDates.clear();
       return finished;
     }
@@ -4295,9 +4522,30 @@ function createAggregate2() {
     workflow: createHarnessWorkflowReducer("claude-code", workflowLocal),
     workflowLocal,
     workflowSeenCalls: /* @__PURE__ */ new Set(),
-    workflowSeenTurns: /* @__PURE__ */ new Set()
+    workflowSeenTurns: /* @__PURE__ */ new Set(),
+    contextFirstCall: /* @__PURE__ */ new Map()
   });
 }
+function workflowSessionKey(rec) {
+  const baseSession = asStr(rec.sessionId);
+  if (!baseSession) return null;
+  if (rec.isSidechain !== true) return baseSession;
+  return `${baseSession}:agent:${asStr(rec.agentId) ?? "unknown"}`;
+}
+function isApiCall(rec) {
+  if (asStr(rec.type) !== "assistant") return false;
+  const msg = asObj(rec.message);
+  if (!msg || !asObj(msg.usage)) return false;
+  return !(asName(msg.model) ?? "").startsWith("<");
+}
+function noteRecordBeforeWindow(agg, raw) {
+  const rec = asObj(raw);
+  if (!rec || !isApiCall(rec)) return;
+  const session = workflowSessionKey(rec);
+  if (session && !agg.contextFirstCall.has(session)) {
+    agg.contextFirstCall.set(session, null);
+  }
+}
 function projectWorkspaceDirectory(raw) {
   const rec = asObj(raw);
   return rec ? asStr(rec.cwd) : null;
@@ -4330,7 +4578,25 @@ function ingestRecord(agg, raw, ctx) {
     ingestClaudeWorkflow(agg, rec, ctx, tsMs);
     ingestAssistant(agg, rec, tsMs);
   } else if (type === "user") ingestUser(agg, rec);
-  else if (type === "system") ingestClaudeTurnDuration(agg, rec, ctx, tsMs);
+  else if (type === "system") {
+    ingestClaudeTurnDuration(agg, rec, ctx, tsMs);
+    ingestClaudeCompaction(agg, rec, ctx, tsMs);
+  }
+}
+function ingestClaudeCompaction(agg, rec, ctx, tsMs) {
+  if (tsMs === null || asStr(rec.subtype) !== "compact_boundary") return;
+  const session = workflowSessionKey(rec);
+  if (!session) return;
+  agg.workflow.ingest({
+    type: "compaction",
+    session,
+    projectWorkspace: projectWorkspaceDirectory(rec) ?? ctx.projectDir,
+    tsMs,
+    ...rec.isSidechain === true ? { sidechain: true } : {}
+  });
+}
+function contextOf(counts2) {
+  return counts2.input + counts2.cacheWrite5m + counts2.cacheWrite1h + counts2.cacheWriteUnsplit + counts2.cacheRead;
 }
 function ingestClaudeTurnDuration(agg, rec, ctx, tsMs) {
   if (tsMs === null || asStr(rec.subtype) !== "turn_duration" || asNum(rec.durationMs) <= 0) {
@@ -4358,10 +4624,28 @@ function ingestClaudeWorkflow(agg, rec, ctx, tsMs) {
   const session = sidechain ? `${baseSession}:agent:${agentId ?? "unknown"}` : baseSession;
   const parentSession = sidechain ? baseSession : void 0;
   const usage = asObj(msg.usage);
-  const counts = usage ? readCounts(usage) : null;
+  const counts2 = usage ? readCounts(usage) : null;
   const messageId = asStr(msg.id);
   const newTurn = messageId ? !agg.workflowSeenTurns.has(messageId) : true;
   if (messageId) agg.workflowSeenTurns.add(messageId);
+  let context = null;
+  if (counts2 && isApiCall(rec)) {
+    const held = agg.contextFirstCall.get(session);
+    let first = false;
+    if (held === void 0) {
+      agg.contextFirstCall.set(session, messageId);
+      first = true;
+    } else if (held !== null && held === messageId) first = true;
+    context = {
+      contextTokens: contextOf(counts2),
+      ...first ? {
+        firstCall: {
+          harnessTokens: counts2.cacheRead,
+          instructionsTokens: contextOf(counts2) - counts2.cacheRead
+        }
+      } : {}
+    };
+  }
   agg.workflow.ingest({
     type: "response",
     session,
@@ -4371,9 +4655,10 @@ function ingestClaudeWorkflow(agg, rec, ctx, tsMs) {
     ...parentSession ? { parentSession } : {},
     ...messageId ? { responseId: messageId } : {},
     ...asName(msg.model) ? { model: asName(msg.model) } : {},
-    ...counts ? { responseTokens: counts.output } : {},
-    ...counts ? { routingTokens: countsTotal(counts) } : {},
-    ...asStr(rec.effort) ?? asStr(msg.effort) ? { effort: asStr(rec.effort) ?? asStr(msg.effort) } : {}
+    ...counts2 ? { responseTokens: counts2.output } : {},
+    ...counts2 ? { routingTokens: countsTotal(counts2) } : {},
+    ...asStr(rec.effort) ?? asStr(msg.effort) ? { effort: asStr(rec.effort) ?? asStr(msg.effort) } : {},
+    ...context ?? {}
   });
   const tools = [];
   for (const rawBlock of asArr(msg.content)) {
@@ -4498,11 +4783,11 @@ function readCounts(usage) {
 function modelKeyFor2(model, speed) {
   return normalizeModel(speed === "fast" ? `${model}#fast` : model);
 }
-function makeEntry(modelKey, counts, tsMs) {
+function makeEntry(modelKey, counts2, tsMs) {
   return {
     modelKey,
-    counts,
-    costUSD: apiEquivalentCost(modelKey, counts, tsMs)
+    counts: counts2,
+    costUSD: apiEquivalentCost(modelKey, counts2, tsMs)
   };
 }
 function buildContribution(usage, model, sidechain, tsMs) {
@@ -4547,24 +4832,24 @@ function buildContribution(usage, model, sidechain, tsMs) {
   };
 }
 function applyContribution(agg, c, sign) {
-  c.entries.forEach(({ modelKey, counts, costUSD }, i) => {
+  c.entries.forEach(({ modelKey, counts: counts2, 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);
+    m.input += sign * counts2.input;
+    m.output += sign * counts2.output;
+    m.cacheWrite5m += sign * counts2.cacheWrite5m;
+    m.cacheWrite1h += sign * counts2.cacheWrite1h;
+    m.cacheWriteUnsplit += sign * counts2.cacheWriteUnsplit;
+    m.cacheRead += sign * counts2.cacheRead;
+    if (costUSD === null) m.unpricedTokens += sign * countsTotal(counts2);
     else m.costUSD += sign * costUSD;
     noteUsageResponse(
       agg,
-      { tsMs: c.tsMs, modelKey, counts, costUSD, sidechain: c.sidechain },
+      { tsMs: c.tsMs, modelKey, counts: counts2, costUSD, sidechain: c.sidechain },
       sign
     );
   });
@@ -4751,7 +5036,10 @@ async function ingestFile(agg, file, projectDir, projectWorkspaces, sinceMs) {
     }
     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;
+      if (Number.isNaN(ts) || ts < sinceMs) {
+        noteRecordBeforeWindow(agg, rec);
+        continue;
+      }
     }
     ingestRecord(agg, rec, { projectDir: projectWorkspace });
   }
@@ -4803,7 +5091,33 @@ function createFileState() {
     responseIndex: 0,
     currentQuestionBack: false,
     counted: false,
-    metaTsMs: null
+    metaTsMs: null,
+    forked: false,
+    sawResponse: false
+  };
+}
+function genuineDelta(payload, state, tsMs) {
+  if (asStr(payload.type) !== "token_count") return null;
+  const info = asObj(payload.info);
+  const last = info ? asObj(info.last_token_usage) : null;
+  if (!last) return null;
+  const inputTotal = asNum(last.input_tokens);
+  const cached = Math.min(asNum(last.cached_input_tokens), inputTotal);
+  const counts2 = {
+    input: inputTotal - cached,
+    output: asNum(last.output_tokens),
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: 0,
+    cacheRead: cached
+  };
+  if (countsTotal(counts2) === 0) return null;
+  if (tsMs !== null && state.metaTsMs !== null && tsMs - state.metaTsMs < FORK_REPLAY_WINDOW_MS)
+    return null;
+  return {
+    counts: counts2,
+    last,
+    contextWindow: info ? asNum(info.model_context_window) : 0
   };
 }
 var FORK_REPLAY_WINDOW_MS = 500;
@@ -4825,11 +5139,17 @@ function ingestLine(agg, raw, state, sinceMs) {
     state.cliVersion = asStr(payload.cli_version) ?? state.cliVersion;
     state.cwd = asStr(payload.cwd) ?? state.cwd;
     state.metaTsMs = tsMs ?? state.metaTsMs;
+    state.forked = payload.forked_from_id !== void 0 && payload.forked_from_id !== null;
   } else if (type === "turn_context" && payload) {
     const model = asName(payload.model);
     if (model) state.modelKey = normalizeModel(model);
     state.effort = asStr(payload.effort) ?? state.effort;
   }
+  let firstCall = false;
+  if (type === "event_msg" && payload && genuineDelta(payload, state, tsMs)) {
+    firstCall = !state.sawResponse;
+    state.sawResponse = true;
+  }
   if (!inWindow) return;
   if (tsMs !== null && timestamp) {
     agg.activeDays.add(timestamp.slice(0, 10));
@@ -4838,9 +5158,18 @@ function ingestLine(agg, raw, state, sinceMs) {
   }
   noteActivity(agg, state, tsMs);
   noteProjectDay(agg, state.cwd ?? "(unknown)", tsMs);
-  if (type === "event_msg" && payload) ingestEvent(agg, payload, state, tsMs);
+  if (type === "event_msg" && payload)
+    ingestEvent(agg, payload, state, tsMs, firstCall);
   else if (type === "response_item" && payload)
     ingestItem(agg, payload, state, tsMs);
+  else if (type === "compacted" && tsMs !== null && state.sessionId) {
+    agg.workflow.ingest({
+      type: "compaction",
+      session: state.sessionId,
+      projectWorkspace: state.cwd ?? void 0,
+      tsMs
+    });
+  }
 }
 function noteActivity(agg, state, tsMs) {
   if (state.sessionId) noteSessionStart(agg, state.sessionId, tsMs);
@@ -4850,25 +5179,11 @@ function noteActivity(agg, state, tsMs) {
   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 && state.metaTsMs !== null && tsMs - state.metaTsMs < FORK_REPLAY_WINDOW_MS)
-    return;
+function ingestEvent(agg, payload, state, tsMs, firstCall) {
+  const delta = genuineDelta(payload, state, tsMs);
+  if (!delta) return;
+  const { counts: counts2, last, contextWindow } = delta;
+  const total = countsTotal(counts2);
   if (state.modelKey === null) return;
   if (tsMs === null) agg.untimestampedResponses++;
   agg.distinctResponses++;
@@ -4876,8 +5191,8 @@ function ingestEvent(agg, payload, state, tsMs) {
   addModelUsage(
     agg,
     modelKey,
-    counts,
-    apiEquivalentCost(modelKey, counts, tsMs),
+    counts2,
+    apiEquivalentCost(modelKey, counts2, tsMs),
     1,
     { tsMs }
   );
@@ -4891,10 +5206,23 @@ function ingestEvent(agg, payload, state, tsMs) {
       projectWorkspace: state.cwd ?? void 0,
       tsMs,
       model: modelKey,
-      responseTokens: counts.output,
+      responseTokens: counts2.output,
       routingTokens: total,
       thinkingTokens: asNum(last.reasoning_output_tokens),
-      ...state.effort ? { effort: state.effort } : {}
+      ...state.effort ? { effort: state.effort } : {},
+      // The context at this call is `input_tokens` (cached is a subset).
+      // On the first call the cached part is the harness (base
+      // instructions and tool specs, cached by an earlier session) and
+      // the fresh part is the instructions: AGENTS.md, environment,
+      // skills and the first prompt. Same method as Claude Code (#358).
+      contextTokens: counts2.input + counts2.cacheRead,
+      ...contextWindow > 0 ? { contextWindow } : {},
+      ...firstCall && !state.forked ? {
+        firstCall: {
+          harnessTokens: counts2.cacheRead,
+          instructionsTokens: counts2.input
+        }
+      } : {}
     });
     agg.workflow.ingest({
       type: "turn",
@@ -5112,11 +5440,11 @@ function ingestWithRetry(agg, file, opts) {
   }
 }
 function ingestFile2(agg, file, opts) {
-  const readFile = opts.readFileImpl ?? readFileSync6;
+  const readFile2 = opts.readFileImpl ?? readFileSync6;
   let text;
   if (file.endsWith(".zst")) {
     if (zstdDecompress === null) throw readError("zstd-unsupported");
-    const raw = readFile(file);
+    const raw = readFile2(file);
     try {
       text = zstdDecompress(
         Buffer.isBuffer(raw) ? raw : Buffer.from(raw)
@@ -5125,7 +5453,7 @@ function ingestFile2(agg, file, opts) {
       throw readError("zstd-corrupt");
     }
   } else {
-    text = readFile(file).toString("utf8");
+    text = readFile2(file).toString("utf8");
   }
   const records = [];
   let nonEmptyLines = 0;
@@ -5228,6 +5556,510 @@ var codexAdapter = {
   }
 };
 
+// src/harness/grok/analyzer.ts
+function createAggregate4() {
+  const workflowLocal = createWorkflowLocalSources();
+  return Object.assign(createAggregate(), {
+    workflow: createHarnessWorkflowReducer("grok-build", workflowLocal),
+    workflowLocal
+  });
+}
+var createGrokEventState = (parentSession) => ({
+  tools: /* @__PURE__ */ new Map(),
+  completedTools: /* @__PURE__ */ new Set(),
+  ...parentSession ? { parentSession } : {}
+});
+var bump3 = (map, key2) => {
+  map.set(key2, (map.get(key2) ?? 0) + 1);
+};
+var toolMetadata = (update) => {
+  const meta = asObj(update._meta);
+  return meta && asObj(meta["x.ai/tool"]);
+};
+function ingestUpdate(agg, state, value, projectDir, sinceMs) {
+  const root = asObj(value);
+  const params = root && asObj(root.params);
+  const update = params && asObj(params.update);
+  const session = params && asStr(params.sessionId);
+  const tsMs = timestampMs(
+    asObj(params?._meta)?.agentTimestampMs ?? root?.timestamp
+  );
+  if (!update || !session || tsMs === null) return;
+  const kind = asStr(update.sessionUpdate);
+  if (kind === "tool_call") {
+    const id = asStr(update.toolCallId);
+    const metadata = toolMetadata(update);
+    const name = asName(metadata?.name ?? update.toolName);
+    if (!id || !name || state.tools.has(id)) return;
+    const raw = asObj(update.input);
+    const arg = asStr(raw?.command ?? raw?.query ?? raw?.skill ?? raw?.name);
+    state.tools.set(id, { name, ...arg ? { arg } : {}, tsMs });
+    return;
+  }
+  if (sinceMs !== void 0 && tsMs < sinceMs) return;
+  if (kind === "tool_call_update") {
+    const id = asStr(update.toolCallId);
+    if (!id || asStr(update.status) !== "completed") return;
+    completeTool(agg, state, id, session, projectDir, tsMs);
+    return;
+  }
+  if (kind !== "turn_completed") return;
+  const usage = asObj(update.usage);
+  if (!usage) return;
+  const prompt = asStr(update.prompt_id) ?? `turn:${tsMs}`;
+  for (const [model, raw] of Object.entries(asObj(usage.modelUsage) ?? {})) {
+    const row = asObj(raw);
+    agg.workflow.ingest({
+      type: "response",
+      session,
+      projectWorkspace: projectDir,
+      parentSession: state.parentSession,
+      tsMs,
+      responseId: `${prompt}:${model}`,
+      model,
+      thinkingTokens: asNum(row?.reasoningTokens),
+      responseTokens: asNum(row?.outputTokens),
+      routingTokens: asNum(row?.outputTokens),
+      ...asNum(row?.apiDurationMs) > 0 ? { durationSec: asNum(row?.apiDurationMs) / 1e3 } : asNum(update.elapsed_ms) > 0 ? { durationSec: asNum(update.elapsed_ms) / 1e3 } : {}
+    });
+  }
+  agg.workflow.ingest({
+    type: "turn",
+    session,
+    projectWorkspace: projectDir,
+    parentSession: state.parentSession,
+    tsMs,
+    turnId: prompt,
+    questionBack: asStr(update.stop_reason) === "question"
+  });
+}
+function completeTool(agg, state, id, session, projectDir, tsMs) {
+  if (state.completedTools.has(id)) return;
+  const tool = state.tools.get(id);
+  if (!tool) return;
+  state.completedTools.add(id);
+  bump3(agg.toolCalls, tool.name);
+  if (["web_search", "websearch", "search_web"].includes(tool.name))
+    agg.webSearchRequests++;
+  if (["skill", "use_skill"].includes(tool.name) && tool.arg)
+    bump3(agg.skillCalls, tool.arg);
+  const mcp = /^(?:mcp__|mcp:)([^_:]+)[_:](.+)$/.exec(tool.name);
+  if (mcp) {
+    bump3(agg.mcpServerCalls, mcp[1]);
+    bump3(agg.mcpToolCalls, tool.name);
+  } else if (tool.name === "use_tool" && tool.arg?.includes("__")) {
+    const [server] = tool.arg.split("__", 1);
+    if (server) {
+      bump3(agg.mcpServerCalls, server);
+      bump3(agg.mcpToolCalls, tool.arg);
+    }
+  }
+  agg.workflow.ingest({
+    type: "event",
+    session,
+    projectWorkspace: projectDir,
+    parentSession: state.parentSession,
+    tsMs: tool.tsMs || tsMs,
+    tool: tool.name,
+    ...tool.arg ? { arg: tool.arg } : {},
+    batchId: id
+  });
+}
+function ingestEvent2(agg, state, value, sessionFallback, projectDir, sinceMs) {
+  const row = asObj(value);
+  if (!row) return;
+  const session = asStr(row.session_id) ?? sessionFallback;
+  const tsMs = timestampMs(row.ts);
+  if (!session || tsMs === null) return;
+  if (asStr(row.type) === "tool_started") {
+    const id = asStr(row.tool_call_id);
+    const name = asName(row.tool_name);
+    if (id && name && !state.tools.has(id)) state.tools.set(id, { name, tsMs });
+  } else if (sinceMs !== void 0 && tsMs < sinceMs) {
+    return;
+  } else if (asStr(row.type) === "tool_completed") {
+    const id = asStr(row.tool_call_id);
+    if (id) completeTool(agg, state, id, session, projectDir, tsMs);
+  } else if (asStr(row.type) === "compaction") {
+    agg.workflow.ingest({
+      type: "compaction",
+      session,
+      projectWorkspace: projectDir,
+      parentSession: state.parentSession,
+      tsMs
+    });
+  }
+}
+var timestampMs = (value) => {
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value < 1e10 ? value * 1e3 : value;
+};
+function counts(value) {
+  const row = asObj(value);
+  if (!row) return null;
+  const totalInput = asNum(row.inputTokens);
+  const cacheRead = asNum(row.cachedReadTokens);
+  const cacheWrite = asNum(row.cacheCreationTokens);
+  if (totalInput < cacheRead + cacheWrite) return null;
+  const result = {
+    input: totalInput - cacheRead - cacheWrite,
+    output: asNum(row.outputTokens),
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: cacheWrite,
+    cacheRead
+  };
+  return countsTotal(result) > 0 ? result : null;
+}
+function sidecarContributions(value, projectDir) {
+  const root = asObj(value);
+  const sessionId = root && asStr(root.sessionId);
+  if (!root || !sessionId) return [];
+  const turns = Array.isArray(root.turns) ? root.turns : [];
+  const out = [];
+  for (const raw of turns) {
+    const turn = asObj(raw);
+    const tsMs = turn && timestampMs(turn.endedAt);
+    if (!turn || tsMs === null) continue;
+    const models = [];
+    const perModel = asObj(turn.modelUsage);
+    for (const [model, usage] of Object.entries(perModel ?? {})) {
+      const c = counts(usage);
+      if (c) models.push({ model, counts: c });
+    }
+    if (models.length === 0) {
+      const c = counts(turn);
+      const model = asStr(turn.primaryModelId);
+      if (c && model) models.push({ model, counts: c });
+    }
+    if (models.length > 0)
+      out.push({
+        sessionId,
+        projectDir,
+        tsMs,
+        ...asNum(turn.apiDurationMs) > 0 ? { durationMs: asNum(turn.apiDurationMs) } : {},
+        models
+      });
+  }
+  return out;
+}
+function terminalContribution(value, projectDir) {
+  const root = asObj(value);
+  const params = root && asObj(root.params);
+  const update = params && asObj(params.update);
+  const meta = params && asObj(params._meta);
+  if (!update || asStr(update.sessionUpdate) !== "turn_completed") return null;
+  const usage = asObj(update.usage);
+  const sessionId = params && asStr(params.sessionId);
+  const tsMs = timestampMs(meta?.agentTimestampMs ?? root?.timestamp);
+  if (!usage || !sessionId || tsMs === null) return null;
+  const models = [];
+  for (const [model, row] of Object.entries(asObj(usage.modelUsage) ?? {})) {
+    const c = counts(row);
+    if (c) models.push({ model, counts: c });
+  }
+  return models.length === 0 ? null : {
+    sessionId,
+    projectDir,
+    tsMs,
+    ...asNum(update.elapsed_ms) > 0 ? { durationMs: asNum(update.elapsed_ms) } : {},
+    models
+  };
+}
+function ingestContribution(agg, row) {
+  agg.records++;
+  agg.assistantRecords++;
+  agg.distinctResponses++;
+  agg.sessions.add(row.sessionId);
+  agg.activeDays.add(new Date(row.tsMs).toISOString().slice(0, 10));
+  agg.projectDirs.add(row.projectDir);
+  agg.firstTs = agg.firstTs === null ? row.tsMs : Math.min(agg.firstTs, row.tsMs);
+  agg.lastTs = agg.lastTs === null ? row.tsMs : Math.max(agg.lastTs, row.tsMs);
+  noteSessionStart(agg, row.sessionId, row.tsMs);
+  noteProjectDay(agg, row.projectDir, row.tsMs);
+  for (const { model, counts: tokenCounts } of row.models) {
+    const key2 = normalizeModel(model);
+    addModelUsage(
+      agg,
+      key2,
+      tokenCounts,
+      apiEquivalentCost(key2, tokenCounts, row.tsMs),
+      1,
+      {
+        tsMs: row.tsMs
+      }
+    );
+  }
+}
+
+// src/harness/grok/scan.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { readdir as readdir4, readFile, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import path4 from "node:path";
+import readline2 from "node:readline";
+import { parse as parseToml3 } from "smol-toml";
+function sessionRoots() {
+  return [
+    path4.join(
+      process.env.GROK_HOME || path4.join(homedir8(), ".grok"),
+      "sessions"
+    )
+  ];
+}
+var isGrokEvidenceFile = (name) => name === "usage.json" || name === "updates.jsonl" || name === "events.jsonl";
+var delays = [0, 100, 300];
+var pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function stableRead(file, jsonl) {
+  for (const delay of delays) {
+    if (delay) await pause(delay);
+    try {
+      const before = await stat4(file);
+      if (!before.isFile()) return { complete: false };
+      if (jsonl) {
+        const lines2 = [];
+        const input = readline2.createInterface({
+          input: createReadStream2(file),
+          crlfDelay: Infinity
+        });
+        for await (const line of input) {
+          if (!line.trim()) continue;
+          try {
+            lines2.push(JSON.parse(line));
+          } catch {
+            lines2.push(null);
+          }
+        }
+        const after = await stat4(file);
+        if (before.size === after.size && before.mtimeMs === after.mtimeMs)
+          return { lines: lines2, complete: true };
+      } else {
+        const raw = await readFile(file, "utf8");
+        const after = await stat4(file);
+        if (before.size === after.size && before.mtimeMs === after.mtimeMs)
+          return { json: JSON.parse(raw), complete: true };
+      }
+    } catch {
+    }
+  }
+  return { complete: false };
+}
+async function directories(root) {
+  try {
+    const workspaces = await readdir4(root, { withFileTypes: true });
+    const out = [];
+    for (const workspace of workspaces) {
+      if (!workspace.isDirectory() || workspace.isSymbolicLink()) continue;
+      const workspacePath = path4.join(root, workspace.name);
+      for (const session of await readdir4(workspacePath, {
+        withFileTypes: true
+      })) {
+        if (session.isDirectory() && !session.isSymbolicLink())
+          out.push(path4.join(workspacePath, session.name));
+      }
+    }
+    return out.sort();
+  } catch (error) {
+    return error.code === "ENOENT" ? [] : null;
+  }
+}
+async function modelAliasesForRoot(root) {
+  if (process.env.GROK_MODELS_BASE_URL) return /* @__PURE__ */ new Map();
+  try {
+    const parsed = asObj(
+      parseToml3(await readFile(path4.join(root, "..", "config.toml"), "utf8"))
+    );
+    if (!parsed || asObj(parsed.endpoints)?.models_base_url) return /* @__PURE__ */ new Map();
+    const models = asObj(parsed.model);
+    const aliases = /* @__PURE__ */ new Map();
+    for (const [alias, raw] of Object.entries(models ?? {})) {
+      const entry = asObj(raw);
+      const model = entry && asStr(entry.model);
+      if (!model || entry?.base_url || entry?.model_provider) continue;
+      aliases.set(alias, model);
+    }
+    return aliases;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function scan3(agg, opts = {}) {
+  const stats = emptyScanStats();
+  const sessionDates = /* @__PURE__ */ new Map();
+  const candidates = /* @__PURE__ */ new Map();
+  let complete = true;
+  for (const root of opts.roots ?? sessionRoots()) {
+    const aliases = await modelAliasesForRoot(root);
+    const dirs = await directories(root);
+    if (dirs === null) {
+      complete = false;
+      continue;
+    }
+    for (const dir of dirs) {
+      let entries;
+      try {
+        entries = await readdir4(dir, { withFileTypes: true });
+      } catch {
+        complete = false;
+        continue;
+      }
+      const files = new Map(
+        entries.filter(
+          (e) => e.isFile() && (isGrokEvidenceFile(e.name) || e.name === "summary.json")
+        ).map((e) => [e.name, path4.join(dir, e.name)])
+      );
+      let projectDir = dir;
+      let sessionFallback = path4.basename(dir);
+      let child = false;
+      let parentSession;
+      const summary = files.get("summary.json");
+      if (summary) {
+        const read2 = await stableRead(summary, false);
+        if (!read2.complete) {
+          complete = false;
+          stats.filesUnreadable++;
+          continue;
+        }
+        const value = asObj(read2.json);
+        const info = value && asObj(value.info);
+        projectDir = asStr(info?.cwd) ?? asStr(value?.cwd) ?? dir;
+        sessionFallback = asStr(value?.sessionId) ?? sessionFallback;
+        parentSession = asStr(value?.parentSessionId) ?? asStr(value?.parent_session_id) ?? asStr(info?.parentSessionId) ?? asStr(info?.parent_session_id) ?? void 0;
+        child = parentSession !== void 0;
+      }
+      let rows = [];
+      let precedence = 0;
+      const usage = files.get("usage.json");
+      if (usage) {
+        stats.filesFound++;
+        const read2 = await stableRead(usage, false);
+        if (!read2.complete) {
+          complete = false;
+          stats.filesUnreadable++;
+          continue;
+        }
+        stats.filesRead++;
+        rows = sidecarContributions(read2.json, projectDir);
+        if (rows.length > 0) precedence = 2;
+      }
+      if (child) {
+        rows = [];
+        precedence = 0;
+      }
+      const eventState = createGrokEventState(parentSession);
+      const updates = files.get("updates.jsonl");
+      if (updates) {
+        const useTerminalUsage = rows.length === 0 && !child;
+        stats.filesFound++;
+        const read2 = await stableRead(updates, true);
+        if (!read2.complete) {
+          complete = false;
+          stats.filesUnreadable++;
+          continue;
+        }
+        stats.filesRead++;
+        for (const value of read2.lines ?? []) {
+          if (value === null) {
+            agg.parseErrors++;
+            continue;
+          }
+          ingestUpdate(agg, eventState, value, projectDir, opts.sinceMs);
+          if (useTerminalUsage) {
+            const row = terminalContribution(value, projectDir);
+            if (row) rows.push(row);
+          }
+        }
+        if (rows.length > 0) precedence = 1;
+      }
+      const events = files.get("events.jsonl");
+      if (events) {
+        stats.filesFound++;
+        const read2 = await stableRead(events, true);
+        if (!read2.complete) {
+          complete = false;
+          stats.filesUnreadable++;
+          continue;
+        }
+        stats.filesRead++;
+        for (const value of read2.lines ?? []) {
+          if (value === null) agg.parseErrors++;
+          else
+            ingestEvent2(
+              agg,
+              eventState,
+              value,
+              sessionFallback,
+              projectDir,
+              opts.sinceMs
+            );
+        }
+      }
+      rows = rows.filter(
+        (row) => opts.sinceMs === void 0 || row.tsMs >= opts.sinceMs
+      );
+      rows = rows.map((row) => ({
+        ...row,
+        models: row.models.map(({ model, counts: counts2 }) => ({
+          model: aliases.get(model) ?? model,
+          counts: counts2
+        }))
+      }));
+      if (rows.length > 0) {
+        const sessionId = rows[0]?.sessionId;
+        const held = candidates.get(sessionId);
+        const total = (values) => values.flatMap((value) => value.models).reduce((sum, model) => sum + countsTotal(model.counts), 0);
+        if (!held || precedence > held.precedence || precedence === held.precedence && total(rows) > total(held.rows))
+          candidates.set(sessionId, { precedence, rows });
+      }
+      opts.onProgress?.(stats.filesFound);
+    }
+  }
+  for (const { rows } of candidates.values()) {
+    for (const row of rows) {
+      ingestContribution(agg, row);
+      const dates = sessionDates.get(row.sessionId) ?? /* @__PURE__ */ new Set();
+      dates.add(new Date(row.tsMs).toISOString().slice(0, 10));
+      sessionDates.set(row.sessionId, dates);
+    }
+  }
+  return { stats, complete, sessionDates };
+}
+
+// src/harness/grok/adapter.ts
+var GROK_HARNESS_NAME = "grok-build";
+var GROK_BUILTIN_TOOLS = /* @__PURE__ */ new Set([
+  "run_terminal_command",
+  "read_file",
+  "write_file",
+  "search",
+  "web_search"
+]);
+var grokAdapter = {
+  name: GROK_HARNESS_NAME,
+  builtinTools: GROK_BUILTIN_TOOLS,
+  detect: (opts) => hasRecentFile(
+    opts.roots ?? sessionRoots(),
+    isGrokEvidenceFile,
+    opts.sinceMs
+  ),
+  async scan(opts) {
+    const aggregate = createAggregate4();
+    const result = await scan3(aggregate, opts);
+    return {
+      aggregate,
+      stats: result.stats,
+      workflow: aggregate.workflow.finish(),
+      workflowLocal: aggregate.workflowLocal,
+      scanComplete: result.complete,
+      sessionDates: result.sessionDates
+    };
+  }
+};
+
 // src/harness/opencode/analyzer.ts
 var OPENCODE_BUILTIN_TOOLS = /* @__PURE__ */ new Set([
   "apply_patch",
@@ -5247,7 +6079,7 @@ var OPENCODE_BUILTIN_TOOLS = /* @__PURE__ */ new Set([
   "websearch",
   "write"
 ]);
-function createAggregate4() {
+function createAggregate5() {
   const workflowLocal = createWorkflowLocalSources();
   return Object.assign(createAggregate(), {
     workflow: createHarnessWorkflowReducer("opencode", workflowLocal),
@@ -5296,7 +6128,7 @@ function ingestMessageRow(agg, state, row) {
   agg.assistantRecords++;
   agg.distinctResponses++;
   if (tsMs === null) agg.untimestampedResponses++;
-  const counts = {
+  const counts2 = {
     input: asNum(row.input),
     output: asNum(row.output),
     cacheWrite5m: 0,
@@ -5304,7 +6136,7 @@ function ingestMessageRow(agg, state, row) {
     cacheWriteUnsplit: asNum(row.cacheWrite),
     cacheRead: asNum(row.cacheRead)
   };
-  const total = counts.input + counts.output + counts.cacheWriteUnsplit + counts.cacheRead;
+  const total = counts2.input + counts2.output + counts2.cacheWriteUnsplit + counts2.cacheRead;
   if (session?.parentId) agg.sidechainTokens += total;
   else agg.mainTokens += total;
   const provider = asStr(row.providerId);
@@ -5313,8 +6145,8 @@ function ingestMessageRow(agg, state, row) {
   addModelUsage(
     agg,
     modelKey,
-    counts,
-    apiEquivalentCost(modelKey, counts, tsMs),
+    counts2,
+    apiEquivalentCost(modelKey, counts2, tsMs),
     1,
     { tsMs, sidechain: Boolean(session?.parentId) }
   );
@@ -5329,7 +6161,7 @@ function ingestMessageRow(agg, state, row) {
       tsMs,
       ...provider && model ? { model: `${provider}:${model}` } : {},
       thinkingTokens: asNum(row.reasoning),
-      responseTokens: counts.output,
+      responseTokens: counts2.output,
       routingTokens: total,
       ...completed > tsMs ? { durationSec: (completed - tsMs) / 1e3 } : {}
     });
@@ -5412,14 +6244,14 @@ function noteConfiguredMcpServers2(agg, state, serverNames) {
 
 // src/harness/opencode/scan.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { readdir as readdir4, stat as stat4 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import path4 from "node:path";
+import { readdir as readdir5, stat as stat5 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import path5 from "node:path";
 var OPENCODE_MIGRATION_CEILING = 20260622202450;
 function opencodeDataDirs() {
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg || path4.join(homedir8(), ".local", "share");
-  return [path4.join(base, "opencode")];
+  const base = xdg || path5.join(homedir9(), ".local", "share");
+  return [path5.join(base, "opencode")];
 }
 function isStoreFile(basename2) {
   return basename2 === "opencode.db" || /^opencode-[^/]+\.db$/.test(basename2);
@@ -5428,8 +6260,8 @@ async function dbFilesIn(root) {
   const override = process.env.OPENCODE_DB;
   if (override) return [override];
   try {
-    const entries = await readdir4(root, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && isStoreFile(e.name)).map((e) => path4.join(root, e.name)).sort();
+    const entries = await readdir5(root, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && isStoreFile(e.name)).map((e) => path5.join(root, e.name)).sort();
   } catch {
     return [];
   }
@@ -5449,7 +6281,7 @@ function errorClass2(e) {
   return e instanceof Error ? e.constructor.name : "unknown";
 }
 var readError2 = (reason) => Object.assign(new Error(reason), { code: reason });
-async function scan3(agg, opts = {}) {
+async function scan4(agg, opts = {}) {
   const stats = emptyScanStats();
   const open2 = await loadSqlite();
   const sinceMs = opts.sinceMs ?? 0;
@@ -5466,7 +6298,7 @@ async function scan3(agg, opts = {}) {
       } catch (e) {
         stats.filesUnreadable++;
         stats.unreadableFiles.push({
-          path: path4.basename(file),
+          path: path5.basename(file),
           reason: errorClass2(e)
         });
       }
@@ -5633,8 +6465,8 @@ function pickTs(jsonTs, columnTs) {
 }
 function opencodeConfigFile() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg || path4.join(homedir8(), ".config");
-  return path4.join(base, "opencode", "opencode.json");
+  const base = xdg || path5.join(homedir9(), ".config");
+  return path5.join(base, "opencode", "opencode.json");
 }
 function readConfiguredMcpServers2(agg, state, configFile) {
   const file = configFile ?? opencodeConfigFile();
@@ -5708,7 +6540,7 @@ async function detectOpencode(opts) {
 }
 async function exists3(p8) {
   try {
-    await stat4(p8);
+    await stat5(p8);
     return true;
   } catch {
     return false;
@@ -5727,8 +6559,8 @@ var opencodeAdapter = {
     });
   },
   async scan(opts) {
-    const aggregate = createAggregate4();
-    const stats = await scan3(aggregate, {
+    const aggregate = createAggregate5();
+    const stats = await scan4(aggregate, {
       sinceMs: opts.sinceMs,
       ...opts.onProgress ? { onProgress: opts.onProgress } : {}
     });
@@ -5742,7 +6574,7 @@ var opencodeAdapter = {
 };
 
 // src/harness/pi/analyzer.ts
-function createAggregate5() {
+function createAggregate6() {
   const workflowLocal = createWorkflowLocalSources();
   return Object.assign(createAggregate(), {
     workflow: createHarnessWorkflowReducer("pi-mono", workflowLocal),
@@ -5811,7 +6643,7 @@ function ingestEntry(agg, raw, state, fold, sinceMs) {
     if (outcome !== "duplicate") {
       if (state.sessionId && tsMs !== null) {
         const usage = asObj(message.usage);
-        const counts = readCounts2(message.usage);
+        const counts2 = readCounts2(message.usage);
         agg.workflow.ingest({
           type: "response",
           session: state.sessionId,
@@ -5820,8 +6652,8 @@ function ingestEntry(agg, raw, state, fold, sinceMs) {
           tsMs,
           ...state.modelKey ? { model: state.modelKey } : {},
           thinkingTokens: usage ? asNum(usage.reasoning) : 0,
-          responseTokens: counts?.output ?? 0,
-          routingTokens: counts ? countsTotal(counts) : 0
+          responseTokens: counts2?.output ?? 0,
+          routingTokens: counts2 ? countsTotal(counts2) : 0
         });
         ingestContent(agg, message.content, state.sessionId, state.cwd, tsMs);
         agg.workflow.ingest({
@@ -5848,9 +6680,9 @@ function noteActivity2(agg, state, tsMs) {
   agg.projectDirs.add(state.cwd ?? "(unknown)");
 }
 function countUsage(agg, fold, rec, msgTsMs, usageRaw, modelKey, tsMs, priceable = true) {
-  const counts = readCounts2(usageRaw);
-  if (!counts) return "none";
-  const total = countsTotal(counts);
+  const counts2 = readCounts2(usageRaw);
+  if (!counts2) return "none";
+  const total = countsTotal(counts2);
   if (total === 0) return "none";
   const id = asStr(rec.id);
   if (id) {
@@ -5869,8 +6701,8 @@ function countUsage(agg, fold, rec, msgTsMs, usageRaw, modelKey, tsMs, priceable
   addModelUsage(
     agg,
     key2,
-    counts,
-    priceable ? apiEquivalentCost(key2, counts, tsMs) : null,
+    counts2,
+    priceable ? apiEquivalentCost(key2, counts2, tsMs) : null,
     1,
     { tsMs }
   );
@@ -5935,18 +6767,18 @@ function readCounts2(usageRaw) {
 }
 
 // src/harness/pi/scan.ts
-import { createReadStream as createReadStream2 } from "node:fs";
-import { readdir as readdir5, realpath as realpath3, stat as stat5 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import path5 from "node:path";
-import readline2 from "node:readline";
+import { createReadStream as createReadStream3 } from "node:fs";
+import { readdir as readdir6, realpath as realpath3, stat as stat6 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import path6 from "node:path";
+import readline3 from "node:readline";
 var MAX_SESSION_VERSION = 3;
 function piAgentDir() {
-  return process.env.PI_CODING_AGENT_DIR || path5.join(homedir9(), ".pi", "agent");
+  return process.env.PI_CODING_AGENT_DIR || path6.join(homedir10(), ".pi", "agent");
 }
-function sessionRoots() {
+function sessionRoots2() {
   const override = process.env.PI_CODING_AGENT_SESSION_DIR;
-  return [override || path5.join(piAgentDir(), "sessions")];
+  return [override || path6.join(piAgentDir(), "sessions")];
 }
 var SESSION_FILE_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/;
 function isSessionFile(basename2) {
@@ -5955,21 +6787,21 @@ function isSessionFile(basename2) {
 async function* walkSessions(dir) {
   let entries;
   try {
-    entries = await readdir5(dir, { withFileTypes: true });
+    entries = await readdir6(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
-    const full = path5.join(dir, e.name);
+    const full = path6.join(dir, e.name);
     if (e.isDirectory()) yield* walkSessions(full);
     else if (e.isFile() && isSessionFile(e.name)) yield full;
   }
 }
-async function scan4(agg, opts = {}) {
+async function scan5(agg, opts = {}) {
   const stats = emptyScanStats();
   const visited = /* @__PURE__ */ new Set();
   const fold = createFoldState();
-  for (const root of opts.roots ?? sessionRoots()) {
+  for (const root of opts.roots ?? sessionRoots2()) {
     if (!await exists4(root)) continue;
     for await (const file of walkSessions(root)) {
       stats.filesFound++;
@@ -5986,7 +6818,7 @@ async function scan4(agg, opts = {}) {
       visited.add(resolved);
       if (opts.sinceMs !== void 0) {
         try {
-          const st = await stat5(file);
+          const st = await stat6(file);
           if (st.mtimeMs < opts.sinceMs) {
             stats.filesSkippedByMtime++;
             continue;
@@ -6008,7 +6840,7 @@ async function scan4(agg, opts = {}) {
           stats.filesUnreadable++;
           stats.filesRead--;
           stats.unreadableFiles.push({
-            path: path5.relative(root, file),
+            path: path6.relative(root, file),
             reason: "version-too-new"
           });
         }
@@ -6016,7 +6848,7 @@ async function scan4(agg, opts = {}) {
         stats.filesUnreadable++;
         stats.filesRead--;
         stats.unreadableFiles.push({
-          path: path5.relative(root, file),
+          path: path6.relative(root, file),
           reason: "read-error"
         });
       }
@@ -6026,15 +6858,15 @@ async function scan4(agg, opts = {}) {
 }
 async function exists4(p8) {
   try {
-    await stat5(p8);
+    await stat6(p8);
     return true;
   } catch {
     return false;
   }
 }
 async function ingestFile3(agg, fold, file, sinceMs) {
-  const rl = readline2.createInterface({
-    input: createReadStream2(file, { encoding: "utf8" }),
+  const rl = readline3.createInterface({
+    input: createReadStream3(file, { encoding: "utf8" }),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   const state = createFileState2();
@@ -6087,14 +6919,14 @@ var piAdapter = {
   builtinTools: PI_BUILTIN_TOOLS,
   async detect(opts) {
     return hasRecentFile(
-      opts.roots ?? sessionRoots(),
+      opts.roots ?? sessionRoots2(),
       isSessionFile,
       opts.sinceMs
     );
   },
   async scan(opts) {
-    const aggregate = createAggregate5();
-    const stats = await scan4(aggregate, {
+    const aggregate = createAggregate6();
+    const stats = await scan5(aggregate, {
       sinceMs: opts.sinceMs,
       ...opts.onProgress ? { onProgress: opts.onProgress } : {}
     });
@@ -6111,12 +6943,14 @@ var piAdapter = {
 var HARNESS_ADAPTERS = [
   claudeAdapter,
   codexAdapter,
+  grokAdapter,
   opencodeAdapter,
   piAdapter
 ];
 function harnessLabel2(name) {
   if (name === CLAUDE_HARNESS_NAME) return "Claude Code";
   if (name === CODEX_HARNESS_NAME) return "Codex";
+  if (name === GROK_HARNESS_NAME) return "Grok Build";
   if (name === OPENCODE_HARNESS_NAME) return "opencode";
   if (name === PI_HARNESS_NAME) return "Pi";
   return name;
@@ -6150,7 +6984,7 @@ var MCP_ADD_ARGS = [
   "mcp"
 ];
 var MCP_REMOVE_ARGS = ["mcp", "remove", "--scope", "user", "aistack"];
-var SKILL_DEST = join6(homedir10(), ".claude", "skills", "aistack-sync");
+var SKILL_DEST = join6(homedir11(), ".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";
@@ -6383,9 +7217,9 @@ async function createCommand() {
 import { hostname } from "node:os";
 import * as p5 from "@clack/prompts";
 import open from "open";
-function proposedMachineName(read = hostname) {
+function proposedMachineName(read2 = hostname) {
   try {
-    const name = read().trim().replace(/\.local$/i, "");
+    const name = read2().trim().replace(/\.local$/i, "");
     if (!name || name.length > 64) return void 0;
     return name;
   } catch {
@@ -6474,11 +7308,11 @@ import * as p7 from "@clack/prompts";
 // src/autosync/codexHook.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir12 } from "node:os";
 import { dirname as dirname5, join as join8 } from "node:path";
 import { parse } from "smol-toml";
 function codexHome2() {
-  return process.env.CODEX_HOME || join8(homedir11(), ".codex");
+  return process.env.CODEX_HOME || join8(homedir12(), ".codex");
 }
 function codexHooksFile() {
   return join8(codexHome2(), "hooks.json");
@@ -6504,9 +7338,9 @@ function readHooksJson(file) {
 }
 var CODEX_TRUST_INSTRUCTION = "Codex hook written - 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 read2 = readHooksJson(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const settings = read2.settings;
   const hooks = settings.hooks ?? {};
   const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
   const kept = sessionStart.map((m) => ({
@@ -6526,9 +7360,9 @@ function installCodexAutoSyncHook(file = codexHooksFile()) {
 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 read2 = readHooksJson(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const settings = read2.settings;
   const sessionStart = settings.hooks?.SessionStart;
   if (!Array.isArray(sessionStart)) {
     return { ok: true, message: "no Codex hook to remove" };
@@ -6553,18 +7387,18 @@ function removeCodexAutoSyncHook(file = codexHooksFile()) {
   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;
+  const read2 = readHooksJson(file);
+  if ("error" in read2) return false;
+  const sessionStart = read2.settings.hooks?.SessionStart;
   if (!Array.isArray(sessionStart)) return false;
   return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs(h)));
 }
 function codexHookTrusted(configFile = codexConfigFile(), hooksFile = codexHooksFile()) {
   try {
     const config = parse(readFileSync9(configFile, "utf-8"));
-    const read = readHooksJson(hooksFile);
-    if ("error" in read) return null;
-    const sessionStart = read.settings.hooks?.SessionStart;
+    const read2 = readHooksJson(hooksFile);
+    if ("error" in read2) return null;
+    const sessionStart = read2.settings.hooks?.SessionStart;
     if (!Array.isArray(sessionStart)) return false;
     const matches = [];
     for (const [groupIndex, group] of sessionStart.entries()) {
@@ -6617,19 +7451,131 @@ function canonicalJson2(value) {
 // src/autosync/optin.ts
 import * as p6 from "@clack/prompts";
 
-// src/autosync/hook.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
+// src/autosync/grokHook.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync10,
+  unlinkSync,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { homedir as homedir13, platform as platform2 } from "node:os";
 import { dirname as dirname6, join as join9 } from "node:path";
-var CLAUDE_SETTINGS_FILE = join9(homedir12(), ".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";
+var GROK_HOOK_FILE = join9(
+  process.env.GROK_HOME || join9(homedir13(), ".grok"),
+  "hooks",
+  "aistack.json"
+);
+var SYNC_COMMAND = "npx -y @use-aistack/cli@latest sync --auto || npx -y --prefer-offline @use-aistack/cli sync --auto";
+function grokHookCommand(os = platform2()) {
+  if (os === "win32") {
+    return `Start-Process -WindowStyle Hidden -FilePath "cmd.exe" -ArgumentList '/d /s /c "set AISTACK_HOOK_SOURCE=grok&& (${SYNC_COMMAND}) >NUL 2>&1"'`;
+  }
+  if (os === "darwin") {
+    return `nohup sh -c 'export AISTACK_HOOK_SOURCE=grok; ${SYNC_COMMAND}' </dev/null >/dev/null 2>&1 &`;
+  }
+  return `setsid nohup sh -c 'export AISTACK_HOOK_SOURCE=grok; ${SYNC_COMMAND}' >/dev/null 2>&1 &`;
+}
+function readHookFile(file) {
+  if (!existsSync9(file)) return { value: {} };
+  try {
+    const value = JSON.parse(readFileSync10(file, "utf-8"));
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const candidate = value;
+      if (candidate.hooks !== void 0 && (!candidate.hooks || typeof candidate.hooks !== "object" || Array.isArray(candidate.hooks) || Object.values(candidate.hooks).some(
+        (groups) => !Array.isArray(groups)
+      ))) {
+        return {
+          error: `${file} has a malformed hooks object. Fix it, then retry.`
+        };
+      }
+      return { value: candidate };
+    }
+  } catch {
+    return { error: `${file} is not valid JSON. Fix it, then retry.` };
+  }
+  return { error: `${file} does not hold a JSON object` };
+}
 function isOurs2(entry) {
   return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
 }
+function installGrokAutoSyncHook(file = GROK_HOOK_FILE, os = platform2()) {
+  const read2 = readHookFile(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const foreignKeys = Object.keys(read2.value).filter((key2) => key2 !== "hooks");
+  const foreignEvents = Object.keys(read2.value.hooks ?? {}).filter(
+    (key2) => key2 !== "SessionStart"
+  );
+  const sessionStart = read2.value.hooks?.SessionStart ?? [];
+  const foreignHandlers = sessionStart.flatMap(
+    (group) => (group.hooks ?? []).filter((entry) => !isOurs2(entry))
+  );
+  if (foreignKeys.length > 0 || foreignEvents.length > 0 || foreignHandlers.length > 0) {
+    return {
+      ok: false,
+      message: `${file} contains hooks not owned by AI Stack. Move them to another Grok hook file, then retry.`
+    };
+  }
+  const value = {
+    hooks: {
+      SessionStart: [
+        {
+          hooks: [
+            { type: "command", command: grokHookCommand(os), timeout: 5 }
+          ]
+        }
+      ]
+    }
+  };
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync4(file, `${JSON.stringify(value, null, 2)}
+`);
+  return {
+    ok: true,
+    message: `Grok Build SessionStart hook written to ${file}. Start a new Grok session or reload hooks before expecting it to run.`
+  };
+}
+function removeGrokAutoSyncHook(file = GROK_HOOK_FILE) {
+  if (!existsSync9(file))
+    return { ok: true, message: "no Grok Build hook to remove" };
+  const read2 = readHookFile(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const entries = read2.value.hooks?.SessionStart ?? [];
+  const onlyOurs = Object.keys(read2.value).every((key2) => key2 === "hooks") && Object.keys(read2.value.hooks ?? {}).every(
+    (key2) => key2 === "SessionStart"
+  ) && entries.every(
+    (group) => (group.hooks ?? []).every((entry) => isOurs2(entry))
+  );
+  if (!onlyOurs) {
+    return {
+      ok: false,
+      message: `${file} contains hooks not owned by AI Stack and was not removed.`
+    };
+  }
+  unlinkSync(file);
+  return { ok: true, message: `Grok Build hook removed from ${file}` };
+}
+function grokAutoSyncHookInstalled(file = GROK_HOOK_FILE) {
+  const read2 = readHookFile(file);
+  if ("error" in read2) return false;
+  return (read2.value.hooks?.SessionStart ?? []).some(
+    (group) => (group.hooks ?? []).some((entry) => isOurs2(entry))
+  );
+}
+
+// src/autosync/hook.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname7, join as join10 } from "node:path";
+var CLAUDE_SETTINGS_FILE = join10(homedir14(), ".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 isOurs3(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: {} };
+  if (!existsSync10(file)) return { settings: {} };
   try {
-    const raw = JSON.parse(readFileSync10(file, "utf-8"));
+    const raw = JSON.parse(readFileSync11(file, "utf-8"));
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       return { settings: raw };
     }
@@ -6639,36 +7585,36 @@ function readClaudeSettings(file) {
   }
 }
 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 read2 = readClaudeSettings(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const settings = read2.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))
+    hooks: (m.hooks ?? []).filter((h) => !isOurs3(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)}
+  mkdirSync5(dirname7(file), { recursive: true });
+  writeFileSync5(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;
+  if (!existsSync10(file)) return { ok: true, message: "no hook to remove" };
+  const read2 = readClaudeSettings(file);
+  if ("error" in read2) return { ok: false, message: read2.error };
+  const settings = read2.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))
+    hooks: (m.hooks ?? []).filter((h) => !isOurs3(h))
   })).filter((m) => (m.hooks?.length ?? 0) > 0);
   const hooks = { ...settings.hooks };
   if (kept.length > 0) {
@@ -6681,21 +7627,21 @@ function removeAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
   } else {
     delete settings.hooks;
   }
-  writeFileSync4(file, `${JSON.stringify(settings, null, 2)}
+  writeFileSync5(file, `${JSON.stringify(settings, null, 2)}
 `);
   return { ok: true, message: `hook removed from ${file}` };
 }
 function autoSyncHookInstalled(file = CLAUDE_SETTINGS_FILE) {
-  const read = readClaudeSettings(file);
-  if ("error" in read) return false;
-  const sessionStart = read.settings.hooks?.SessionStart;
+  const read2 = readClaudeSettings(file);
+  if ("error" in read2) return false;
+  const sessionStart = read2.settings.hooks?.SessionStart;
   if (!Array.isArray(sessionStart)) return false;
-  return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs2(h)));
+  return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs3(h)));
 }
 
 // src/autosync/optin.ts
 var NOT_LINKED = "This machine is not linked to an aistack account, and the auto-sync permission lives on your stack. Run `npx @use-aistack/cli sync` first.";
-var NOTHING_TO_TRIGGER = `No Claude Code or Codex session on this machine in the last ${DEFAULT_WINDOW_DAYS} days, so nothing would trigger an auto-sync. Nothing was changed.`;
+var NOTHING_TO_TRIGGER = `No supported session on this machine in the last ${DEFAULT_WINDOW_DAYS} days, so nothing would trigger an auto-sync. Nothing was changed.`;
 async function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {}) {
   frequencyHours = normalizeFrequencyHours(frequencyHours);
   const detected = await (deps.detectedImpl ?? detectedAdapters)();
@@ -6728,6 +7674,10 @@ async function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {
       trustLine = codexResult.message;
     }
   }
+  if (names.has(GROK_HARNESS_NAME)) {
+    const grokResult = (deps.installGrokHook ?? installGrokAutoSyncHook)();
+    if (!grokResult.ok) return grokResult;
+  }
   saveSettings(
     {
       autoSyncAnswered: true,
@@ -6759,7 +7709,8 @@ async function disableAutoSync(deps = {}) {
   );
   const result = (deps.removeHook ?? removeAutoSyncHook)();
   const codexResult = (deps.removeCodexHook ?? removeCodexAutoSyncHook)();
-  const failures = [result, codexResult].filter((r) => !r.ok).map((r) => r.message);
+  const grokResult = (deps.removeGrokHook ?? removeGrokAutoSyncHook)();
+  const failures = [result, codexResult, grokResult].filter((r) => !r.ok).map((r) => r.message);
   const token = (deps.getTokenImpl ?? getToken)();
   if (token !== null) {
     try {
@@ -6782,7 +7733,40 @@ async function disableAutoSync(deps = {}) {
   };
 }
 async function reconcileAutoSync(permission, deps = {}) {
-  if (permission?.enabled !== true) return null;
+  if (permission === null) return null;
+  if (permission.enabled !== true) {
+    const settings = getSettings(deps.settingsFile);
+    saveSettings(
+      {
+        autoSyncAnswered: true,
+        autoSync: {
+          enabled: false,
+          frequencyHours: normalizeFrequencyHours(
+            permission.frequencyHours ?? settings.autoSync?.frequencyHours
+          )
+        }
+      },
+      deps.settingsFile
+    );
+    const results = [
+      (deps.removeHook ?? removeAutoSyncHook)(),
+      (deps.removeCodexHook ?? removeCodexAutoSyncHook)(),
+      (deps.removeGrokHook ?? removeGrokAutoSyncHook)()
+    ];
+    const failures2 = results.filter((result) => !result.ok);
+    if (failures2.length > 0) {
+      return {
+        ok: false,
+        message: `Auto-sync is off on this machine, but a trigger could not be removed: ${failures2.map((result) => result.message).join("; ")}. The next interactive sync will retry.`
+      };
+    }
+    const changed = settings.autoSync?.enabled !== false || results.some((result) => !result.message.toLowerCase().startsWith("no "));
+    if (!changed) return null;
+    return {
+      ok: true,
+      message: "Auto-sync is off on this machine. Removed its local triggers."
+    };
+  }
   const detected = await (deps.detectedImpl ?? detectedAdapters)();
   if (detected.length === 0) return null;
   const names = new Set(detected.map((a) => a.name));
@@ -6804,6 +7788,11 @@ async function reconcileAutoSync(permission, deps = {}) {
     deps.codexHookInstalledImpl ?? codexAutoSyncHookInstalled,
     deps.installCodexHook ?? installCodexAutoSyncHook
   );
+  install(
+    GROK_HARNESS_NAME,
+    deps.grokHookInstalledImpl ?? grokAutoSyncHookInstalled,
+    deps.installGrokHook ?? installGrokAutoSyncHook
+  );
   if (failures.length > 0) {
     return {
       ok: false,
@@ -6888,15 +7877,18 @@ async function offerAutoSyncOptIn(deps = {}) {
 // src/autosync/run.ts
 import {
   appendFileSync,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync11,
-  writeFileSync as writeFileSync5
+  closeSync,
+  mkdirSync as mkdirSync7,
+  openSync,
+  readFileSync as readFileSync13,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname8, join as join11 } from "node:path";
 
 // src/sync/stage.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // src/usage/days.ts
 var round6 = (n) => Math.round(n * 1e6) / 1e6;
@@ -6989,7 +7981,13 @@ function mergeUsageDays(perHarness) {
 function buildMeasuredDays(input) {
   const workflowByDate = /* @__PURE__ */ new Map();
   for (const day of input.workflow ?? []) workflowByDate.set(day.date, day);
-  const dates = [.../* @__PURE__ */ new Set([...input.usage.keys(), ...workflowByDate.keys()])].filter(
+  const dates = [
+    .../* @__PURE__ */ new Set([
+      ...input.usage.keys(),
+      ...workflowByDate.keys(),
+      ...input.includeDates ?? []
+    ])
+  ].filter(
     (d) => /^\d{4}-\d{2}-\d{2}$/.test(d) && d >= input.from && d <= input.to
   ).sort();
   return dates.map((date) => {
@@ -7046,7 +8044,7 @@ function selectDaysToPublish(input) {
 
 // src/workflow/git.ts
 import { execFile, execFileSync as execFileSync2 } from "node:child_process";
-import path6 from "node:path";
+import path7 from "node:path";
 var TEST_FILE_RULE_VERSION = "test-files/v2";
 var FILE_TYPE_RULE_VERSION = "file-types/v2";
 var COMMIT_SET_RULE_VERSION = "commit-set/v1";
@@ -7329,9 +8327,9 @@ function reduceGitHistories(histories, options) {
         if (included) seenCommits.add(hash);
         continue;
       }
-      const stat6 = parseNumstat(field);
-      if (!stat6) continue;
-      let file = stat6.file;
+      const stat7 = parseNumstat(field);
+      if (!stat7) continue;
+      let file = stat7.file;
       if (file.length === 0) {
         fieldIndex += 2;
         file = fields[fieldIndex] ?? fields[fieldIndex - 1] ?? "";
@@ -7339,13 +8337,13 @@ function reduceGitHistories(histories, options) {
       if (!current?.included) continue;
       if (isUnauthoredPath(file)) continue;
       current.authored = true;
-      const fileChangedLines = stat6.additions + stat6.removals;
-      current.additions += stat6.additions;
-      current.removals += stat6.removals;
+      const fileChangedLines = stat7.additions + stat7.removals;
+      current.additions += stat7.additions;
+      current.removals += stat7.removals;
       current.changedLines += fileChangedLines;
       if (isTestFile(file)) current.touchesTest = true;
       if (fileChangedLines <= 0) continue;
-      const extension = path6.extname(file).toLowerCase();
+      const extension = path7.extname(file).toLowerCase();
       if (APPROVED_EXTENSIONS.has(extension)) {
         current.extensionLines.set(
           extension,
@@ -7434,7 +8432,7 @@ function buildWorkflowExtraction(harnessWorkflows, git, utcOffsetMinutes = machi
     ])
   ].sort();
   return {
-    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    aggregateVersion: WORKFLOW_AGGREGATES_V3,
     utcOffsetMinutes,
     days: dates.map((date) => {
       const projects = projectDays.get(date)?.size;
@@ -7448,6 +8446,47 @@ function buildWorkflowExtraction(harnessWorkflows, git, utcOffsetMinutes = machi
   };
 }
 
+// src/sync/grokDateCache.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import path8 from "node:path";
+var defaultFile = path8.join(
+  homedir15(),
+  ".config",
+  "aistack",
+  "grok-session-dates.json"
+);
+function grokCacheScope(baseUrl, stack, token) {
+  return createHash2("sha256").update(`${baseUrl}\0${stack}\0${token}`).digest("hex");
+}
+function read(file) {
+  if (!existsSync11(file)) return {};
+  try {
+    const value = JSON.parse(readFileSync12(file, "utf8"));
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+function loadGrokDateHints(scope, file = defaultFile) {
+  return read(file)[scope] ?? {};
+}
+function saveGrokDateHints(scope, hints, file = defaultFile) {
+  const cache = read(file);
+  cache[scope] = hints;
+  mkdirSync6(path8.dirname(file), { recursive: true });
+  writeFileSync6(file, JSON.stringify(cache, null, 2));
+}
+function mapToHints(value, floor) {
+  return Object.fromEntries(
+    [...value].map(([id, dates]) => [
+      id,
+      [...dates].filter((d) => d >= floor).sort()
+    ])
+  );
+}
+
 // src/sync/summary.ts
 function fmtTokens(n) {
   const sig = (v) => {
@@ -7690,7 +8729,7 @@ var PHASE_ORDER = ["scout", "build", "verify", "handoff", "unknown"];
 function workflowBlock(workflowDays, utcOffsetMinutes, host) {
   const out = [];
   const folded = foldWorkflowDays(workflowDays, {
-    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    aggregateVersion: WORKFLOW_AGGREGATES_V3,
     utcOffsetMinutes
   });
   const harnesses = folded?.harnesses ?? [];
@@ -7700,7 +8739,7 @@ function workflowBlock(workflowDays, utcOffsetMinutes, host) {
     ...new Set(withPlaybook.map((h) => h.phase?.ruleVersion ?? ""))
   ].filter(Boolean);
   out.push(
-    `workflow  ${harnesses.length} harness${harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${WORKFLOW_AGGREGATES_V2}`
+    `workflow  ${harnesses.length} harness${harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${WORKFLOW_AGGREGATES_V3}`
   );
   const first = folded?.dates[0];
   const last = folded?.dates.at(-1);
@@ -7848,7 +8887,7 @@ function buildGateSummary(ctx) {
 // src/sync/stage.ts
 var utcDate2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 function stageId(bodyJson) {
-  return createHash2("sha256").update(bodyJson).digest("hex").slice(0, 12);
+  return createHash3("sha256").update(bodyJson).digest("hex").slice(0, 12);
 }
 async function stageSync(deps) {
   const now = (deps.now ?? Date.now)();
@@ -7900,6 +8939,9 @@ async function stageSync(deps) {
   const sinceMs = windowStartMs(now, windowDays);
   const daysSinceMs = windowStartMs(now, retentionDays);
   const active2 = await adapters(sinceMs);
+  const historical = await adapters(daysSinceMs);
+  let dayScansComplete = true;
+  let grokCurrentDates = null;
   for (const adapter of active2) {
     progress(`Scanning recent ${adapter.name} usage`);
     const { aggregate, stats } = await adapter.scan({
@@ -7920,12 +8962,15 @@ async function stageSync(deps) {
       })
     );
   }
-  for (const adapter of active2) {
+  for (const adapter of historical) {
     progress(`Reading historical ${adapter.name} days`);
-    const { aggregate, workflow: workflow2, workflowLocal } = await adapter.scan({
+    const { aggregate, workflow: workflow2, workflowLocal, scanComplete, sessionDates } = await adapter.scan({
       sinceMs: daysSinceMs,
       onProgress: (files) => progress(`Reading historical ${adapter.name} days \xB7 ${files} files`)
     });
+    if (scanComplete === false) dayScansComplete = false;
+    if (adapter.name === "grok-build")
+      grokCurrentDates = sessionDates ?? /* @__PURE__ */ new Map();
     workflowScans.push({ aggregate: workflow2, local: workflowLocal });
     usageScans.push(
       buildUsageDays({
@@ -7951,17 +8996,33 @@ async function stageSync(deps) {
       toMs: now
     });
   }
+  const correctionDates = /* @__PURE__ */ new Set();
+  let acknowledgePublish;
+  if (grokCurrentDates && token && config.stack) {
+    const scope = grokCacheScope(deps.baseUrl, config.stack.slug, token);
+    const floor = utcDate2(daysSinceMs);
+    const previous = loadGrokDateHints(scope);
+    const current = mapToHints(grokCurrentDates, floor);
+    for (const dates of Object.values(previous))
+      for (const date of dates) correctionDates.add(date);
+    for (const dates of Object.values(current))
+      for (const date of dates) correctionDates.add(date);
+    if (Object.keys(previous).some((id) => !(id in current)))
+      dayScansComplete = false;
+    acknowledgePublish = () => saveGrokDateHints(scope, current);
+  }
   const localDays = applyDayConsent(
     buildMeasuredDays({
       usage: mergeUsageDays(usageScans),
       ...workflow ? { workflow: workflow.days } : {},
       from: utcDate2(daysSinceMs),
-      to: utcDate2(now)
+      to: utcDate2(now),
+      includeDates: correctionDates
     }),
     config
   );
   const days = selectDaysToPublish({
-    local: localDays,
+    local: dayScansComplete ? localDays : [],
     manifest,
     todayUtc: utcDate2(now)
   });
@@ -7970,7 +9031,7 @@ async function stageSync(deps) {
     config,
     settings.autoSync,
     deps.trigger,
-    active2.length > 0 ? {
+    historical.length > 0 && dayScansComplete ? {
       aggregateVersion: MEASURED_DAYS_V1,
       utcOffsetMinutes: workflow?.utcOffsetMinutes ?? machineUtcOffsetMinutes(),
       days: days.send
@@ -7994,8 +9055,8 @@ async function stageSync(deps) {
     width: process.stdout.columns
   };
   let blockedReason = null;
-  if (built.length === 0) {
-    blockedReason = `No active harness on this machine - no Claude Code and no Codex transcript from the last ${windowDays} days to read.`;
+  if (historical.length === 0) {
+    blockedReason = `No supported harness transcript from the last ${retentionDays} days to read.`;
   } else if (token === null) {
     blockedReason = "This machine is not linked. Run `npx @use-aistack/cli login` first.";
   } else if (config.stack === null) {
@@ -8013,25 +9074,47 @@ async function stageSync(deps) {
     stagedAt: now,
     blockedReason,
     days,
-    prices
+    prices,
+    ...acknowledgePublish ? { acknowledgePublish } : {}
   };
 }
 
 // src/autosync/run.ts
-var SYNC_LOG_FILE = join10(homedir13(), ".config", "aistack", "sync.log");
+var SYNC_LOG_FILE = join11(homedir16(), ".config", "aistack", "sync.log");
 var SYNC_LOG_MAX_LINES = 200;
 var FIX_COMMAND = "npx @use-aistack/cli sync";
 var REVOKED_RESULT = "off - auto-sync is switched off for this stack";
 function appendLogLine(file, line) {
-  mkdirSync5(dirname7(file), { recursive: true });
+  mkdirSync7(dirname8(file), { recursive: true });
   appendFileSync(file, `${line}
 `);
-  const lines2 = readFileSync11(file, "utf-8").split("\n").filter(Boolean);
+  const lines2 = readFileSync13(file, "utf-8").split("\n").filter(Boolean);
   if (lines2.length > SYNC_LOG_MAX_LINES) {
-    writeFileSync5(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
+    writeFileSync7(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
 `);
   }
 }
+function reserveAttempt(file, now, windowMs) {
+  mkdirSync7(dirname8(file), { recursive: true });
+  for (; ; ) {
+    try {
+      const fd = openSync(file, "wx");
+      writeFileSync7(fd, String(now));
+      closeSync(fd);
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const held = Number(readFileSync13(file, "utf-8"));
+      if (Number.isFinite(held) && now - held < windowMs) return false;
+      try {
+        unlinkSync2(file);
+      } catch (unlinkError) {
+        if (unlinkError.code !== "ENOENT")
+          throw unlinkError;
+      }
+    }
+  }
+}
 async function runAutoSync(deps) {
   const now = (deps.now ?? Date.now)();
   const settingsFile = deps.settingsFile;
@@ -8046,9 +9129,13 @@ async function runAutoSync(deps) {
     return;
   }
   const frequencyHours = normalizeFrequencyHours(config.frequencyHours);
+  const windowMs = frequencyHours * 36e5;
   const state = settings.autoSyncState ?? {};
   const lastRunAt = state.lastRunAt ?? 0;
-  if (now - lastRunAt < frequencyHours * 36e5) return;
+  if (now - lastRunAt < windowMs) return;
+  const reservationFile = deps.reservationFile ?? `${settingsFile ?? join11(homedir16(), ".config", "aistack", "settings.json")}.auto-sync-attempt`;
+  if (!reserveAttempt(reservationFile, now, windowMs)) return;
+  saveSettings({ autoSyncState: { ...state, lastRunAt: now } }, settingsFile);
   const stage = deps.stageImpl ?? stageSync;
   const publish = deps.publishImpl ?? syncPublish;
   const loadConfig = deps.loadConfigImpl ?? loadSyncConfig;
@@ -8139,7 +9226,7 @@ async function runAutoSync(deps) {
     logFile,
     `${stamp} fail (${consecutiveFailures} in a row) - ${failure2}`
   );
-  if (shouldWarn) {
+  if (shouldWarn && deps.suppressOutput !== true && process.env.AISTACK_HOOK_SOURCE !== "grok") {
     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.`
@@ -8284,6 +9371,7 @@ async function syncCommand(options = {}) {
   s.start("Publishing");
   try {
     const res = await syncPublish(staged.token, staged.bodyJson);
+    staged.acknowledgePublish?.();
     s.stop("Published");
     const lines2 = [
       `Snapshot received ${fmtReceivedAt(res.receivedAt)}`,
@@ -8514,6 +9602,7 @@ function createSyncServer(deps, send) {
         log7(`consent received, sending stage ${approvedStage.id}`);
         publish(approvedStage.token, approvedStage.bodyJson).then(
           (res) => {
+            approvedStage.acknowledgePublish?.();
             if (staged?.id === approvedStage.id) staged = null;
             const lines2 = [
               `Published. Snapshot received ${fmtReceivedAt(res.receivedAt)}.`,