@use-aistack/cli 0.14.0 → 0.16.0

package/dist/index.js

@@ -377,12 +377,12 @@ function apiEquivalentCost(modelKey, t, atMs) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.14.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.16.0" : "0.0.0-dev";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
-async function request(path9, options = {}) {
-  return fetch(`${BASE_URL}${path9}`, {
+async function request(path14, options = {}) {
+  return fetch(`${BASE_URL}${path14}`, {
     ...options,
     headers: {
       "Content-Type": "application/json",
@@ -800,9 +800,9 @@ function canonicalizeRepoUrl(input) {
 function repoNameFromCanonical(canonical) {
   return parseRepo(canonical)?.repo ?? "";
 }
-function normalizeUpstreamPath(path9) {
-  if (!path9) return "";
-  return path9.split("/").filter(Boolean).join("/");
+function normalizeUpstreamPath(path14) {
+  if (!path14) return "";
+  return path14.split("/").filter(Boolean).join("/");
 }
 
 // src/git.ts
@@ -848,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(path9) {
+function readJson(path14) {
   try {
-    if (!existsSync2(path9)) return null;
-    return JSON.parse(readFileSync2(path9, "utf-8"));
+    if (!existsSync2(path14)) return null;
+    return JSON.parse(readFileSync2(path14, "utf-8"));
   } catch {
     return null;
   }
 }
-function hooksFrom(path9, source, out, seen) {
-  const hooks = readJson(path9)?.hooks;
+function hooksFrom(path14, source, out, seen) {
+  const hooks = readJson(path14)?.hooks;
   if (!hooks || typeof hooks !== "object") return;
   for (const [event, config] of Object.entries(hooks)) {
     const stableKey = `hooks:${source}:${event}`;
@@ -1006,16 +1006,16 @@ function buildMcpResource(name, group, pkg) {
     pkg
   };
 }
-function readText(path9) {
+function readText(path14) {
   try {
-    if (!existsSync3(path9)) return null;
-    return readFileSync3(path9, "utf-8");
+    if (!existsSync3(path14)) return null;
+    return readFileSync3(path14, "utf-8");
   } catch {
     return null;
   }
 }
-function readParsed(path9, parse2) {
-  const raw = readText(path9);
+function readParsed(path14, parse2) {
+  const raw = readText(path14);
   if (raw === null) return null;
   try {
     return parse2(raw);
@@ -1023,14 +1023,14 @@ function readParsed(path9, parse2) {
     return null;
   }
 }
-function readJson2(path9) {
-  return readParsed(path9, JSON.parse);
+function readJson2(path14) {
+  return readParsed(path14, JSON.parse);
 }
-function readYaml(path9) {
-  return readParsed(path9, parseYaml);
+function readYaml(path14) {
+  return readParsed(path14, parseYaml);
 }
-function readToml(path9) {
-  return readParsed(path9, parseToml);
+function readToml(path14) {
+  return readParsed(path14, parseToml);
 }
 function continueListToMap(file) {
   if (!file?.mcpServers?.length) return void 0;
@@ -1169,8 +1169,8 @@ function resolveSource(entry, mpRepoUrl) {
   const src = entry.source;
   if (typeof src === "string") {
     if (!mpRepoUrl) return null;
-    const path9 = src.replace(/^\.\//, "").replace(/\/+$/, "");
-    return { url: mpRepoUrl, path: path9 || void 0 };
+    const path14 = src.replace(/^\.\//, "").replace(/\/+$/, "");
+    return { url: mpRepoUrl, path: path14 || void 0 };
   }
   if (src && typeof src === "object" && src.url) {
     return { url: src.url, path: src.path, sha: src.sha };
@@ -1207,10 +1207,10 @@ function resolvePluginLinks(installed, marketplaces, manifests) {
   }
   return out;
 }
-function readJson3(path9) {
+function readJson3(path14) {
   try {
-    if (!existsSync4(path9)) return null;
-    return JSON.parse(readFileSync4(path9, "utf-8"));
+    if (!existsSync4(path14)) return null;
+    return JSON.parse(readFileSync4(path14, "utf-8"));
   } catch {
     return null;
   }
@@ -1299,8 +1299,8 @@ function loadGitignore(cwd) {
 }
 function readFileSafe(filePath) {
   try {
-    const stat7 = statSync(filePath);
-    if (stat7.size > MAX_FILE_SIZE) return null;
+    const stat8 = statSync(filePath);
+    if (stat8.size > MAX_FILE_SIZE) return null;
     return readFileSync5(filePath, "utf-8");
   } catch {
     return null;
@@ -1519,9 +1519,9 @@ function lines(items) {
     console.log(`${BAR}  ${item}`);
   }
 }
-function section(label, count) {
+function section(label, count2) {
   console.log(`${BAR}`);
-  const countStr = count !== void 0 ? ` ${dim(String(count))}` : "";
+  const countStr = count2 !== void 0 ? ` ${dim(String(count2))}` : "";
   console.log(`${BAR}  ${bold(label.toUpperCase())}${countStr}`);
 }
 function divider() {
@@ -1844,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 homedir11 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 import { dirname as dirname3, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as p3 from "@clack/prompts";
@@ -2442,7 +2442,7 @@ function filterAtoms(atoms, sets) {
     }
     merged.set(published, (merged.get(published) ?? 0) + atom.count);
   }
-  const allowed = [...merged].map(([name, count]) => ({ name, count }));
+  const allowed = [...merged].map(([name, count2]) => ({ name, count: count2 }));
   allowed.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
   keptPrivate.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
   return { allowed, keptPrivate, withheld: keptPrivate.length };
@@ -3199,6 +3199,7 @@ var HANDOFF_MARKERS = {
     "mcp__curia__request_review"
   ],
   codex: ["request_user_input"],
+  cursor: ["ask_question"],
   "grok-build": ["ask_user_question", "request_user_input"],
   opencode: ["question"],
   "pi-mono": []
@@ -3633,13 +3634,13 @@ function canonicalJson(value) {
 function fnv1a64(text) {
   const prime = 0x100000001b3n;
   const mask = 0xffffffffffffffffn;
-  let hash = 0xcbf29ce484222325n;
+  let hash2 = 0xcbf29ce484222325n;
   const bytes = new TextEncoder().encode(text);
   for (const byte of bytes) {
-    hash ^= BigInt(byte);
-    hash = hash * prime & mask;
+    hash2 ^= BigInt(byte);
+    hash2 = hash2 * prime & mask;
   }
-  return hash.toString(16).padStart(16, "0");
+  return hash2.toString(16).padStart(16, "0");
 }
 function dayFingerprint(day) {
   return fnv1a64(
@@ -3732,7 +3733,7 @@ function sanitizeModelId(id) {
 var round4 = (n) => Math.round(n * 1e4) / 1e4;
 var round2 = (n) => Math.round(n * 100) / 100;
 var utcDate = (ms) => new Date(ms).toISOString().slice(0, 10);
-var toAtoms = (pairs) => pairs.map(([name, count]) => ({ name, count }));
+var toAtoms = (pairs) => pairs.map(([name, count2]) => ({ name, count: count2 }));
 function buildCategory(observed, curated, optIns, denominator) {
   const publishable = /* @__PURE__ */ new Set([...curated, ...optIns]);
   const {
@@ -4025,7 +4026,7 @@ var bump2 = (map, key2, amount = 1) => {
 var utcDateOf2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 function asBuckets(map, field) {
   return [...map].map(
-    ([bucket, count]) => ({ bucket, [field]: count })
+    ([bucket, count2]) => ({ bucket, [field]: count2 })
   ).sort((a, b) => a.bucket - b.bucket);
 }
 var PHASE_RANK = {
@@ -4410,7 +4411,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
         0
       );
       const unknown = attributed === 0 ? 0 : windowPhaseSec.unknown / attributed;
-      const routesModels = harness === "claude-code" || harness === "opencode" || harness === "grok-build";
+      const routesModels = harness === "claude-code" || harness === "opencode" || harness === "grok-build" || harness === "cursor";
       const asRows = (map) => {
         const safe = /* @__PURE__ */ new Map();
         for (const [model, tokens] of map) {
@@ -4433,7 +4434,7 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
           date,
           harness,
           sessions: day.sessions,
-          startHours: [...day.startHours].map(([hourUtc, count]) => ({ hourUtc, sessions: count })).sort((a, b) => a.hourUtc - b.hourUtc),
+          startHours: [...day.startHours].map(([hourUtc, count2]) => ({ hourUtc, sessions: count2 })).sort((a, b) => a.hourUtc - b.hourUtc),
           ...day.phase.sessions > 0 ? {
             phase: {
               ruleVersion: PHASE_RULES_V1,
@@ -4561,12 +4562,12 @@ function ingestRecord(agg, raw, ctx) {
   const sessionId = asStr(rec.sessionId);
   if (sessionId) agg.sessions.add(sessionId);
   let tsMs = null;
-  const timestamp = asStr(rec.timestamp);
-  if (timestamp) {
-    const ts = Date.parse(timestamp);
+  const timestamp2 = asStr(rec.timestamp);
+  if (timestamp2) {
+    const ts = Date.parse(timestamp2);
     if (!Number.isNaN(ts)) {
       tsMs = ts;
-      agg.activeDays.add(timestamp.slice(0, 10));
+      agg.activeDays.add(timestamp2.slice(0, 10));
       agg.firstTs = agg.firstTs === null ? ts : Math.min(agg.firstTs, ts);
       agg.lastTs = agg.lastTs === null ? ts : Math.max(agg.lastTs, ts);
     }
@@ -4859,8 +4860,8 @@ function applyContribution(agg, c, sign) {
   agg.webFetchRequests += sign * c.webFetch;
   agg.fallbackAttempts += sign * c.fallbackAttempts;
   agg.untypedMirrors += sign * c.untypedMirrors;
-  for (const [type, count] of c.mirroredIterationTypes) {
-    bump(agg.mirroredIterationTypes, type, sign * count);
+  for (const [type, count2] of c.mirroredIterationTypes) {
+    bump(agg.mirroredIterationTypes, type, sign * count2);
   }
 }
 function ingestContentBlocks(agg, content) {
@@ -5126,9 +5127,9 @@ function ingestLine(agg, raw, state, sinceMs) {
   if (!rec) return;
   agg.records++;
   let tsMs = null;
-  const timestamp = asStr(rec.timestamp);
-  if (timestamp) {
-    const ts = Date.parse(timestamp);
+  const timestamp2 = asStr(rec.timestamp);
+  if (timestamp2) {
+    const ts = Date.parse(timestamp2);
     if (!Number.isNaN(ts)) tsMs = ts;
   }
   const inWindow = sinceMs === void 0 || tsMs !== null && tsMs >= sinceMs;
@@ -5151,8 +5152,8 @@ function ingestLine(agg, raw, state, sinceMs) {
     state.sawResponse = true;
   }
   if (!inWindow) return;
-  if (tsMs !== null && timestamp) {
-    agg.activeDays.add(timestamp.slice(0, 10));
+  if (tsMs !== null && timestamp2) {
+    agg.activeDays.add(timestamp2.slice(0, 10));
     agg.firstTs = agg.firstTs === null ? tsMs : Math.min(agg.firstTs, tsMs);
     agg.lastTs = agg.lastTs === null ? tsMs : Math.max(agg.lastTs, tsMs);
   }
@@ -5440,11 +5441,11 @@ function ingestWithRetry(agg, file, opts) {
   }
 }
 function ingestFile2(agg, file, opts) {
-  const readFile2 = opts.readFileImpl ?? readFileSync6;
+  const readFile4 = opts.readFileImpl ?? readFileSync6;
   let text;
   if (file.endsWith(".zst")) {
     if (zstdDecompress === null) throw readError("zstd-unsupported");
-    const raw = readFile2(file);
+    const raw = readFile4(file);
     try {
       text = zstdDecompress(
         Buffer.isBuffer(raw) ? raw : Buffer.from(raw)
@@ -5453,7 +5454,7 @@ function ingestFile2(agg, file, opts) {
       throw readError("zstd-corrupt");
     }
   } else {
-    text = readFile2(file).toString("utf8");
+    text = readFile4(file).toString("utf8");
   }
   const records = [];
   let nonEmptyLines = 0;
@@ -5556,6 +5557,817 @@ var codexAdapter = {
   }
 };
 
+// src/harness/cursor/cache.ts
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import path5 from "node:path";
+
+// src/harness/cursor/account.ts
+import { createHash } from "node:crypto";
+
+// src/harness/cursor/evidence.ts
+function timestamp(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? /^\d+$/.test(value) ? Number(value) : Date.parse(value) : NaN;
+  return Number.isFinite(n) && n > 0 && n < 864e13 ? n : null;
+}
+function count(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function tokenEvidence(value) {
+  const raw = asObj(value) ?? {};
+  const direct = asObj(raw.tokenCount);
+  const usage = asObj(raw.usage);
+  for (const [obj, fields] of [
+    [
+      direct,
+      ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"]
+    ],
+    [
+      usage,
+      [
+        "input_tokens",
+        "output_tokens",
+        "cache_read_input_tokens",
+        "cache_creation_input_tokens"
+      ]
+    ]
+  ]) {
+    for (const field of fields)
+      if (obj?.[field] != null && count(obj[field]) === void 0)
+        throw new Error("Invalid Cursor token evidence");
+  }
+  const out = {};
+  out.input = count(direct?.inputTokens) ?? count(usage?.input_tokens);
+  out.output = count(direct?.outputTokens) ?? count(usage?.output_tokens);
+  out.cacheRead = count(direct?.cacheReadTokens) ?? count(usage?.cache_read_input_tokens);
+  out.cacheWrite = count(direct?.cacheWriteTokens) ?? count(usage?.cache_creation_input_tokens);
+  if (out.input !== void 0) out.inputSource = "reported";
+  if (out.output !== void 0) out.outputSource = "reported";
+  if (out.input === void 0) {
+    const context = count(asObj(raw.contextWindowStatusAtCreation)?.tokensUsed);
+    if (context !== void 0) {
+      out.input = context;
+      out.inputSource = "context";
+    } else if (typeof raw.promptDryRunInfo === "string") {
+      try {
+        const dry = asObj(JSON.parse(raw.promptDryRunInfo));
+        const estimate = count(asObj(dry?.fullConversationTokenCount)?.numTokens) ?? count(asObj(dry?.userMessageTokenCount)?.numTokens);
+        if (estimate !== void 0) {
+          out.input = estimate;
+          out.inputSource = "dry-run";
+        }
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+var directTimes = /* @__PURE__ */ new Set([
+  "composer-created-at",
+  "composer-timing",
+  "store-turn-timing"
+]);
+function messageTimes(session, api = []) {
+  const times = session.messages.map(
+    (m) => directTimes.has(m.timestampSource ?? "") ? timestamp(m.timestamp) : null
+  );
+  const anchors = [];
+  for (const [index, time] of times.entries())
+    if (time !== null) anchors.push({ index, time });
+  const start = session.createdAtSource !== "epoch-unknown" ? timestamp(session.timestamp) : null;
+  const end = session.lastUpdatedAtSource !== "epoch-unknown" ? timestamp(session.metadata?.lastModified) : null;
+  const apiTimes = api.filter((e) => e.session === session.id).map((e) => e.tsMs);
+  if (!anchors.some((a) => a.index === 0)) {
+    const time = start ?? (apiTimes.length ? Math.min(...apiTimes) : null);
+    if (time !== null) anchors.unshift({ index: -1, time });
+  }
+  const last = session.messages.length;
+  if (last && !anchors.some((a) => a.index === last - 1)) {
+    const time = end ?? (apiTimes.length ? Math.max(...apiTimes) : null);
+    if (time !== null) anchors.push({ index: last, time });
+  }
+  for (let i = 0; i < times.length; i++) {
+    if (times[i] !== null) continue;
+    const before = anchors.filter((a) => a.index < i).at(-1);
+    const after = anchors.find((a) => a.index > i);
+    if (before && after && after.time >= before.time)
+      times[i] = Math.round(
+        before.time + (after.time - before.time) * (i - before.index) / (after.index - before.index)
+      );
+    else times[i] = before?.time ?? after?.time ?? null;
+  }
+  return times;
+}
+function localContributions(local, api = []) {
+  const { session, tokens } = local;
+  const times = messageTimes(session, api);
+  const out = [];
+  let pending;
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, message] of session.messages.entries()) {
+    if (message.id && seen.has(message.id)) continue;
+    if (message.id) seen.add(message.id);
+    if (message.role === "user") {
+      pending = message;
+      continue;
+    }
+    const own = tokens.get(message.id ?? "") ?? {};
+    const user = tokens.get(pending?.id ?? "") ?? {};
+    const input = own.input !== void 0 ? own : user;
+    const buckets = {
+      ...own,
+      input: input.input ?? (pending ? Math.ceil(pending.content.length / 4) : void 0),
+      inputSource: input.inputSource ?? (pending ? "text" : void 0),
+      output: own.output ?? Math.ceil(message.content.length / 4),
+      outputSource: own.outputSource ?? "text"
+    };
+    pending = void 0;
+    const tsMs = times[i];
+    if (tsMs === null) continue;
+    out.push({
+      session: session.id,
+      ...message.id ? { id: message.id } : {},
+      ...message.identityOrigin === "composer-native" && message.id ? { nativeId: message.id } : {},
+      tsMs,
+      model: asStr(message.model) ?? "unknown",
+      buckets,
+      source: "local",
+      ...message.isSidechain ? { sidechain: true } : {}
+    });
+  }
+  return out;
+}
+function reconcile(local, api) {
+  const grain = (c) => `${c.session}\0${new Date(c.tsMs).toISOString().slice(0, 10)}`;
+  const reported = api.filter(
+    (row) => Object.values(row.buckets).some((value) => typeof value === "number")
+  );
+  const grains = new Set(reported.map(grain));
+  return [...local.filter((c) => !grains.has(grain(c))), ...reported];
+}
+
+// src/harness/cursor/local.ts
+import { stat as stat4 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import path4 from "node:path";
+function dataPath(env = process.env, home = homedir8(), platform4 = process.platform) {
+  if (env.CURSOR_DATA_PATH) return path4.resolve(env.CURSOR_DATA_PATH);
+  const base = platform4 === "darwin" ? path4.join(home, "Library", "Application Support") : platform4 === "win32" ? env.APPDATA || path4.join(home, "AppData", "Roaming") : env.XDG_CONFIG_HOME || path4.join(home, ".config");
+  return path4.join(base, "Cursor", "User", "workspaceStorage");
+}
+var storeRoot = () => process.env.CURSOR_STORE_ROOT || path4.join(homedir8(), ".cursor");
+var globalDb = (root) => path4.join(path4.dirname(root), "globalStorage", "state.vscdb");
+async function exists3(file) {
+  try {
+    await stat4(file);
+    return true;
+  } catch (error) {
+    return error.code !== "ENOENT";
+  }
+}
+async function hasLocalSource(root = dataPath()) {
+  return (await Promise.all(
+    [
+      root,
+      globalDb(root),
+      path4.join(storeRoot(), "projects"),
+      path4.join(storeRoot(), "chats"),
+      path4.join(storeRoot(), "acp-sessions")
+    ].map(exists3)
+  )).some(Boolean);
+}
+async function readTokenEvidence(root, session) {
+  const out = /* @__PURE__ */ new Map();
+  if (!session.messages.some((m) => m.identityOrigin?.startsWith("composer")))
+    return out;
+  const file = globalDb(root);
+  if (!await exists3(file)) return out;
+  const { DatabaseSync } = await import("node:sqlite");
+  const db = new DatabaseSync(file, { readOnly: true });
+  try {
+    db.exec("BEGIN");
+    const table = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'cursorDiskKV'"
+    ).get();
+    if (!table) return out;
+    const query = db.prepare(`SELECT json_object(
+			'tokenCount', json_extract(value, '$.tokenCount'),
+			'usage', json_extract(value, '$.usage'),
+			'contextWindowStatusAtCreation', json_extract(value, '$.contextWindowStatusAtCreation'),
+			'promptDryRunInfo', json_extract(value, '$.promptDryRunInfo')) AS evidence
+			FROM cursorDiskKV WHERE key = ?`);
+    for (const message of session.messages) {
+      if (!message.id || message.identityOrigin !== "composer-native") continue;
+      const row = query.get(`bubbleId:${session.id}:${message.id}`);
+      if (typeof row?.evidence === "string")
+        out.set(message.id, tokenEvidence(JSON.parse(row.evidence)));
+    }
+    const header = db.prepare(
+      "SELECT json_extract(value, '$.conversation') AS conversation FROM cursorDiskKV WHERE key = ?"
+    ).get(`composerData:${session.id}`);
+    if (typeof header?.conversation === "string") {
+      const conversation = JSON.parse(header.conversation);
+      if (Array.isArray(conversation))
+        for (const [index, raw] of conversation.entries()) {
+          const obj = asObj(raw);
+          const id = asStr(obj?.bubbleId) ?? asStr(obj?.id) ?? `msg:${index}`;
+          if (!out.has(id)) out.set(id, tokenEvidence(raw));
+        }
+    }
+    return out;
+  } finally {
+    db.close();
+  }
+}
+async function sourceStamp(root) {
+  const values = await Promise.all(
+    [globalDb(root), `${globalDb(root)}-wal`].map(async (file) => {
+      try {
+        const info = await stat4(file);
+        return `${info.size}:${info.mtimeMs}`;
+      } catch {
+        return "unavailable";
+      }
+    })
+  );
+  return values.join("/");
+}
+async function readLocal(root = dataPath(), onProgress) {
+  const stats = emptyScanStats();
+  const out = { sessions: [], complete: true, stats };
+  if (!await hasLocalSource(root)) return out;
+  const before = await sourceStamp(root);
+  let context;
+  try {
+    const reader = await import("cursor-history");
+    const options = {
+      dataPath: root,
+      sqliteDriver: "node:sqlite",
+      onDiagnostic: () => {
+        out.complete = false;
+      },
+      signal: AbortSignal.timeout(12e4)
+    };
+    context = reader.createSessionReadContext(options);
+    const config = { ...options, readContext: context };
+    let offset = 0;
+    while (true) {
+      const page = await reader.listSessionSummaries({
+        ...config,
+        offset,
+        limit: 100
+      });
+      for (const summary of page.data) {
+        stats.filesFound++;
+        if (summary.resolutionState === "ambiguous") {
+          out.complete = false;
+        }
+        try {
+          const session = await reader.getSession(summary.id, config);
+          if (session.resolutionState !== "complete" || session.messages.some((m) => m.metadata?.corrupted))
+            out.complete = false;
+          const tokens = await readTokenEvidence(root, session);
+          out.sessions.push({ session, tokens });
+          stats.filesRead++;
+          onProgress?.(stats.filesRead);
+        } catch {
+          out.complete = false;
+          stats.filesUnreadable++;
+        } finally {
+          context.releaseSession(summary.id);
+        }
+      }
+      if (!page.pagination.hasMore) break;
+      if (page.data.length === 0 || offset >= 1e5) {
+        out.complete = false;
+        break;
+      }
+      offset += page.data.length;
+    }
+  } catch {
+    out.complete = false;
+    stats.filesUnreadable++;
+  } finally {
+    try {
+      await context?.dispose();
+    } catch {
+      out.complete = false;
+    }
+  }
+  if (before !== await sourceStamp(root)) out.complete = false;
+  return out;
+}
+
+// src/harness/cursor/account.ts
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+async function existingAccount(root) {
+  let db;
+  try {
+    const { DatabaseSync } = await import("node:sqlite");
+    db = new DatabaseSync(globalDb(root), { readOnly: true });
+    const row = db.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/accessToken");
+    if (typeof row?.value !== "string") return null;
+    const token = row.value.trim().replace(/^"|"$/g, "");
+    const claims = asObj(
+      JSON.parse(
+        Buffer.from(token.split(".")[1] ?? "", "base64url").toString("utf8")
+      )
+    );
+    const subject = asStr(claims?.sub);
+    if (!subject || claims?.type === "api_key_token" || !/^[\w|:-]+$/.test(subject) || !/^[A-Za-z0-9_.-]+$/.test(token))
+      return null;
+    const user = subject.split("|").at(-1);
+    if (!user) return null;
+    return { scope: digest(subject), cookie: `${user}%3A%3A${token}` };
+  } catch {
+    return null;
+  } finally {
+    db?.close();
+  }
+}
+function apiContribution(value) {
+  const raw = asObj(value);
+  if (!raw) throw new Error("Invalid Cursor event");
+  const session = asStr(raw.conversationId);
+  if (!session || raw.cloudAgentId || session.startsWith("bc-")) return null;
+  const tsMs = timestamp(raw.timestamp);
+  const usage = raw.tokenUsage == null ? {} : asObj(raw.tokenUsage);
+  if (tsMs === null || !usage) throw new Error("Invalid Cursor event");
+  const buckets = {};
+  for (const [key2, field] of [
+    ["input", "inputTokens"],
+    ["output", "outputTokens"],
+    ["cacheRead", "cacheReadTokens"],
+    ["cacheWrite", "cacheWriteTokens"]
+  ]) {
+    if (usage[field] === void 0 || usage[field] === null) continue;
+    const value2 = count(usage[field]);
+    if (value2 === void 0) throw new Error("Invalid Cursor token bucket");
+    buckets[key2] = value2;
+  }
+  const id = asStr(raw.id) ?? asStr(raw.eventId);
+  return {
+    session,
+    ...id ? { id } : {},
+    tsMs,
+    model: asStr(raw.model) ?? "unknown",
+    buckets,
+    source: "api"
+  };
+}
+async function fetchWindow(account, from, to, fetchImpl = fetch) {
+  const out = [];
+  const pages = /* @__PURE__ */ new Set();
+  const eventIds = /* @__PURE__ */ new Set();
+  let total;
+  let retrieved = 0;
+  const pageSize = 100;
+  for (let page = 1; page <= 100; page++) {
+    const response = await fetchImpl(
+      "https://cursor.com/api/dashboard/get-filtered-usage-events",
+      {
+        method: "POST",
+        redirect: "error",
+        signal: AbortSignal.timeout(15e3),
+        headers: {
+          "Content-Type": "application/json",
+          Origin: "https://cursor.com",
+          Cookie: `WorkosCursorSessionToken=${account.cookie}`
+        },
+        body: JSON.stringify({
+          startDate: from,
+          endDate: to - 1,
+          page,
+          pageSize
+        })
+      }
+    );
+    if (!response.ok) throw new Error("Cursor usage unavailable");
+    const payload = asObj(await response.json());
+    const events = payload?.usageEventsDisplay;
+    if (!Array.isArray(events) || events.length > pageSize)
+      throw new Error("Invalid Cursor page");
+    if (payload?.totalUsageEventsCount !== void 0) {
+      const reported = count(payload.totalUsageEventsCount);
+      if (reported === void 0 || !Number.isInteger(reported) || total !== void 0 && total !== reported)
+        throw new Error("Cursor page count changed");
+      total = reported;
+    }
+    if (events.length) {
+      const key2 = digest(JSON.stringify(events));
+      if (pages.has(key2)) throw new Error("Repeated Cursor page");
+      pages.add(key2);
+    }
+    retrieved += events.length;
+    for (const value of events) {
+      const event = apiContribution(value);
+      if (!event) continue;
+      if (event.tsMs < from || event.tsMs >= to)
+        throw new Error("Cursor event outside query");
+      if (event.id && eventIds.has(event.id)) continue;
+      if (event.id) eventIds.add(event.id);
+      out.push(event);
+    }
+    if (total !== void 0 && retrieved > total)
+      throw new Error("Invalid Cursor page count");
+    if (total !== void 0 && retrieved === total || total === void 0 && events.length < pageSize)
+      return out;
+    if (!events.length) throw new Error("Incomplete Cursor pages");
+  }
+  throw new Error("Cursor page limit");
+}
+
+// src/harness/cursor/cache.ts
+var emptyCache = () => ({
+  version: 1,
+  account: null,
+  windows: {},
+  local: [],
+  sessions: []
+});
+var cacheFile = (root, store) => path5.join(
+  homedir9(),
+  ".config",
+  "aistack",
+  "cursor",
+  `${digest(`${root}\0${store}`)}.json`
+);
+function validContribution(value) {
+  const row = asObj(value);
+  const buckets = asObj(row?.buckets);
+  return !!row && typeof row.session === "string" && typeof row.model === "string" && timestamp(row.tsMs) !== null && (row.id === void 0 || typeof row.id === "string") && (row.source === "api" || row.source === "local") && !!buckets && ["input", "output", "cacheRead", "cacheWrite"].every(
+    (k) => buckets[k] === void 0 || count(buckets[k]) !== void 0
+  );
+}
+async function loadCache(file) {
+  try {
+    const raw = asObj(JSON.parse(await readFile(file, "utf8")));
+    const windows = asObj(raw?.windows);
+    if (raw?.version !== 1 || !(raw.account === null || typeof raw.account === "string") || !Array.isArray(raw.sessions) || !raw.sessions.every((id) => typeof id === "string") || !Array.isArray(raw.local) || !raw.local.every(validContribution) || !windows)
+      throw new Error("Invalid cache");
+    for (const value of Object.values(windows)) {
+      const w = asObj(value);
+      if (!w || timestamp(w.from) === null || timestamp(w.to) === null || timestamp(w.fetchedAt) === null || !Array.isArray(w.events) || !w.events.every(validContribution))
+        throw new Error("Invalid window");
+    }
+    return { value: raw, complete: true };
+  } catch (error) {
+    return {
+      value: emptyCache(),
+      complete: error.code === "ENOENT"
+    };
+  }
+}
+async function saveCache(file, value) {
+  await mkdir(path5.dirname(file), { recursive: true, mode: 448 });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, JSON.stringify(value), { mode: 384 });
+  await rename(temporary, file);
+}
+var WINDOW_MS = 30 * 864e5;
+async function refreshAccount(input) {
+  const { cache, account, now, sessionIds } = input;
+  if (!account) return cache;
+  const changed = cache.account !== account.scope;
+  const next = {
+    ...cache,
+    account: account.scope,
+    windows: changed ? {} : { ...cache.windows }
+  };
+  for (let from = Math.floor(input.sinceMs / WINDOW_MS) * WINDOW_MS; from <= now; from += WINDOW_MS) {
+    const to = Math.min(from + WINDOW_MS, now + 1);
+    const key2 = String(from);
+    const previous = next.windows[key2];
+    if (previous && now - previous.fetchedAt < 3e5) continue;
+    try {
+      const events = (await fetchWindow(account, from, to, input.fetchImpl)).filter((e) => sessionIds.has(e.session));
+      if (previous?.events.length && events.length === 0 && to <= now) continue;
+      next.windows[key2] = { from, to, fetchedAt: now, events };
+    } catch {
+      break;
+    }
+  }
+  return next;
+}
+function cachedEvents(cache, sessionIds) {
+  const seen = /* @__PURE__ */ new Set();
+  return Object.values(cache.windows).sort((a, b) => b.fetchedAt - a.fetchedAt || b.from - a.from).flatMap((w) => w.events).filter((e) => {
+    if (!sessionIds.has(e.session) || e.id && seen.has(e.id)) return false;
+    if (e.id) seen.add(e.id);
+    return true;
+  });
+}
+
+// src/harness/cursor/scan.ts
+import path7 from "node:path";
+
+// src/harness/cursor/workflow.ts
+import path6 from "node:path";
+var TOOLS = {
+  read_file: "Read",
+  read_file_v2: "Read",
+  list_dir: "Glob",
+  glob_file_search: "Glob",
+  grep: "Grep",
+  search: "Grep",
+  codebase_search: "Grep",
+  edit_file: "Edit",
+  edit_file_v2: "Edit",
+  search_replace: "Edit",
+  write: "Write",
+  write_file: "Write",
+  delete_file: "Edit",
+  run_terminal_cmd: "Bash",
+  run_terminal_command: "Bash",
+  execute_command: "Bash",
+  web_search: "WebSearch",
+  web_fetch: "WebFetch",
+  ask_question: "ask_question",
+  todo_write: "TodoWrite",
+  task: "Task",
+  skill: "Skill"
+};
+var CURSOR_BUILTIN_TOOLS = new Set(
+  Object.keys(TOOLS)
+);
+function projectHistory(options) {
+  const { locals, api, usage, aggregate, workflow, sinceMs, now } = options;
+  const nativeOwners = /* @__PURE__ */ new Map();
+  for (const { session } of locals)
+    for (const message of session.messages)
+      if (message.id && message.identityOrigin === "composer-native" && !message.isSidechain && !nativeOwners.has(message.id))
+        nativeOwners.set(message.id, session.id);
+  const seenMessages = /* @__PURE__ */ new Set();
+  const seenTools = /* @__PURE__ */ new Set();
+  const configuredServers = /* @__PURE__ */ new Map();
+  const scopes = /* @__PURE__ */ new Map();
+  const inWindow = (t) => t !== null && t >= sinceMs && t <= now;
+  for (const { session } of locals) {
+    const projectWorkspace = session.canonicalWorkspacePath && path6.isAbsolute(session.canonicalWorkspacePath) ? session.canonicalWorkspacePath : void 0;
+    const times = messageTimes(session, api);
+    const scopeOf = (message) => {
+      const parent = message.parentMessageId && nativeOwners.get(message.parentMessageId);
+      return message.isSidechain ? {
+        session: `${session.id}:sidechain`,
+        sidechain: true,
+        ...parent ? { parentSession: parent } : {}
+      } : { session: session.id };
+    };
+    for (const [index, message] of session.messages.entries()) {
+      const identity = message.identityOrigin === "composer-native" && message.id ? `native:${message.id}` : `${session.id}:${message.id ?? index}`;
+      if (seenMessages.has(identity)) continue;
+      seenMessages.add(identity);
+      const tsMs = times[index];
+      const scope = scopeOf(message);
+      if (message.id) scopes.set(`${session.id}:${message.id}`, scope);
+      if (tsMs !== null && !inWindow(tsMs)) continue;
+      const common = { ...scope, projectWorkspace, tsMs: tsMs ?? 0 };
+      if (message.role === "user") {
+        if (inWindow(tsMs))
+          workflow?.ingest({
+            ...common,
+            type: "response",
+            responseId: `anchor:${message.id ?? index}`
+          });
+        continue;
+      }
+      let questionBack = false;
+      for (const [toolIndex, call] of (message.toolCalls ?? []).entries()) {
+        const id = call.identityOrigin === "source-native" && call.id ? `native:${call.id}` : `${identity}:${call.id ?? toolIndex}`;
+        if (seenTools.has(id)) continue;
+        seenTools.add(id);
+        bump(aggregate.toolCalls, call.name);
+        const tool = TOOLS[call.name] ?? call.name;
+        const arg = asStr(call.params?.command) ?? asStr(call.params?.cmd) ?? asStr(call.params?.skill) ?? asStr(call.params?.subagent_type) ?? "";
+        if (tool === "WebSearch") aggregate.webSearchRequests++;
+        if (tool === "WebFetch") aggregate.webFetchRequests++;
+        if (tool === "Skill" && arg) bump(aggregate.skillCalls, arg);
+        if (tool === "Task") bump(aggregate.subagentCalls, arg || "(unknown)");
+        const mcp = /^mcp__(.+?)__(.+)$/.exec(call.name);
+        let server = mcp?.[1];
+        if (!server && call.name.startsWith("mcp_")) {
+          const directory = projectWorkspace ?? process.cwd();
+          let names = configuredServers.get(directory);
+          if (!names) {
+            names = detectMcpServers(directory).filter((r) => r.group === "cursor").map((r) => r.name).sort((a, b) => b.length - a.length);
+            configuredServers.set(directory, names);
+          }
+          server = names.find((name) => call.name.startsWith(`mcp_${name}_`));
+        }
+        if (server) {
+          bump(aggregate.mcpServerCalls, server);
+          bump(aggregate.mcpToolCalls, call.name);
+        }
+        questionBack ||= tool === "ask_question";
+        if (inWindow(tsMs))
+          workflow?.ingest({
+            ...common,
+            type: "event",
+            tool,
+            arg,
+            batchId: id
+          });
+      }
+      if (inWindow(tsMs))
+        workflow?.ingest({
+          ...common,
+          type: "turn",
+          turnId: message.id ?? `assistant:${index}`,
+          questionBack
+        });
+    }
+  }
+  if (!workflow) return;
+  const projects = new Map(
+    locals.map(({ session }) => [session.id, session.canonicalWorkspacePath])
+  );
+  for (const [index, row] of usage.entries()) {
+    if (!inWindow(row.tsMs)) continue;
+    const project = projects.get(row.session);
+    const scope = row.id && row.source === "local" ? scopes.get(`${row.session}:${row.id}`) : void 0;
+    workflow.ingest({
+      ...scope ?? {
+        session: row.sidechain ? `${row.session}:sidechain` : row.session,
+        sidechain: row.sidechain
+      },
+      ...project && path6.isAbsolute(project) ? { projectWorkspace: project } : {},
+      type: "response",
+      tsMs: row.tsMs,
+      responseId: `${row.source}:${row.id ?? index}`,
+      model: normalizeModel(row.model),
+      routingTokens: (row.buckets.input ?? 0) + (row.buckets.output ?? 0) + (row.buckets.cacheRead ?? 0) + (row.buckets.cacheWrite ?? 0)
+    });
+  }
+}
+
+// src/harness/cursor/scan.ts
+async function scan3(options) {
+  const root = options.root ?? dataPath();
+  const now = options.now ?? Date.now();
+  const file = options.cachePath ?? cacheFile(root, storeRoot());
+  const local = await (options.readLocalImpl ?? readLocal)(
+    root,
+    options.onProgress
+  );
+  const loaded = await loadCache(file);
+  let complete = local.complete && loaded.complete;
+  const ids = new Set(local.sessions.map((s) => s.session.id));
+  if ([
+    ...loaded.value.local,
+    ...Object.values(loaded.value.windows).flatMap((w) => w.events)
+  ].some((row) => row.tsMs >= options.sinceMs && !ids.has(row.session)))
+    complete = false;
+  const account = await (options.accountImpl ?? existingAccount)(root);
+  const cache = await refreshAccount({
+    cache: loaded.value,
+    account,
+    sinceMs: options.sinceMs,
+    now,
+    sessionIds: ids,
+    fetchImpl: options.fetchImpl
+  });
+  const api = cachedEvents(cache, ids);
+  const native = /* @__PURE__ */ new Set();
+  const contributions = local.sessions.flatMap((s) => localContributions(s, api)).filter((row) => {
+    if (!row.nativeId) return true;
+    if (native.has(row.nativeId)) return false;
+    native.add(row.nativeId);
+    return true;
+  });
+  const dated = new Set(contributions.map((row) => row.session));
+  if (loaded.value.local.some(
+    (row) => row.tsMs >= options.sinceMs && !dated.has(row.session)
+  ))
+    complete = false;
+  const previousDates = /* @__PURE__ */ new Map();
+  for (const row of [
+    ...loaded.value.local,
+    ...cachedEvents(loaded.value, ids)
+  ]) {
+    const dates = previousDates.get(row.session) ?? /* @__PURE__ */ new Set();
+    dates.add(utcDateOf(row.tsMs));
+    previousDates.set(row.session, dates);
+  }
+  if (complete) {
+    cache.local = contributions;
+    cache.sessions = [...ids].sort();
+    try {
+      await saveCache(file, cache);
+    } catch {
+      complete = false;
+    }
+  }
+  const aggregate = createAggregate();
+  const workflowLocal = createWorkflowLocalSources();
+  const workflow = createHarnessWorkflowReducer("cursor", workflowLocal);
+  const sessions = new Map(local.sessions.map((s) => [s.session.id, s]));
+  const sessionDates = previousDates;
+  for (const { session } of local.sessions) {
+    for (const message of session.messages)
+      if (message.model) {
+        const model = normalizeModel(message.model);
+        if (!aggregate.byModel.has(model))
+          aggregate.byModel.set(model, emptyUsage());
+      }
+    const project = session.canonicalWorkspacePath;
+    if (project && path7.isAbsolute(project)) aggregate.projectDirs.add(project);
+    if (session.metadata?.cursorVersion)
+      aggregate.ccVersions.add(session.metadata.cursorVersion);
+    const times = messageTimes(session, api).filter(
+      (t) => t !== null && t >= options.sinceMs && t <= now
+    );
+    if (times.length) {
+      aggregate.sessions.add(session.id);
+      noteSessionStart(aggregate, session.id, Math.min(...times));
+    }
+  }
+  const usage = reconcile(contributions, api);
+  projectHistory({
+    locals: local.sessions,
+    api,
+    usage,
+    aggregate,
+    workflow: options.publishWorkflow === false ? void 0 : workflow,
+    sinceMs: options.sinceMs,
+    now
+  });
+  for (const contribution of usage) {
+    const { tsMs, buckets, session, sidechain } = contribution;
+    const dates = sessionDates.get(session) ?? /* @__PURE__ */ new Set();
+    dates.add(utcDateOf(tsMs));
+    sessionDates.set(session, dates);
+    if (tsMs < options.sinceMs || tsMs > now) continue;
+    const model = normalizeModel(contribution.model);
+    const counts2 = {
+      input: buckets.input ?? 0,
+      output: buckets.output ?? 0,
+      cacheRead: buckets.cacheRead ?? 0,
+      cacheWrite5m: 0,
+      cacheWrite1h: 0,
+      cacheWriteUnsplit: buckets.cacheWrite ?? 0
+    };
+    addModelUsage(
+      aggregate,
+      model,
+      counts2,
+      apiEquivalentCost(model, counts2, tsMs),
+      1,
+      { tsMs, sidechain }
+    );
+    aggregate.records++;
+    aggregate.assistantRecords++;
+    aggregate.distinctResponses++;
+    aggregate.sessions.add(session);
+    aggregate.activeDays.add(utcDateOf(tsMs));
+    aggregate.firstTs = Math.min(aggregate.firstTs ?? tsMs, tsMs);
+    aggregate.lastTs = Math.max(aggregate.lastTs ?? tsMs, tsMs);
+    if (sidechain) aggregate.sidechainTokens += countsTotal(counts2);
+    else aggregate.mainTokens += countsTotal(counts2);
+    noteSessionStart(aggregate, session, tsMs);
+    const project = sessions.get(session)?.session.canonicalWorkspacePath;
+    if (project && path7.isAbsolute(project))
+      noteProjectDay(aggregate, project, tsMs);
+  }
+  aggregate.files = local.stats.filesRead;
+  return {
+    aggregate,
+    stats: local.stats,
+    workflow: workflow.finish(),
+    workflowLocal,
+    scanComplete: complete,
+    sessionDates
+  };
+}
+
+// src/harness/cursor/adapter.ts
+var CURSOR_HARNESS_NAME = "cursor";
+var cursorAdapter = {
+  name: CURSOR_HARNESS_NAME,
+  builtinTools: CURSOR_BUILTIN_TOOLS,
+  async detect(options) {
+    const roots = options.roots ?? [dataPath()];
+    for (const root of roots) {
+      const held = await loadCache(cacheFile(root, storeRoot()));
+      if (!held.complete || [
+        ...held.value.local,
+        ...cachedEvents(held.value, new Set(held.value.sessions))
+      ].some((row) => row.tsMs >= options.sinceMs))
+        return true;
+      const local = await readLocal(root);
+      if (!local.complete || local.sessions.some(
+        ({ session }) => messageTimes(session).some((t) => t !== null && t >= options.sinceMs)
+      ))
+        return true;
+      if (local.sessions.some(
+        ({ session }) => session.messages.length > 0 && messageTimes(session).every((t) => t === null)
+      ))
+        return true;
+    }
+    return false;
+  },
+  scan: scan3
+};
+
 // src/harness/grok/analyzer.ts
 function createAggregate4() {
   const workflowLocal = createWorkflowLocalSources();
@@ -5572,41 +6384,41 @@ var createGrokEventState = (parentSession) => ({
 var bump3 = (map, key2) => {
   map.set(key2, (map.get(key2) ?? 0) + 1);
 };
-var toolMetadata = (update) => {
-  const meta = asObj(update._meta);
+var toolMetadata = (update2) => {
+  const meta = asObj(update2._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 update2 = 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 (!update2 || !session || tsMs === null) return;
+  const kind = asStr(update2.sessionUpdate);
   if (kind === "tool_call") {
-    const id = asStr(update.toolCallId);
-    const metadata = toolMetadata(update);
-    const name = asName(metadata?.name ?? update.toolName);
+    const id = asStr(update2.toolCallId);
+    const metadata = toolMetadata(update2);
+    const name = asName(metadata?.name ?? update2.toolName);
     if (!id || !name || state.tools.has(id)) return;
-    const raw = asObj(update.input);
+    const raw = asObj(update2.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;
+    const id = asStr(update2.toolCallId);
+    if (!id || asStr(update2.status) !== "completed") return;
     completeTool(agg, state, id, session, projectDir, tsMs);
     return;
   }
   if (kind !== "turn_completed") return;
-  const usage = asObj(update.usage);
+  const usage = asObj(update2.usage);
   if (!usage) return;
-  const prompt = asStr(update.prompt_id) ?? `turn:${tsMs}`;
+  const prompt = asStr(update2.prompt_id) ?? `turn:${tsMs}`;
   for (const [model, raw] of Object.entries(asObj(usage.modelUsage) ?? {})) {
     const row = asObj(raw);
     agg.workflow.ingest({
@@ -5620,7 +6432,7 @@ function ingestUpdate(agg, state, value, projectDir, sinceMs) {
       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 } : {}
+      ...asNum(row?.apiDurationMs) > 0 ? { durationSec: asNum(row?.apiDurationMs) / 1e3 } : asNum(update2.elapsed_ms) > 0 ? { durationSec: asNum(update2.elapsed_ms) / 1e3 } : {}
     });
   }
   agg.workflow.ingest({
@@ -5630,7 +6442,7 @@ function ingestUpdate(agg, state, value, projectDir, sinceMs) {
     parentSession: state.parentSession,
     tsMs,
     turnId: prompt,
-    questionBack: asStr(update.stop_reason) === "question"
+    questionBack: asStr(update2.stop_reason) === "question"
   });
 }
 function completeTool(agg, state, id, session, projectDir, tsMs) {
@@ -5750,10 +6562,10 @@ function sidecarContributions(value, projectDir) {
 function terminalContribution(value, projectDir) {
   const root = asObj(value);
   const params = root && asObj(root.params);
-  const update = params && asObj(params.update);
+  const update2 = params && asObj(params.update);
   const meta = params && asObj(params._meta);
-  if (!update || asStr(update.sessionUpdate) !== "turn_completed") return null;
-  const usage = asObj(update.usage);
+  if (!update2 || asStr(update2.sessionUpdate) !== "turn_completed") return null;
+  const usage = asObj(update2.usage);
   const sessionId = params && asStr(params.sessionId);
   const tsMs = timestampMs(meta?.agentTimestampMs ?? root?.timestamp);
   if (!usage || !sessionId || tsMs === null) return null;
@@ -5766,7 +6578,7 @@ function terminalContribution(value, projectDir) {
     sessionId,
     projectDir,
     tsMs,
-    ...asNum(update.elapsed_ms) > 0 ? { durationMs: asNum(update.elapsed_ms) } : {},
+    ...asNum(update2.elapsed_ms) > 0 ? { durationMs: asNum(update2.elapsed_ms) } : {},
     models
   };
 }
@@ -5798,15 +6610,129 @@ function ingestContribution(agg, row) {
 
 // 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 { readdir as readdir5, readFile as readFile3, stat as stat5 } from "node:fs/promises";
+import { homedir as homedir11 } from "node:os";
+import path9 from "node:path";
 import readline2 from "node:readline";
 import { parse as parseToml3 } from "smol-toml";
+
+// src/harness/grok/context.ts
+import { createHash as createHash2 } from "node:crypto";
+import { appendFile, mkdir as mkdir2, readdir as readdir4, readFile as readFile2, unlink } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import path8 from "node:path";
+var DAY_MS = 864e5;
+var hash = (value) => createHash2("sha256").update(value).digest("hex");
+function contextCall(value) {
+  const row = asObj(value);
+  if (row?.src !== "shell" || row.msg !== "shell.turn.inference_done")
+    return null;
+  const session = asStr(row.sid);
+  const ts = asStr(row.ts);
+  const ctx = asObj(row.ctx);
+  const tokens = ctx?.prompt_tokens;
+  const loop = ctx?.loop_index;
+  const tsMs = ts ? Date.parse(ts) : NaN;
+  if (!session || !Number.isFinite(tsMs) || typeof tokens !== "number" || !Number.isSafeInteger(tokens) || tokens < 0 || typeof loop !== "number" || !Number.isSafeInteger(loop) || loop < 0)
+    return null;
+  return {
+    id: hash(JSON.stringify([session, tsMs, row.pid ?? null, loop, tokens])),
+    session,
+    tsMs,
+    tokens
+  };
+}
+function contextCacheDirectory(root) {
+  return path8.join(
+    homedir10(),
+    ".config",
+    "aistack",
+    "grok-context",
+    hash(path8.resolve(root))
+  );
+}
+async function optionalRead(file) {
+  try {
+    return await readFile2(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return "";
+    throw error;
+  }
+}
+async function retainedContextCalls(root, sessions, cacheDir = contextCacheDirectory(root), now = Date.now()) {
+  const cutoff = now - 400 * DAY_MS;
+  const calls = /* @__PURE__ */ new Map();
+  let files = [];
+  try {
+    files = await readdir4(cacheDir);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  for (const file of files) {
+    if (!/^\d{4}-\d{2}-\d{2}\.jsonl$/.test(file)) continue;
+    if (Date.parse(file.slice(0, 10)) + DAY_MS < cutoff) {
+      await unlink(path8.join(cacheDir, file)).catch(
+        (error) => {
+          if (error.code !== "ENOENT") throw error;
+        }
+      );
+      continue;
+    }
+    const raw2 = await optionalRead(path8.join(cacheDir, file));
+    if (raw2 && !raw2.endsWith("\n"))
+      throw new Error("Incomplete Grok context cache");
+    for (const line of raw2.split("\n").filter(Boolean)) {
+      const call = asObj(JSON.parse(line));
+      if (!call || typeof call.id !== "string" || !/^[a-f0-9]{64}$/.test(call.id) || typeof call.session !== "string" || typeof call.tsMs !== "number" || !Number.isFinite(call.tsMs) || typeof call.tokens !== "number" || !Number.isSafeInteger(call.tokens) || call.tokens < 0)
+        throw new Error("Invalid Grok context cache");
+      if (call.tsMs >= cutoff && call.tsMs <= now)
+        calls.set(call.id, {
+          id: call.id,
+          session: call.session,
+          tsMs: call.tsMs,
+          tokens: call.tokens
+        });
+    }
+  }
+  const raw = await optionalRead(
+    path8.join(root, "..", "logs", "unified.jsonl")
+  );
+  const additions = /* @__PURE__ */ new Map();
+  for (const line of raw.slice(0, raw.lastIndexOf("\n") + 1).split("\n")) {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const call = contextCall(value);
+    if (!call || !sessions.has(call.session) || call.tsMs < cutoff || call.tsMs > now || calls.has(call.id))
+      continue;
+    calls.set(call.id, call);
+    const date = new Date(call.tsMs).toISOString().slice(0, 10);
+    const lines2 = additions.get(date) ?? [];
+    lines2.push(JSON.stringify(call));
+    additions.set(date, lines2);
+  }
+  if (additions.size) {
+    await mkdir2(cacheDir, { recursive: true, mode: 448 });
+    for (const [date, lines2] of additions) {
+      await appendFile(
+        path8.join(cacheDir, `${date}.jsonl`),
+        `${lines2.join("\n")}
+`,
+        { mode: 384 }
+      );
+    }
+  }
+  return [...calls.values()].filter((call) => sessions.has(call.session)).sort((a, b) => a.tsMs - b.tsMs || a.id.localeCompare(b.id));
+}
+
+// src/harness/grok/scan.ts
 function sessionRoots() {
   return [
-    path4.join(
-      process.env.GROK_HOME || path4.join(homedir8(), ".grok"),
+    path9.join(
+      process.env.GROK_HOME || path9.join(homedir11(), ".grok"),
       "sessions"
     )
   ];
@@ -5818,7 +6744,7 @@ async function stableRead(file, jsonl) {
   for (const delay of delays) {
     if (delay) await pause(delay);
     try {
-      const before = await stat4(file);
+      const before = await stat5(file);
       if (!before.isFile()) return { complete: false };
       if (jsonl) {
         const lines2 = [];
@@ -5834,12 +6760,12 @@ async function stableRead(file, jsonl) {
             lines2.push(null);
           }
         }
-        const after = await stat4(file);
+        const after = await stat5(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);
+        const raw = await readFile3(file, "utf8");
+        const after = await stat5(file);
         if (before.size === after.size && before.mtimeMs === after.mtimeMs)
           return { json: JSON.parse(raw), complete: true };
       }
@@ -5850,16 +6776,16 @@ async function stableRead(file, jsonl) {
 }
 async function directories(root) {
   try {
-    const workspaces = await readdir4(root, { withFileTypes: true });
+    const workspaces = await readdir5(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, {
+      const workspacePath = path9.join(root, workspace.name);
+      for (const session of await readdir5(workspacePath, {
         withFileTypes: true
       })) {
         if (session.isDirectory() && !session.isSymbolicLink())
-          out.push(path4.join(workspacePath, session.name));
+          out.push(path9.join(workspacePath, session.name));
       }
     }
     return out.sort();
@@ -5871,7 +6797,7 @@ 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"))
+      parseToml3(await readFile3(path9.join(root, "..", "config.toml"), "utf8"))
     );
     if (!parsed || asObj(parsed.endpoints)?.models_base_url) return /* @__PURE__ */ new Map();
     const models = asObj(parsed.model);
@@ -5887,13 +6813,14 @@ async function modelAliasesForRoot(root) {
     return /* @__PURE__ */ new Map();
   }
 }
-async function scan3(agg, opts = {}) {
+async function scan4(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 contextSessions = /* @__PURE__ */ new Map();
     const dirs = await directories(root);
     if (dirs === null) {
       complete = false;
@@ -5902,7 +6829,7 @@ async function scan3(agg, opts = {}) {
     for (const dir of dirs) {
       let entries;
       try {
-        entries = await readdir4(dir, { withFileTypes: true });
+        entries = await readdir5(dir, { withFileTypes: true });
       } catch {
         complete = false;
         continue;
@@ -5910,41 +6837,46 @@ async function scan3(agg, opts = {}) {
       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)])
+        ).map((e) => [e.name, path9.join(dir, e.name)])
       );
       let projectDir = dir;
-      let sessionFallback = path4.basename(dir);
+      let sessionFallback = path9.basename(dir);
       let child = false;
       let parentSession;
       const summary = files.get("summary.json");
       if (summary) {
-        const read2 = await stableRead(summary, false);
-        if (!read2.complete) {
+        const read3 = await stableRead(summary, false);
+        if (!read3.complete) {
           complete = false;
           stats.filesUnreadable++;
           continue;
         }
-        const value = asObj(read2.json);
+        const value = asObj(read3.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;
       }
+      contextSessions.set(sessionFallback, { projectDir, parentSession });
       let rows = [];
       let precedence = 0;
       const usage = files.get("usage.json");
       if (usage) {
         stats.filesFound++;
-        const read2 = await stableRead(usage, false);
-        if (!read2.complete) {
+        const read3 = await stableRead(usage, false);
+        if (!read3.complete) {
           complete = false;
           stats.filesUnreadable++;
           continue;
         }
         stats.filesRead++;
-        rows = sidecarContributions(read2.json, projectDir);
-        if (rows.length > 0) precedence = 2;
+        rows = sidecarContributions(read3.json, projectDir);
+        if (rows.length > 0) {
+          precedence = 2;
+          for (const row of rows)
+            contextSessions.set(row.sessionId, { projectDir, parentSession });
+        }
       }
       if (child) {
         rows = [];
@@ -5955,14 +6887,14 @@ async function scan3(agg, opts = {}) {
       if (updates) {
         const useTerminalUsage = rows.length === 0 && !child;
         stats.filesFound++;
-        const read2 = await stableRead(updates, true);
-        if (!read2.complete) {
+        const read3 = await stableRead(updates, true);
+        if (!read3.complete) {
           complete = false;
           stats.filesUnreadable++;
           continue;
         }
         stats.filesRead++;
-        for (const value of read2.lines ?? []) {
+        for (const value of read3.lines ?? []) {
           if (value === null) {
             agg.parseErrors++;
             continue;
@@ -5978,14 +6910,14 @@ async function scan3(agg, opts = {}) {
       const events = files.get("events.jsonl");
       if (events) {
         stats.filesFound++;
-        const read2 = await stableRead(events, true);
-        if (!read2.complete) {
+        const read3 = await stableRead(events, true);
+        if (!read3.complete) {
           complete = false;
           stats.filesUnreadable++;
           continue;
         }
         stats.filesRead++;
-        for (const value of read2.lines ?? []) {
+        for (const value of read3.lines ?? []) {
           if (value === null) agg.parseErrors++;
           else
             ingestEvent2(
@@ -6017,6 +6949,32 @@ async function scan3(agg, opts = {}) {
       }
       opts.onProgress?.(stats.filesFound);
     }
+    try {
+      const calls = await retainedContextCalls(
+        root,
+        new Set(contextSessions.keys()),
+        opts.contextCacheDir
+      );
+      for (const call of calls) {
+        if (opts.sinceMs !== void 0 && call.tsMs < opts.sinceMs) continue;
+        const source = contextSessions.get(call.session);
+        agg.workflow.ingest({
+          type: "response",
+          session: call.session,
+          projectWorkspace: source?.projectDir,
+          parentSession: source?.parentSession,
+          tsMs: call.tsMs,
+          responseId: `context:${call.id}`,
+          contextTokens: call.tokens
+        });
+        const dates = sessionDates.get(call.session) ?? /* @__PURE__ */ new Set();
+        dates.add(new Date(call.tsMs).toISOString().slice(0, 10));
+        sessionDates.set(call.session, dates);
+      }
+    } catch {
+      complete = false;
+      stats.filesUnreadable++;
+    }
   }
   for (const { rows } of candidates.values()) {
     for (const row of rows) {
@@ -6048,7 +7006,7 @@ var grokAdapter = {
   ),
   async scan(opts) {
     const aggregate = createAggregate4();
-    const result = await scan3(aggregate, opts);
+    const result = await scan4(aggregate, opts);
     return {
       aggregate,
       stats: result.stats,
@@ -6244,14 +7202,14 @@ function noteConfiguredMcpServers2(agg, state, serverNames) {
 
 // src/harness/opencode/scan.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { readdir as readdir5, stat as stat5 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import path5 from "node:path";
+import { readdir as readdir6, stat as stat6 } from "node:fs/promises";
+import { homedir as homedir12 } from "node:os";
+import path10 from "node:path";
 var OPENCODE_MIGRATION_CEILING = 20260622202450;
 function opencodeDataDirs() {
   const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg || path5.join(homedir9(), ".local", "share");
-  return [path5.join(base, "opencode")];
+  const base = xdg || path10.join(homedir12(), ".local", "share");
+  return [path10.join(base, "opencode")];
 }
 function isStoreFile(basename2) {
   return basename2 === "opencode.db" || /^opencode-[^/]+\.db$/.test(basename2);
@@ -6260,8 +7218,8 @@ async function dbFilesIn(root) {
   const override = process.env.OPENCODE_DB;
   if (override) return [override];
   try {
-    const entries = await readdir5(root, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && isStoreFile(e.name)).map((e) => path5.join(root, e.name)).sort();
+    const entries = await readdir6(root, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && isStoreFile(e.name)).map((e) => path10.join(root, e.name)).sort();
   } catch {
     return [];
   }
@@ -6281,7 +7239,7 @@ function errorClass2(e) {
   return e instanceof Error ? e.constructor.name : "unknown";
 }
 var readError2 = (reason) => Object.assign(new Error(reason), { code: reason });
-async function scan4(agg, opts = {}) {
+async function scan5(agg, opts = {}) {
   const stats = emptyScanStats();
   const open2 = await loadSqlite();
   const sinceMs = opts.sinceMs ?? 0;
@@ -6298,7 +7256,7 @@ async function scan4(agg, opts = {}) {
       } catch (e) {
         stats.filesUnreadable++;
         stats.unreadableFiles.push({
-          path: path5.basename(file),
+          path: path10.basename(file),
           reason: errorClass2(e)
         });
       }
@@ -6465,8 +7423,8 @@ function pickTs(jsonTs, columnTs) {
 }
 function opencodeConfigFile() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg || path5.join(homedir9(), ".config");
-  return path5.join(base, "opencode", "opencode.json");
+  const base = xdg || path10.join(homedir12(), ".config");
+  return path10.join(base, "opencode", "opencode.json");
 }
 function readConfiguredMcpServers2(agg, state, configFile) {
   const file = configFile ?? opencodeConfigFile();
@@ -6518,7 +7476,7 @@ async function detectOpencode(opts) {
   if (open2 === null) return false;
   for (const root of opts.roots ?? opencodeDataDirs()) {
     for (const file of await dbFilesIn(root)) {
-      if (!await exists3(file)) continue;
+      if (!await exists4(file)) continue;
       let db = null;
       try {
         db = open2(file);
@@ -6538,9 +7496,9 @@ async function detectOpencode(opts) {
   }
   return false;
 }
-async function exists3(p8) {
+async function exists4(p8) {
   try {
-    await stat5(p8);
+    await stat6(p8);
     return true;
   } catch {
     return false;
@@ -6560,7 +7518,7 @@ var opencodeAdapter = {
   },
   async scan(opts) {
     const aggregate = createAggregate5();
-    const stats = await scan4(aggregate, {
+    const stats = await scan5(aggregate, {
       sinceMs: opts.sinceMs,
       ...opts.onProgress ? { onProgress: opts.onProgress } : {}
     });
@@ -6768,17 +7726,17 @@ function readCounts2(usageRaw) {
 
 // src/harness/pi/scan.ts
 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 { readdir as readdir7, realpath as realpath3, stat as stat7 } from "node:fs/promises";
+import { homedir as homedir13 } from "node:os";
+import path11 from "node:path";
 import readline3 from "node:readline";
 var MAX_SESSION_VERSION = 3;
 function piAgentDir() {
-  return process.env.PI_CODING_AGENT_DIR || path6.join(homedir10(), ".pi", "agent");
+  return process.env.PI_CODING_AGENT_DIR || path11.join(homedir13(), ".pi", "agent");
 }
 function sessionRoots2() {
   const override = process.env.PI_CODING_AGENT_SESSION_DIR;
-  return [override || path6.join(piAgentDir(), "sessions")];
+  return [override || path11.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) {
@@ -6787,22 +7745,22 @@ function isSessionFile(basename2) {
 async function* walkSessions(dir) {
   let entries;
   try {
-    entries = await readdir6(dir, { withFileTypes: true });
+    entries = await readdir7(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
-    const full = path6.join(dir, e.name);
+    const full = path11.join(dir, e.name);
     if (e.isDirectory()) yield* walkSessions(full);
     else if (e.isFile() && isSessionFile(e.name)) yield full;
   }
 }
-async function scan5(agg, opts = {}) {
+async function scan6(agg, opts = {}) {
   const stats = emptyScanStats();
   const visited = /* @__PURE__ */ new Set();
   const fold = createFoldState();
   for (const root of opts.roots ?? sessionRoots2()) {
-    if (!await exists4(root)) continue;
+    if (!await exists5(root)) continue;
     for await (const file of walkSessions(root)) {
       stats.filesFound++;
       let resolved;
@@ -6818,7 +7776,7 @@ async function scan5(agg, opts = {}) {
       visited.add(resolved);
       if (opts.sinceMs !== void 0) {
         try {
-          const st = await stat6(file);
+          const st = await stat7(file);
           if (st.mtimeMs < opts.sinceMs) {
             stats.filesSkippedByMtime++;
             continue;
@@ -6840,7 +7798,7 @@ async function scan5(agg, opts = {}) {
           stats.filesUnreadable++;
           stats.filesRead--;
           stats.unreadableFiles.push({
-            path: path6.relative(root, file),
+            path: path11.relative(root, file),
             reason: "version-too-new"
           });
         }
@@ -6848,7 +7806,7 @@ async function scan5(agg, opts = {}) {
         stats.filesUnreadable++;
         stats.filesRead--;
         stats.unreadableFiles.push({
-          path: path6.relative(root, file),
+          path: path11.relative(root, file),
           reason: "read-error"
         });
       }
@@ -6856,9 +7814,9 @@ async function scan5(agg, opts = {}) {
   }
   return stats;
 }
-async function exists4(p8) {
+async function exists5(p8) {
   try {
-    await stat6(p8);
+    await stat7(p8);
     return true;
   } catch {
     return false;
@@ -6926,7 +7884,7 @@ var piAdapter = {
   },
   async scan(opts) {
     const aggregate = createAggregate6();
-    const stats = await scan5(aggregate, {
+    const stats = await scan6(aggregate, {
       sinceMs: opts.sinceMs,
       ...opts.onProgress ? { onProgress: opts.onProgress } : {}
     });
@@ -6944,12 +7902,14 @@ var HARNESS_ADAPTERS = [
   claudeAdapter,
   codexAdapter,
   grokAdapter,
+  cursorAdapter,
   opencodeAdapter,
   piAdapter
 ];
 function harnessLabel2(name) {
   if (name === CLAUDE_HARNESS_NAME) return "Claude Code";
   if (name === CODEX_HARNESS_NAME) return "Codex";
+  if (name === CURSOR_HARNESS_NAME) return "Cursor";
   if (name === GROK_HARNESS_NAME) return "Grok Build";
   if (name === OPENCODE_HARNESS_NAME) return "opencode";
   if (name === PI_HARNESS_NAME) return "Pi";
@@ -6984,7 +7944,7 @@ var MCP_ADD_ARGS = [
   "mcp"
 ];
 var MCP_REMOVE_ARGS = ["mcp", "remove", "--scope", "user", "aistack"];
-var SKILL_DEST = join6(homedir11(), ".claude", "skills", "aistack-sync");
+var SKILL_DEST = join6(homedir14(), ".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";
@@ -7217,9 +8177,9 @@ async function createCommand() {
 import { hostname } from "node:os";
 import * as p5 from "@clack/prompts";
 import open from "open";
-function proposedMachineName(read2 = hostname) {
+function proposedMachineName(read3 = hostname) {
   try {
-    const name = read2().trim().replace(/\.local$/i, "");
+    const name = read3().trim().replace(/\.local$/i, "");
     if (!name || name.length > 64) return void 0;
     return name;
   } catch {
@@ -7306,13 +8266,13 @@ async function loginCommand(options = {}) {
 import * as p7 from "@clack/prompts";
 
 // src/autosync/codexHook.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir15 } 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(homedir12(), ".codex");
+  return process.env.CODEX_HOME || join8(homedir15(), ".codex");
 }
 function codexHooksFile() {
   return join8(codexHome2(), "hooks.json");
@@ -7338,9 +8298,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 read2 = readHooksJson(file);
-  if ("error" in read2) return { ok: false, message: read2.error };
-  const settings = read2.settings;
+  const read3 = readHooksJson(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const settings = read3.settings;
   const hooks = settings.hooks ?? {};
   const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
   const kept = sessionStart.map((m) => ({
@@ -7360,9 +8320,9 @@ function installCodexAutoSyncHook(file = codexHooksFile()) {
 function removeCodexAutoSyncHook(file = codexHooksFile()) {
   if (!existsSync8(file))
     return { ok: true, message: "no Codex hook to remove" };
-  const read2 = readHooksJson(file);
-  if ("error" in read2) return { ok: false, message: read2.error };
-  const settings = read2.settings;
+  const read3 = readHooksJson(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const settings = read3.settings;
   const sessionStart = settings.hooks?.SessionStart;
   if (!Array.isArray(sessionStart)) {
     return { ok: true, message: "no Codex hook to remove" };
@@ -7387,18 +8347,18 @@ function removeCodexAutoSyncHook(file = codexHooksFile()) {
   return { ok: true, message: `hook removed from ${file}` };
 }
 function codexAutoSyncHookInstalled(file = codexHooksFile()) {
-  const read2 = readHooksJson(file);
-  if ("error" in read2) return false;
-  const sessionStart = read2.settings.hooks?.SessionStart;
+  const read3 = readHooksJson(file);
+  if ("error" in read3) return false;
+  const sessionStart = read3.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 read2 = readHooksJson(hooksFile);
-    if ("error" in read2) return null;
-    const sessionStart = read2.settings.hooks?.SessionStart;
+    const read3 = readHooksJson(hooksFile);
+    if ("error" in read3) return null;
+    const sessionStart = read3.settings.hooks?.SessionStart;
     if (!Array.isArray(sessionStart)) return false;
     const matches = [];
     for (const [groupIndex, group] of sessionStart.entries()) {
@@ -7421,7 +8381,7 @@ function codexHookTrusted(configFile = codexConfigFile(), hooksFile = codexHooks
           hooks: [normalizedHandler]
         };
         if (typeof group.matcher === "string") identity.matcher = group.matcher;
-        const currentHash = `sha256:${createHash("sha256").update(JSON.stringify(canonicalJson2(identity))).digest("hex")}`;
+        const currentHash = `sha256:${createHash3("sha256").update(JSON.stringify(canonicalJson2(identity))).digest("hex")}`;
         const key2 = `${hooksFile}:session_start:${groupIndex}:${handlerIndex}`;
         matches.push(config.hooks?.state?.[key2]?.trusted_hash === currentHash);
       }
@@ -7451,23 +8411,177 @@ function canonicalJson2(value) {
 // src/autosync/optin.ts
 import * as p6 from "@clack/prompts";
 
+// src/autosync/cursorHook.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir17, platform as platform2 } from "node:os";
+import { dirname as dirname7, join as join10 } from "node:path";
+
+// src/autosync/hook.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname6, join as join9 } from "node:path";
+var CLAUDE_SETTINGS_FILE = join9(homedir16(), ".claude", "settings.json");
+var AUTO_SYNC_HOOK_COMMAND = "npx -y @use-aistack/cli@latest sync --auto || npx -y --prefer-offline @use-aistack/cli sync --auto";
+function isOurs2(entry) {
+  return typeof entry.command === "string" && entry.command.includes("@use-aistack/cli") && entry.command.includes("sync --auto");
+}
+function readClaudeSettings(file) {
+  if (!existsSync9(file)) return { settings: {} };
+  try {
+    const raw = JSON.parse(readFileSync10(file, "utf-8"));
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      return { settings: raw };
+    }
+    return { error: `${file} does not hold a JSON object` };
+  } catch {
+    return { error: `${file} is not valid JSON - fix it, then retry` };
+  }
+}
+function installAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  const read3 = readClaudeSettings(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const settings = read3.settings;
+  const hooks = settings.hooks ?? {};
+  const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs2(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  kept.push({
+    hooks: [{ type: "command", command: AUTO_SYNC_HOOK_COMMAND, async: true }]
+  });
+  settings.hooks = { ...hooks, SessionStart: kept };
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync4(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `SessionStart hook written to ${file}` };
+}
+function removeAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
+  if (!existsSync9(file)) return { ok: true, message: "no hook to remove" };
+  const read3 = readClaudeSettings(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const settings = read3.settings;
+  const sessionStart = settings.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) {
+    return { ok: true, message: "no hook to remove" };
+  }
+  const kept = sessionStart.map((m) => ({
+    ...m,
+    hooks: (m.hooks ?? []).filter((h) => !isOurs2(h))
+  })).filter((m) => (m.hooks?.length ?? 0) > 0);
+  const hooks = { ...settings.hooks };
+  if (kept.length > 0) {
+    hooks.SessionStart = kept;
+  } else {
+    delete hooks.SessionStart;
+  }
+  if (Object.keys(hooks).length > 0) {
+    settings.hooks = hooks;
+  } else {
+    delete settings.hooks;
+  }
+  writeFileSync4(file, `${JSON.stringify(settings, null, 2)}
+`);
+  return { ok: true, message: `hook removed from ${file}` };
+}
+function autoSyncHookInstalled(file = CLAUDE_SETTINGS_FILE) {
+  const read3 = readClaudeSettings(file);
+  if ("error" in read3) return false;
+  const sessionStart = read3.settings.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) return false;
+  return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs2(h)));
+}
+
+// src/autosync/cursorHook.ts
+var CURSOR_HOOK_FILE = join10(homedir17(), ".cursor", "hooks.json");
+function cursorHookCommand(os = platform2()) {
+  if (os === "win32") {
+    const script = `Start-Process -WindowStyle Hidden -FilePath 'cmd.exe' -ArgumentList '/d /s /c "set AISTACK_HOOK_SOURCE=cursor&& (${AUTO_SYNC_HOOK_COMMAND}) <NUL >NUL 2>&1"'`;
+    return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(script, "utf16le").toString("base64")}`;
+  }
+  const detach = os === "darwin" ? "nohup" : "setsid nohup";
+  return `${detach} sh -c 'export AISTACK_HOOK_SOURCE=cursor; ${AUTO_SYNC_HOOK_COMMAND}' </dev/null >/dev/null 2>&1 &`;
+}
+function read(file) {
+  if (!existsSync10(file)) return {};
+  const value = JSON.parse(readFileSync11(file, "utf8"));
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("expected a JSON object");
+  const config = value;
+  if (config.version !== void 0 && config.version !== 1)
+    throw new Error("unsupported hooks version");
+  if (config.hooks !== void 0 && (!config.hooks || typeof config.hooks !== "object" || Array.isArray(config.hooks) || Object.values(config.hooks).some(
+    (entries) => !Array.isArray(entries) || entries.some(
+      (entry) => !entry || typeof entry !== "object" || Array.isArray(entry)
+    )
+  )))
+    throw new Error("malformed hooks object");
+  return config;
+}
+function isOurs3(entry) {
+  return ["linux", "darwin", "win32"].some(
+    (os) => entry.command === cursorHookCommand(os)
+  );
+}
+function update(file, install, os) {
+  try {
+    const config = read(file);
+    const existing = config.hooks?.stop ?? [];
+    const kept = existing.filter((entry) => !isOurs3(entry));
+    if (!install && kept.length === existing.length)
+      return { ok: true, message: "no Cursor hook to remove" };
+    if (install) kept.push({ command: cursorHookCommand(os) });
+    const hooks = { ...config.hooks };
+    if (kept.length) hooks.stop = kept;
+    else delete hooks.stop;
+    if (Object.keys(hooks).length) config.hooks = hooks;
+    else delete config.hooks;
+    if (install) config.version = 1;
+    mkdirSync5(dirname7(file), { recursive: true });
+    writeFileSync5(file, `${JSON.stringify(config, null, 2)}
+`);
+    return {
+      ok: true,
+      message: `Cursor stop hook ${install ? "written to" : "removed from"} ${file}`
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Could not ${install ? "install" : "remove"} Cursor hook in ${file}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function installCursorAutoSyncHook(file = CURSOR_HOOK_FILE, os = platform2()) {
+  return update(file, true, os);
+}
+function removeCursorAutoSyncHook(file = CURSOR_HOOK_FILE) {
+  return update(file, false, platform2());
+}
+function cursorAutoSyncHookInstalled(file = CURSOR_HOOK_FILE) {
+  try {
+    return (read(file).hooks?.stop ?? []).some(isOurs3);
+  } catch {
+    return false;
+  }
+}
+
 // src/autosync/grokHook.ts
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync10,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync12,
   unlinkSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { homedir as homedir13, platform as platform2 } from "node:os";
-import { dirname as dirname6, join as join9 } from "node:path";
-var GROK_HOOK_FILE = join9(
-  process.env.GROK_HOME || join9(homedir13(), ".grok"),
+import { homedir as homedir18, platform as platform3 } from "node:os";
+import { dirname as dirname8, join as join11 } from "node:path";
+var GROK_HOOK_FILE = join11(
+  process.env.GROK_HOME || join11(homedir18(), ".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()) {
+function grokHookCommand(os = platform3()) {
   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"'`;
   }
@@ -7477,9 +8591,9 @@ function grokHookCommand(os = platform2()) {
   return `setsid nohup sh -c 'export AISTACK_HOOK_SOURCE=grok; ${SYNC_COMMAND}' >/dev/null 2>&1 &`;
 }
 function readHookFile(file) {
-  if (!existsSync9(file)) return { value: {} };
+  if (!existsSync11(file)) return { value: {} };
   try {
-    const value = JSON.parse(readFileSync10(file, "utf-8"));
+    const value = JSON.parse(readFileSync12(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(
@@ -7496,19 +8610,19 @@ function readHookFile(file) {
   }
   return { error: `${file} does not hold a JSON object` };
 }
-function isOurs2(entry) {
+function isOurs4(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(
+function installGrokAutoSyncHook(file = GROK_HOOK_FILE, os = platform3()) {
+  const read3 = readHookFile(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const foreignKeys = Object.keys(read3.value).filter((key2) => key2 !== "hooks");
+  const foreignEvents = Object.keys(read3.value.hooks ?? {}).filter(
     (key2) => key2 !== "SessionStart"
   );
-  const sessionStart = read2.value.hooks?.SessionStart ?? [];
+  const sessionStart = read3.value.hooks?.SessionStart ?? [];
   const foreignHandlers = sessionStart.flatMap(
-    (group) => (group.hooks ?? []).filter((entry) => !isOurs2(entry))
+    (group) => (group.hooks ?? []).filter((entry) => !isOurs4(entry))
   );
   if (foreignKeys.length > 0 || foreignEvents.length > 0 || foreignHandlers.length > 0) {
     return {
@@ -7527,8 +8641,8 @@ function installGrokAutoSyncHook(file = GROK_HOOK_FILE, os = platform2()) {
       ]
     }
   };
-  mkdirSync4(dirname6(file), { recursive: true });
-  writeFileSync4(file, `${JSON.stringify(value, null, 2)}
+  mkdirSync6(dirname8(file), { recursive: true });
+  writeFileSync6(file, `${JSON.stringify(value, null, 2)}
 `);
   return {
     ok: true,
@@ -7536,15 +8650,15 @@ function installGrokAutoSyncHook(file = GROK_HOOK_FILE, os = platform2()) {
   };
 }
 function removeGrokAutoSyncHook(file = GROK_HOOK_FILE) {
-  if (!existsSync9(file))
+  if (!existsSync11(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(
+  const read3 = readHookFile(file);
+  if ("error" in read3) return { ok: false, message: read3.error };
+  const entries = read3.value.hooks?.SessionStart ?? [];
+  const onlyOurs = Object.keys(read3.value).every((key2) => key2 === "hooks") && Object.keys(read3.value.hooks ?? {}).every(
     (key2) => key2 === "SessionStart"
   ) && entries.every(
-    (group) => (group.hooks ?? []).every((entry) => isOurs2(entry))
+    (group) => (group.hooks ?? []).every((entry) => isOurs4(entry))
   );
   if (!onlyOurs) {
     return {
@@ -7556,89 +8670,13 @@ function removeGrokAutoSyncHook(file = GROK_HOOK_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))
+  const read3 = readHookFile(file);
+  if ("error" in read3) return false;
+  return (read3.value.hooks?.SessionStart ?? []).some(
+    (group) => (group.hooks ?? []).some((entry) => isOurs4(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 (!existsSync10(file)) return { settings: {} };
-  try {
-    const raw = JSON.parse(readFileSync11(file, "utf-8"));
-    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-      return { settings: raw };
-    }
-    return { error: `${file} does not hold a JSON object` };
-  } catch {
-    return { error: `${file} is not valid JSON - fix it, then retry` };
-  }
-}
-function installAutoSyncHook(file = CLAUDE_SETTINGS_FILE) {
-  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) => !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 };
-  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 (!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) => !isOurs3(h))
-  })).filter((m) => (m.hooks?.length ?? 0) > 0);
-  const hooks = { ...settings.hooks };
-  if (kept.length > 0) {
-    hooks.SessionStart = kept;
-  } else {
-    delete hooks.SessionStart;
-  }
-  if (Object.keys(hooks).length > 0) {
-    settings.hooks = hooks;
-  } else {
-    delete settings.hooks;
-  }
-  writeFileSync5(file, `${JSON.stringify(settings, null, 2)}
-`);
-  return { ok: true, message: `hook removed from ${file}` };
-}
-function autoSyncHookInstalled(file = CLAUDE_SETTINGS_FILE) {
-  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) => 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 supported session on this machine in the last ${DEFAULT_WINDOW_DAYS} days, so nothing would trigger an auto-sync. Nothing was changed.`;
@@ -7678,6 +8716,10 @@ async function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {
     const grokResult = (deps.installGrokHook ?? installGrokAutoSyncHook)();
     if (!grokResult.ok) return grokResult;
   }
+  if (names.has(CURSOR_HARNESS_NAME)) {
+    const result = (deps.installCursorHook ?? installCursorAutoSyncHook)();
+    if (!result.ok) return result;
+  }
   saveSettings(
     {
       autoSyncAnswered: true,
@@ -7688,7 +8730,7 @@ async function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {
   return {
     ok: true,
     message: [
-      `Auto-sync is on. It runs about every ${frequencyHours}h when a ${harnessListLabel(detected)} session starts. Turn it off any time: npx @use-aistack/cli sync --auto off`,
+      `Auto-sync is on. It runs about every ${frequencyHours}h when a ${harnessListLabel(detected)} ${names.has(CURSOR_HARNESS_NAME) ? "session is active" : "session starts"}. Turn it off any time: npx @use-aistack/cli sync --auto off`,
       ...trustLine ? [trustLine] : []
     ].join("\n")
   };
@@ -7710,7 +8752,8 @@ async function disableAutoSync(deps = {}) {
   const result = (deps.removeHook ?? removeAutoSyncHook)();
   const codexResult = (deps.removeCodexHook ?? removeCodexAutoSyncHook)();
   const grokResult = (deps.removeGrokHook ?? removeGrokAutoSyncHook)();
-  const failures = [result, codexResult, grokResult].filter((r) => !r.ok).map((r) => r.message);
+  const cursorResult = (deps.removeCursorHook ?? removeCursorAutoSyncHook)();
+  const failures = [result, codexResult, grokResult, cursorResult].filter((r) => !r.ok).map((r) => r.message);
   const token = (deps.getTokenImpl ?? getToken)();
   if (token !== null) {
     try {
@@ -7751,7 +8794,8 @@ async function reconcileAutoSync(permission, deps = {}) {
     const results = [
       (deps.removeHook ?? removeAutoSyncHook)(),
       (deps.removeCodexHook ?? removeCodexAutoSyncHook)(),
-      (deps.removeGrokHook ?? removeGrokAutoSyncHook)()
+      (deps.removeGrokHook ?? removeGrokAutoSyncHook)(),
+      (deps.removeCursorHook ?? removeCursorAutoSyncHook)()
     ];
     const failures2 = results.filter((result) => !result.ok);
     if (failures2.length > 0) {
@@ -7793,6 +8837,11 @@ async function reconcileAutoSync(permission, deps = {}) {
     deps.grokHookInstalledImpl ?? grokAutoSyncHookInstalled,
     deps.installGrokHook ?? installGrokAutoSyncHook
   );
+  install(
+    CURSOR_HARNESS_NAME,
+    deps.cursorHookInstalledImpl ?? cursorAutoSyncHookInstalled,
+    deps.installCursorHook ?? installCursorAutoSyncHook
+  );
   if (failures.length > 0) {
     return {
       ok: false,
@@ -7811,7 +8860,7 @@ async function reconcileAutoSync(permission, deps = {}) {
   if (installed.length === 0 && mirrored) return null;
   return {
     ok: true,
-    message: installed.length > 0 ? `Auto-sync is on for this stack. Installed the ${installed.join(" and ")} trigger on this machine; it runs about every ${frequencyHours}h when a session starts.` : `Auto-sync is on for this stack. It runs about every ${frequencyHours}h when a ${harnessListLabel(detected)} session starts.`
+    message: installed.length > 0 ? `Auto-sync is on for this stack. Installed the ${installed.join(" and ")} trigger on this machine; it runs about every ${frequencyHours}h during session activity.` : `Auto-sync is on for this stack. It runs about every ${frequencyHours}h when a ${harnessListLabel(detected)} ${names.has(CURSOR_HARNESS_NAME) ? "session is active" : "session starts"}.`
   };
 }
 async function settleAutoSync(permission, deps = {}) {
@@ -7829,13 +8878,14 @@ async function offerAutoSyncOptIn(deps = {}) {
     return false;
   const detected = await (deps.detectedImpl ?? detectedAdapters)();
   if (detected.length === 0) return false;
+  const names = new Set(detected.map((adapter) => adapter.name));
   const answer = await p6.select({
     message: "Keep this stack fresh automatically every 6 hours?",
     options: [
       {
         value: "enable",
         label: "Enable",
-        hint: `a silent sync at most every 6 hours when a ${harnessListLabel(detected)} session starts`
+        hint: `a silent sync at most every 6 hours when a ${harnessListLabel(detected)} ${names.has(CURSOR_HARNESS_NAME) ? "session is active" : "session starts"}`
       },
       {
         value: "later",
@@ -7878,17 +8928,17 @@ async function offerAutoSyncOptIn(deps = {}) {
 import {
   appendFileSync,
   closeSync,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { dirname as dirname8, join as join11 } from "node:path";
+import { homedir as homedir20 } from "node:os";
+import { dirname as dirname9, join as join12 } from "node:path";
 
 // src/sync/stage.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 
 // src/usage/days.ts
 var round6 = (n) => Math.round(n * 1e6) / 1e6;
@@ -8003,11 +9053,11 @@ function buildMeasuredDays(input) {
 
 // src/usage/diff.ts
 var MAX_DAY_WINDOW = 400;
-var DAY_MS = 864e5;
+var DAY_MS2 = 864e5;
 function retentionFloor(todayUtc, days) {
   const span = Math.max(1, Math.min(days, MAX_DAY_WINDOW));
   const todayMs = Date.parse(`${todayUtc}T00:00:00.000Z`);
-  return new Date(todayMs - (span - 1) * DAY_MS).toISOString().slice(0, 10);
+  return new Date(todayMs - (span - 1) * DAY_MS2).toISOString().slice(0, 10);
 }
 function selectDaysToPublish(input) {
   const { local, manifest, todayUtc } = input;
@@ -8044,7 +9094,7 @@ function selectDaysToPublish(input) {
 
 // src/workflow/git.ts
 import { execFile, execFileSync as execFileSync2 } from "node:child_process";
-import path7 from "node:path";
+import path12 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";
@@ -8308,10 +9358,10 @@ function reduceGitHistories(histories, options) {
       const field = fields[fieldIndex] ?? "";
       if (field.replace(/^\n+/, "") === COMMIT_MARKER) {
         finishCommit();
-        const hash = fields[++fieldIndex] ?? "";
+        const hash2 = fields[++fieldIndex] ?? "";
         const authoredAt = fields[++fieldIndex] ?? "";
         const authoredMs = Date.parse(authoredAt);
-        const included = Number.isFinite(authoredMs) && authoredMs >= options.fromMs && authoredMs <= options.toMs && !seenCommits.has(hash);
+        const included = Number.isFinite(authoredMs) && authoredMs >= options.fromMs && authoredMs <= options.toMs && !seenCommits.has(hash2);
         current = {
           included,
           date: included ? new Date(authoredMs).toISOString().slice(0, 10) : "",
@@ -8324,12 +9374,12 @@ function reduceGitHistories(histories, options) {
           withheldLines: 0,
           extensionLines: /* @__PURE__ */ new Map()
         };
-        if (included) seenCommits.add(hash);
+        if (included) seenCommits.add(hash2);
         continue;
       }
-      const stat7 = parseNumstat(field);
-      if (!stat7) continue;
-      let file = stat7.file;
+      const stat8 = parseNumstat(field);
+      if (!stat8) continue;
+      let file = stat8.file;
       if (file.length === 0) {
         fieldIndex += 2;
         file = fields[fieldIndex] ?? fields[fieldIndex - 1] ?? "";
@@ -8337,13 +9387,13 @@ function reduceGitHistories(histories, options) {
       if (!current?.included) continue;
       if (isUnauthoredPath(file)) continue;
       current.authored = true;
-      const fileChangedLines = stat7.additions + stat7.removals;
-      current.additions += stat7.additions;
-      current.removals += stat7.removals;
+      const fileChangedLines = stat8.additions + stat8.removals;
+      current.additions += stat8.additions;
+      current.removals += stat8.removals;
       current.changedLines += fileChangedLines;
       if (isTestFile(file)) current.touchesTest = true;
       if (fileChangedLines <= 0) continue;
-      const extension = path7.extname(file).toLowerCase();
+      const extension = path12.extname(file).toLowerCase();
       if (APPROVED_EXTENSIONS.has(extension)) {
         current.extensionLines.set(
           extension,
@@ -8447,36 +9497,36 @@ 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(),
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import path13 from "node:path";
+var defaultFile = path13.join(
+  homedir19(),
   ".config",
   "aistack",
   "grok-session-dates.json"
 );
 function grokCacheScope(baseUrl, stack, token) {
-  return createHash2("sha256").update(`${baseUrl}\0${stack}\0${token}`).digest("hex");
+  return createHash4("sha256").update(`${baseUrl}\0${stack}\0${token}`).digest("hex");
 }
-function read(file) {
-  if (!existsSync11(file)) return {};
+function read2(file) {
+  if (!existsSync12(file)) return {};
   try {
-    const value = JSON.parse(readFileSync12(file, "utf8"));
+    const value = JSON.parse(readFileSync13(file, "utf8"));
     return value && typeof value === "object" ? value : {};
   } catch {
     return {};
   }
 }
 function loadGrokDateHints(scope, file = defaultFile) {
-  return read(file)[scope] ?? {};
+  return read2(file)[scope] ?? {};
 }
 function saveGrokDateHints(scope, hints, file = defaultFile) {
-  const cache = read(file);
+  const cache = read2(file);
   cache[scope] = hints;
-  mkdirSync6(path8.dirname(file), { recursive: true });
-  writeFileSync6(file, JSON.stringify(cache, null, 2));
+  mkdirSync7(path13.dirname(file), { recursive: true });
+  writeFileSync7(file, JSON.stringify(cache, null, 2));
 }
 function mapToHints(value, floor) {
   return Object.fromEntries(
@@ -8887,7 +9937,7 @@ function buildGateSummary(ctx) {
 // src/sync/stage.ts
 var utcDate2 = (ms) => new Date(ms).toISOString().slice(0, 10);
 function stageId(bodyJson) {
-  return createHash3("sha256").update(bodyJson).digest("hex").slice(0, 12);
+  return createHash5("sha256").update(bodyJson).digest("hex").slice(0, 12);
 }
 async function stageSync(deps) {
   const now = (deps.now ?? Date.now)();
@@ -8941,11 +9991,12 @@ async function stageSync(deps) {
   const active2 = await adapters(sinceMs);
   const historical = await adapters(daysSinceMs);
   let dayScansComplete = true;
-  let grokCurrentDates = null;
+  const sessionDatesByHarness = /* @__PURE__ */ new Map();
   for (const adapter of active2) {
     progress(`Scanning recent ${adapter.name} usage`);
     const { aggregate, stats } = await adapter.scan({
       sinceMs,
+      publishWorkflow: false,
       onProgress: (files) => progress(`Scanning recent ${adapter.name} usage \xB7 ${files} files`)
     });
     scanStats[adapter.name] = stats;
@@ -8966,11 +10017,12 @@ async function stageSync(deps) {
     progress(`Reading historical ${adapter.name} days`);
     const { aggregate, workflow: workflow2, workflowLocal, scanComplete, sessionDates } = await adapter.scan({
       sinceMs: daysSinceMs,
+      publishWorkflow: config.publishWorkflow,
       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();
+    if (adapter.name === "grok-build" || adapter.name === "cursor")
+      sessionDatesByHarness.set(adapter.name, sessionDates ?? /* @__PURE__ */ new Map());
     workflowScans.push({ aggregate: workflow2, local: workflowLocal });
     usageScans.push(
       buildUsageDays({
@@ -8998,19 +10050,29 @@ async function stageSync(deps) {
   }
   const correctionDates = /* @__PURE__ */ new Set();
   let acknowledgePublish;
-  if (grokCurrentDates && token && config.stack) {
-    const scope = grokCacheScope(deps.baseUrl, config.stack.slug, token);
+  const acknowledgements = [];
+  for (const [harness, currentDates] of sessionDatesByHarness) {
+    if (!token || !config.stack) continue;
+    const scope = grokCacheScope(
+      harness === "grok-build" ? deps.baseUrl : `${deps.baseUrl}\0${harness}`,
+      config.stack.slug,
+      token
+    );
     const floor = utcDate2(daysSinceMs);
     const previous = loadGrokDateHints(scope);
-    const current = mapToHints(grokCurrentDates, floor);
+    const current = mapToHints(currentDates, 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);
+    acknowledgements.push(() => saveGrokDateHints(scope, current));
   }
+  if (acknowledgements.length)
+    acknowledgePublish = () => {
+      for (const acknowledge of acknowledgements) acknowledge();
+    };
   const localDays = applyDayConsent(
     buildMeasuredDays({
       usage: mergeUsageDays(usageScans),
@@ -9080,31 +10142,31 @@ async function stageSync(deps) {
 }
 
 // src/autosync/run.ts
-var SYNC_LOG_FILE = join11(homedir16(), ".config", "aistack", "sync.log");
+var SYNC_LOG_FILE = join12(homedir20(), ".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) {
-  mkdirSync7(dirname8(file), { recursive: true });
+  mkdirSync8(dirname9(file), { recursive: true });
   appendFileSync(file, `${line}
 `);
-  const lines2 = readFileSync13(file, "utf-8").split("\n").filter(Boolean);
+  const lines2 = readFileSync14(file, "utf-8").split("\n").filter(Boolean);
   if (lines2.length > SYNC_LOG_MAX_LINES) {
-    writeFileSync7(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
+    writeFileSync8(file, `${lines2.slice(-SYNC_LOG_MAX_LINES).join("\n")}
 `);
   }
 }
 function reserveAttempt(file, now, windowMs) {
-  mkdirSync7(dirname8(file), { recursive: true });
+  mkdirSync8(dirname9(file), { recursive: true });
   for (; ; ) {
     try {
       const fd = openSync(file, "wx");
-      writeFileSync7(fd, String(now));
+      writeFileSync8(fd, String(now));
       closeSync(fd);
       return true;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
-      const held = Number(readFileSync13(file, "utf-8"));
+      const held = Number(readFileSync14(file, "utf-8"));
       if (Number.isFinite(held) && now - held < windowMs) return false;
       try {
         unlinkSync2(file);
@@ -9133,7 +10195,7 @@ async function runAutoSync(deps) {
   const state = settings.autoSyncState ?? {};
   const lastRunAt = state.lastRunAt ?? 0;
   if (now - lastRunAt < windowMs) return;
-  const reservationFile = deps.reservationFile ?? `${settingsFile ?? join11(homedir16(), ".config", "aistack", "settings.json")}.auto-sync-attempt`;
+  const reservationFile = deps.reservationFile ?? `${settingsFile ?? join12(homedir20(), ".config", "aistack", "settings.json")}.auto-sync-attempt`;
   if (!reserveAttempt(reservationFile, now, windowMs)) return;
   saveSettings({ autoSyncState: { ...state, lastRunAt: now } }, settingsFile);
   const stage = deps.stageImpl ?? stageSync;
@@ -9226,7 +10288,7 @@ async function runAutoSync(deps) {
     logFile,
     `${stamp} fail (${consecutiveFailures} in a row) - ${failure2}`
   );
-  if (shouldWarn && deps.suppressOutput !== true && process.env.AISTACK_HOOK_SOURCE !== "grok") {
+  if (shouldWarn && deps.suppressOutput !== true && process.env.AISTACK_HOOK_SOURCE !== "grok" && process.env.AISTACK_HOOK_SOURCE !== "cursor") {
     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.`
@@ -9720,7 +10782,7 @@ program.command("mcp").description(
 });
 program.command("sync").description("Scan, preview, and publish measured usage (rolling 30 days)").option(
   "--auto [state]",
-  "silent background sync; 'on' asks your stack for the permission and installs the SessionStart hooks, 'off' revokes both"
+  "silent background sync; 'on' asks your stack for the permission and installs harness hooks, 'off' revokes both"
 ).option(
   "--every <hours>",
   "with --auto on: hours between auto-syncs (default 6)"