@ascenda-one/history-import 0.1.12

package/dist/cli.js

@@ -0,0 +1,3889 @@
+#!/usr/bin/env node
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../packages/tool-kit/out/commandClassifier.js
+var require_commandClassifier = __commonJS({
+  "../packages/tool-kit/out/commandClassifier.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.classifyCommand = classifyCommand;
+    exports.isVerificationCommand = isVerificationCommand;
+    function classifyCommand(command) {
+      if (!command)
+        return "unknown";
+      const value = command.toLowerCase().trim();
+      if (/\b(test|jest|vitest|mocha|pytest|rspec|go test|cargo test|dotnet test|xcodebuild test)\b/.test(value) || /\bnpm\s+(run\s+)?test\b/.test(value) || /\byarn\s+test\b/.test(value) || /\bpnpm\s+(run\s+)?test\b/.test(value))
+        return "test";
+      if (/\b(lint|eslint|ruff|flake8|pylint|rubocop)\b/.test(value) || /\bnpm\s+(run\s+)?lint\b/.test(value))
+        return "lint";
+      if (/\b(tsc|typecheck|mypy|pyright|sorbet|flow)\b/.test(value) || /\bnpm\s+(run\s+)?typecheck\b/.test(value))
+        return "typecheck";
+      if (/\b(build|webpack|vite build|next build|turbo build|cargo build|go build|dotnet build|xcodebuild)\b/.test(value) || /\bnpm\s+(run\s+)?build\b/.test(value))
+        return "build";
+      if (/\b(git)\b/.test(value))
+        return "git";
+      if (/\b(npm install|yarn install|pnpm install|bun install|pip install|poetry install|bundle install)\b/.test(value))
+        return "install";
+      if (/\b(npm start|npm run dev|yarn dev|pnpm dev|next dev|vite|node|python|tsx|ts-node)\b/.test(value))
+        return "run";
+      return "unknown";
+    }
+    function isVerificationCommand(commandClass) {
+      return commandClass === "test" || commandClass === "lint" || commandClass === "typecheck" || commandClass === "build";
+    }
+  }
+});
+
+// ../packages/tool-kit/out/commandHeads.js
+var require_commandHeads = __commonJS({
+  "../packages/tool-kit/out/commandHeads.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.commandHeads = commandHeads;
+    function commandHeads(value) {
+      const stripped = stripQuoted(stripHeredocBodies(value));
+      return stripped.split(/[;&|()\n]+/).map((segment) => {
+        let head = segment.trim();
+        for (; ; ) {
+          const env = /^[a-z_][a-z0-9_]*=\S*\s+/.exec(head);
+          if (!env)
+            break;
+          head = head.slice(env[0].length);
+        }
+        return head;
+      }).filter((head) => head.length > 0);
+    }
+    function stripHeredocBodies(value) {
+      const marker = /<<-?\s*(["']?)(\w+)\1/;
+      let kept = "";
+      let rest = value;
+      for (; ; ) {
+        const opened = marker.exec(rest);
+        if (!opened)
+          return kept + rest;
+        const introLineEnd = rest.indexOf("\n", opened.index + opened[0].length);
+        if (introLineEnd === -1)
+          return kept + rest;
+        kept += rest.slice(0, introLineEnd + 1);
+        const body = rest.slice(introLineEnd + 1);
+        const terminator = new RegExp(`^\\s*${opened[2]}\\s*$`, "m").exec(body);
+        if (!terminator)
+          return kept;
+        rest = body.slice(terminator.index + terminator[0].length);
+      }
+    }
+    function stripQuoted(value) {
+      let out = "";
+      let i = 0;
+      while (i < value.length) {
+        const ch = value[i];
+        if (ch === "'") {
+          const close = value.indexOf("'", i + 1);
+          if (close === -1)
+            return out;
+          i = close + 1;
+        } else if (ch === '"') {
+          let j = i + 1;
+          while (j < value.length && value[j] !== '"') {
+            j += value[j] === "\\" ? 2 : 1;
+          }
+          if (j >= value.length)
+            return out;
+          i = j + 1;
+        } else if (ch === "\\") {
+          out += value.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += ch;
+          i += 1;
+        }
+      }
+      return out;
+    }
+  }
+});
+
+// ../packages/tool-kit/out/gitActionClassifier.js
+var require_gitActionClassifier = __commonJS({
+  "../packages/tool-kit/out/gitActionClassifier.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.classifyGitAction = classifyGitAction;
+    exports.isReworkGitAction = isReworkGitAction;
+    var commandHeads_1 = require_commandHeads();
+    function classifyGitAction(command) {
+      if (!command)
+        return void 0;
+      const value = command.toLowerCase().trim();
+      if (!/\bgit\b/.test(value))
+        return void 0;
+      const heads = (0, commandHeads_1.commandHeads)(value);
+      if (heads.some((h) => /^git\s+commit\b/.test(h) && /\s--amend\b/.test(h)))
+        return "amend";
+      if (heads.some((h) => /^git\s+revert\b/.test(h)))
+        return "revert";
+      if (heads.some((h) => /^git\s+reset\b/.test(h) && /\s--hard\b/.test(h)))
+        return "reset_hard";
+      if (heads.some((h) => /^git\s+restore\b/.test(h) && !/\s--staged\b/.test(h)))
+        return "restore";
+      if (heads.some((h) => /^git\s+checkout\b.*\s--\s/.test(h)))
+        return "restore";
+      if (heads.some((h) => /^git\s+push\b/.test(h)))
+        return "push";
+      if (heads.some((h) => /^git\s+commit\b/.test(h)))
+        return "commit";
+      return void 0;
+    }
+    function isReworkGitAction(action) {
+      return action === "revert" || action === "reset_hard" || action === "restore";
+    }
+  }
+});
+
+// ../packages/tool-kit/out/workMilestoneClassifier.js
+var require_workMilestoneClassifier = __commonJS({
+  "../packages/tool-kit/out/workMilestoneClassifier.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.classifyWorkMilestone = classifyWorkMilestone;
+    exports.invitesDebrief = invitesDebrief;
+    var commandHeads_1 = require_commandHeads();
+    function classifyWorkMilestone(command) {
+      if (!command)
+        return void 0;
+      const value = command.toLowerCase().trim();
+      if (!/\bgh\b/.test(value))
+        return void 0;
+      const heads = (0, commandHeads_1.commandHeads)(value);
+      if (heads.some((head) => /^gh\s+pr\s+merge\b/.test(head)))
+        return "pr_merged";
+      if (heads.some((head) => /^gh\s+issue\s+close\b/.test(head)))
+        return "issue_closed";
+      if (heads.some((head) => /^gh\s+pr\s+create\b/.test(head)))
+        return "pr_opened";
+      return void 0;
+    }
+    function invitesDebrief(kind) {
+      return kind === "pr_merged" || kind === "issue_closed";
+    }
+  }
+});
+
+// ../packages/tool-kit/out/buckets.js
+var require_buckets = __commonJS({
+  "../packages/tool-kit/out/buckets.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bucketLinesChanged = bucketLinesChanged2;
+    exports.bucketDurationMs = bucketDurationMs4;
+    function bucketLinesChanged2(count) {
+      if (count <= 0)
+        return "0";
+      if (count <= 10)
+        return "1-10";
+      if (count <= 50)
+        return "10-50";
+      if (count <= 200)
+        return "50-200";
+      return "200+";
+    }
+    function bucketDurationMs4(durationMs) {
+      if (typeof durationMs !== "number" || !Number.isFinite(durationMs) || durationMs < 0)
+        return void 0;
+      const minutes = durationMs / 6e4;
+      if (minutes <= 1)
+        return "0-1m";
+      if (minutes <= 5)
+        return "1-5m";
+      if (minutes <= 10)
+        return "5-10m";
+      if (minutes <= 30)
+        return "10-30m";
+      if (minutes <= 60)
+        return "30-60m";
+      return "60m+";
+    }
+  }
+});
+
+// ../packages/tool-kit/out/afterHours.js
+var require_afterHours = __commonJS({
+  "../packages/tool-kit/out/afterHours.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isAfterHours = isAfterHours4;
+    exports.utcOffsetMinutesAt = utcOffsetMinutesAt2;
+    exports.localHourAt = localHourAt;
+    function isAfterHours4(now = /* @__PURE__ */ new Date(), start = "19:00", end = "07:00") {
+      const currentMinutes = now.getHours() * 60 + now.getMinutes();
+      const startMinutes = parseTimeToMinutes(start, 19 * 60);
+      const endMinutes = parseTimeToMinutes(end, 7 * 60);
+      if (startMinutes === endMinutes)
+        return false;
+      if (startMinutes < endMinutes)
+        return currentMinutes >= startMinutes && currentMinutes < endMinutes;
+      return currentMinutes >= startMinutes || currentMinutes < endMinutes;
+    }
+    function parseTimeToMinutes(value, fallback) {
+      const match = /^(\d{1,2}):(\d{2})$/.exec(value.trim());
+      if (!match)
+        return fallback;
+      const hours = Number(match[1]);
+      const minutes = Number(match[2]);
+      if (Number.isNaN(hours) || Number.isNaN(minutes))
+        return fallback;
+      return Math.max(0, Math.min(23, hours)) * 60 + Math.max(0, Math.min(59, minutes));
+    }
+    function utcOffsetMinutesAt2(at) {
+      return -at.getTimezoneOffset();
+    }
+    function localHourAt(at, utcOffsetMinutes) {
+      const shifted = new Date(at.getTime() + utcOffsetMinutes * 6e4);
+      return shifted.getUTCHours();
+    }
+  }
+});
+
+// ../packages/tool-kit/out/payload.js
+var require_payload = __commonJS({
+  "../packages/tool-kit/out/payload.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getString = getString;
+    exports.getNumber = getNumber;
+    exports.getNested = getNested;
+    exports.getNestedString = getNestedString;
+    exports.getNestedNumber = getNestedNumber;
+    exports.inferOutcome = inferOutcome;
+    exports.outcomeForHook = outcomeForHook;
+    exports.looksLikeCorrection = looksLikeCorrection;
+    function getString(input, keys) {
+      for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim())
+          return value;
+      }
+      return void 0;
+    }
+    function getNumber(input, keys) {
+      for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "number" && Number.isFinite(value))
+          return value;
+      }
+      return void 0;
+    }
+    function getNested(input, path9) {
+      let current = input;
+      for (const segment of path9) {
+        if (!current || typeof current !== "object")
+          return void 0;
+        current = current[segment];
+      }
+      return current;
+    }
+    function getNestedString(input, paths) {
+      for (const path9 of paths) {
+        const value = getNested(input, path9);
+        if (typeof value === "string" && value.trim())
+          return value;
+      }
+      return void 0;
+    }
+    function getNestedNumber(input, paths) {
+      for (const path9 of paths) {
+        const value = getNested(input, path9);
+        if (typeof value === "number" && Number.isFinite(value))
+          return value;
+      }
+      return void 0;
+    }
+    function inferOutcome(input) {
+      const exitCode = getNumber(input, ["exitCode", "exit_code", "status"]) ?? getNestedNumber(input, [["tool_response", "exitCode"], ["tool_response", "exit_code"], ["result", "exitCode"], ["result", "exit_code"]]);
+      if (typeof exitCode === "number")
+        return exitCode === 0 ? "success" : "failure";
+      const error = getString(input, ["error", "errorMessage"]) ?? getNestedString(input, [["tool_response", "error"], ["result", "error"]]);
+      if (error)
+        return "failure";
+      return "unknown";
+    }
+    function outcomeForHook(hookName, input) {
+      if (hookName === "PostToolUseFailure") {
+        const interrupted = input["is_interrupt"] === true || getNested(input, ["tool_response", "interrupted"]) === true;
+        return interrupted ? "cancelled" : "failure";
+      }
+      if (hookName === "PostToolUse") {
+        if (getNested(input, ["tool_response", "interrupted"]) === true)
+          return "cancelled";
+        return "success";
+      }
+      return "unknown";
+    }
+    function looksLikeCorrection(text) {
+      if (!text)
+        return false;
+      return /\b(wrong|incorrect|try again|fix|not what i asked|that's not|that is not|redo|regenerate|you missed|doesn't work|does not work)\b/i.test(text);
+    }
+  }
+});
+
+// ../packages/tool-contract/out/index.js
+var require_out = __commonJS({
+  "../packages/tool-contract/out/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ASCENDA_SEMANTIC_PROVENANCE = exports.ASCENDA_HISTORICAL_CONSENT_SCOPE = exports.ASCENDA_COLLABORATION_CONSENT_SCOPE = exports.ASCENDA_SEMANTIC_CONSENT_SCOPE = exports.ASCENDA_PROVENANCE = exports.ASCENDA_CONSENT_SCOPE = exports.EVENT_WORKLOAD_CATEGORY = exports.COLLABORATION_EVENT_TYPES = exports.SEMANTIC_WORK_SIGNAL_EVENT_TYPES = void 0;
+    exports.SEMANTIC_WORK_SIGNAL_EVENT_TYPES = [
+      "approach_churn_detected",
+      "goal_drift_detected",
+      "progress_stalled",
+      "progress_recovered",
+      "session_intention_declared",
+      "scope_change_declared"
+    ];
+    exports.COLLABORATION_EVENT_TYPES = [
+      "review_requested_of_me",
+      "review_given",
+      "pull_request_opened"
+    ];
+    exports.EVENT_WORKLOAD_CATEGORY = {
+      create_focus_session: "creation",
+      ai_prompt_submitted: "creation",
+      ai_generation_completed: "creation",
+      ai_file_write: "creation",
+      ai_file_edit: "creation",
+      editor_verification_activity: "verification",
+      compile_diagnostic: "verification",
+      editor_correction_activity: "supervision",
+      ai_correction_prompt: "supervision",
+      supervis_meeting_load: "supervision",
+      ai_tool_call_started: "supervision",
+      ai_tool_call_completed: "supervision",
+      ai_tool_call_failed: "supervision",
+      // Collaboration (the report's §4.2 collaboration family). Both review
+      // events are supervision: being asked to check work, and checking it, are
+      // the load the report's "verification overload" concern is about — the one
+      // that concentrates on senior engineers as a team adopts AI. Opening a pull
+      // request is creation: it is the point your own work leaves your hands.
+      review_requested_of_me: "supervision",
+      review_given: "supervision",
+      pull_request_opened: "creation",
+      context_pressure_high: "risk",
+      agent_loop_long: "risk",
+      after_hours_ai_session: "risk",
+      compile_error: "risk",
+      tool_failure: "risk",
+      recovery_offline_period: "neutral",
+      context_compression_manual: "neutral",
+      context_compression_auto: "neutral",
+      editor_activity: "neutral",
+      // Semantic (agent-observed) — see SEMANTIC_WORK_SIGNAL_EVENT_TYPES.
+      approach_churn_detected: "risk",
+      goal_drift_detected: "risk",
+      progress_stalled: "risk",
+      progress_recovered: "neutral",
+      session_intention_declared: "neutral",
+      scope_change_declared: "neutral"
+    };
+    exports.ASCENDA_CONSENT_SCOPE = "ide_telemetry";
+    exports.ASCENDA_PROVENANCE = "ai_work_telemetry";
+    exports.ASCENDA_SEMANTIC_CONSENT_SCOPE = "semantic_work_signals";
+    exports.ASCENDA_COLLABORATION_CONSENT_SCOPE = "workflow_telemetry";
+    exports.ASCENDA_HISTORICAL_CONSENT_SCOPE = "historical_import";
+    exports.ASCENDA_SEMANTIC_PROVENANCE = "semantic_work_signals";
+  }
+});
+
+// ../packages/tool-kit/out/eventLog.js
+var require_eventLog = __commonJS({
+  "../packages/tool-kit/out/eventLog.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EVENT_LOG_ENV_VAR = void 0;
+    exports.expandUserPath = expandUserPath;
+    exports.resolveEventLogPath = resolveEventLogPath;
+    exports.appendEventLog = appendEventLog;
+    var fs9 = __importStar(__require("fs"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    exports.EVENT_LOG_ENV_VAR = "ASCENDA_EVENT_LOG_FILE";
+    var MAX_BYTES = 5 * 1024 * 1024;
+    function expandUserPath(configured) {
+      const value = configured?.trim();
+      if (!value)
+        return void 0;
+      if (value === "~")
+        return os3.homedir();
+      if (value.startsWith("~/"))
+        return path9.join(os3.homedir(), value.slice(2));
+      return path9.resolve(value);
+    }
+    function resolveEventLogPath() {
+      return expandUserPath(process.env[exports.EVENT_LOG_ENV_VAR]);
+    }
+    function appendEventLog(logFilePath, entry) {
+      try {
+        rotateIfLarge(logFilePath);
+        const dir = path9.dirname(logFilePath);
+        fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs9.appendFileSync(logFilePath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+        if (process.platform !== "win32")
+          fs9.chmodSync(logFilePath, 384);
+      } catch {
+      }
+    }
+    function rotateIfLarge(logFilePath) {
+      try {
+        if (fs9.statSync(logFilePath).size < MAX_BYTES)
+          return;
+        fs9.renameSync(logFilePath, `${logFilePath}.1`);
+      } catch {
+      }
+    }
+  }
+});
+
+// ../packages/tool-kit/out/http.js
+var require_http = __commonJS({
+  "../packages/tool-kit/out/http.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AscendaApiError = void 0;
+    exports.createPairingSession = createPairingSession;
+    exports.getPairingStatus = getPairingStatus;
+    exports.renewToolToken = renewToolToken;
+    exports.isRetryableStatus = isRetryableStatus;
+    exports.postToolEvent = postToolEvent;
+    exports.postToolEventsBatch = postToolEventsBatch;
+    exports.parseIngestResponse = parseIngestResponse;
+    var AscendaApiError = class extends Error {
+      status;
+      errorCode;
+      constructor(status, errorCode, body) {
+        super(body ?? `Ascenda API error ${status}`);
+        this.status = status;
+        this.errorCode = errorCode;
+        this.name = "AscendaApiError";
+      }
+    };
+    exports.AscendaApiError = AscendaApiError;
+    async function createPairingSession(apiBaseUrl, toolInstallationId, toolType, displayName) {
+      const response = await fetch(`${apiBaseUrl}/v1/tool-pairing-sessions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ toolInstallationId, toolType, displayName })
+      });
+      if (!response.ok)
+        throw new AscendaApiError(response.status, void 0, await response.text());
+      return await response.json();
+    }
+    async function getPairingStatus(apiBaseUrl, pairingSessionId) {
+      const response = await fetch(`${apiBaseUrl}/v1/tool-pairing-sessions/${encodeURIComponent(pairingSessionId)}/status`, {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok)
+        throw new AscendaApiError(response.status, void 0, await response.text());
+      return await response.json();
+    }
+    async function renewToolToken(apiBaseUrl, eventWriteToken, signal) {
+      const response = await fetch(`${apiBaseUrl}/v1/tool-events/renew-token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${eventWriteToken}` },
+        signal
+      });
+      if (response.status === 401)
+        return null;
+      if (!response.ok)
+        throw new AscendaApiError(response.status, void 0, await response.text());
+      return await response.json();
+    }
+    function isRetryableStatus(status) {
+      return status === 408 || status === 429 || status !== void 0 && status >= 500 && status <= 599;
+    }
+    async function postToolEvent(apiBaseUrl, eventWriteToken, payload, signal) {
+      return sendIngest(`${apiBaseUrl}/v1/tool-events`, eventWriteToken, JSON.stringify(payload), signal);
+    }
+    async function postToolEventsBatch(apiBaseUrl, eventWriteToken, payloads, signal) {
+      return sendIngest(`${apiBaseUrl}/v1/tool-events/batch`, eventWriteToken, JSON.stringify({ events: payloads }), signal);
+    }
+    async function sendIngest(url, eventWriteToken, body, signal) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${eventWriteToken}` },
+          body,
+          signal
+        });
+        return parseIngestResponse(response);
+      } catch (error) {
+        return {
+          result: "transport_error",
+          detail: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
+        };
+      }
+    }
+    async function parseIngestResponse(response) {
+      if (response.ok)
+        return { result: "accepted", httpStatus: response.status };
+      const body = await response.text();
+      let errorCode;
+      try {
+        errorCode = JSON.parse(body).error;
+      } catch {
+        errorCode = void 0;
+      }
+      const base = { httpStatus: response.status, errorCode, detail: body || void 0 };
+      if (response.status === 401)
+        return { ...base, result: "auth_failed" };
+      if (response.status === 403 && errorCode === "consent_missing_or_expired")
+        return { ...base, result: "consent_missing" };
+      if (response.status === 400 || response.status === 422)
+        return { ...base, result: "validation_failed" };
+      return { ...base, result: "transport_error" };
+    }
+  }
+});
+
+// ../packages/tool-kit/out/tokenStore.js
+var require_tokenStore = __commonJS({
+  "../packages/tool-kit/out/tokenStore.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultTokenFilePath = defaultTokenFilePath2;
+    exports.persistEventWriteToken = persistEventWriteToken;
+    exports.readTokenFile = readTokenFile2;
+    exports.sanitizeFilePart = sanitizeFilePart;
+    var fs9 = __importStar(__require("fs"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    function defaultTokenFilePath2(toolInstallationId) {
+      return path9.join(os3.homedir(), ".ascenda", "tokens", sanitizeFilePart(toolInstallationId));
+    }
+    function persistEventWriteToken(tokenFilePath, token) {
+      const dir = path9.dirname(tokenFilePath);
+      fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs9.writeFileSync(tokenFilePath, token, { encoding: "utf8", mode: 384 });
+      if (process.platform !== "win32") {
+        fs9.chmodSync(dir, 448);
+        fs9.chmodSync(tokenFilePath, 384);
+      }
+    }
+    function readTokenFile2(tokenFilePath) {
+      try {
+        if (!fs9.existsSync(tokenFilePath))
+          return void 0;
+        const value = fs9.readFileSync(tokenFilePath, "utf8").trim();
+        return value || void 0;
+      } catch {
+        return void 0;
+      }
+    }
+    function sanitizeFilePart(value) {
+      return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+    }
+  }
+});
+
+// ../packages/tool-kit/out/stateStore.js
+var require_stateStore = __commonJS({
+  "../packages/tool-kit/out/stateStore.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultStateFilePath = defaultStateFilePath;
+    exports.readCollectorState = readCollectorState;
+    exports.recordSendOutcome = recordSendOutcome;
+    exports.shouldAnnounceFailure = shouldAnnounceFailure;
+    exports.markFailureNotified = markFailureNotified;
+    var fs9 = __importStar(__require("fs"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    var tokenStore_1 = require_tokenStore();
+    function defaultStateFilePath(toolInstallationId) {
+      const dir = process.env.ASCENDA_STATE_DIR?.trim();
+      const base = dir ? dir : path9.join(os3.homedir(), ".ascenda", "state");
+      return path9.join(base, `${(0, tokenStore_1.sanitizeFilePart)(toolInstallationId)}.json`);
+    }
+    function readCollectorState(stateFilePath) {
+      try {
+        if (!fs9.existsSync(stateFilePath))
+          return void 0;
+        const raw = fs9.readFileSync(stateFilePath, "utf8").trim();
+        if (!raw)
+          return void 0;
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+          return void 0;
+        return parsed;
+      } catch {
+        return void 0;
+      }
+    }
+    function recordSendOutcome(stateFilePath, toolInstallationId, outcome, detail = {}) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const previous = readCollectorState(stateFilePath);
+      const accepted = outcome === "accepted";
+      const next = {
+        toolInstallationId,
+        lastAttemptAt: now,
+        lastSuccessAt: accepted ? now : previous?.lastSuccessAt,
+        lastOutcome: outcome,
+        consecutiveFailures: accepted ? 0 : (previous?.consecutiveFailures ?? 0) + 1,
+        ...detail.httpStatus !== void 0 ? { httpStatus: detail.httpStatus } : {},
+        ...detail.errorCode !== void 0 ? { errorCode: detail.errorCode } : {},
+        ...detail.detail !== void 0 ? { detail: truncate(detail.detail) } : {},
+        // A success closes the episode; a failure either opens one or continues
+        // the one already open. Carrying `notifiedFailingSince` across a
+        // continuing episode is what keeps the notice to once per outage.
+        ...accepted ? {} : { failingSince: previous?.failingSince ?? now },
+        ...accepted ? {} : previous?.notifiedFailingSince !== void 0 ? { notifiedFailingSince: previous.notifiedFailingSince } : {}
+      };
+      writeStateFile(stateFilePath, next);
+      return next;
+    }
+    function shouldAnnounceFailure(state) {
+      if (!state || state.consecutiveFailures === 0 || !state.failingSince)
+        return false;
+      return state.notifiedFailingSince !== state.failingSince;
+    }
+    function markFailureNotified(stateFilePath, state) {
+      if (!state.failingSince)
+        return;
+      writeStateFile(stateFilePath, { ...state, notifiedFailingSince: state.failingSince });
+    }
+    function writeStateFile(stateFilePath, state) {
+      const temporaryPath = `${stateFilePath}.${process.pid}.tmp`;
+      try {
+        const dir = path9.dirname(stateFilePath);
+        fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs9.writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+        fs9.renameSync(temporaryPath, stateFilePath);
+        if (process.platform !== "win32")
+          fs9.chmodSync(stateFilePath, 384);
+      } catch {
+        try {
+          if (fs9.existsSync(temporaryPath))
+            fs9.unlinkSync(temporaryPath);
+        } catch {
+        }
+      }
+    }
+    function truncate(value) {
+      const collapsed = value.replace(/\s+/g, " ").trim();
+      return collapsed.length > 200 ? `${collapsed.slice(0, 197)}...` : collapsed;
+    }
+  }
+});
+
+// ../packages/tool-kit/out/eventSender.js
+var require_eventSender = __commonJS({
+  "../packages/tool-kit/out/eventSender.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AscendaEventSender = exports.AscendaSemanticEventError = void 0;
+    exports.buildEventPayload = buildEventPayload;
+    var afterHours_1 = require_afterHours();
+    var tool_contract_1 = require_out();
+    var eventLog_1 = require_eventLog();
+    var http_1 = require_http();
+    var tokenStore_1 = require_tokenStore();
+    var stateStore_1 = require_stateStore();
+    var AscendaSemanticEventError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AscendaSemanticEventError";
+      }
+    };
+    exports.AscendaSemanticEventError = AscendaSemanticEventError;
+    function buildEventPayload(identity, mapped) {
+      return {
+        toolInstallationId: identity.toolInstallationId,
+        source: identity.source,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+        sessionId: identity.sessionId ?? void 0,
+        workspaceHash: identity.workspaceHash ?? void 0,
+        consentScope: tool_contract_1.ASCENDA_CONSENT_SCOPE,
+        provenance: tool_contract_1.ASCENDA_PROVENANCE,
+        privacyMode: "metadata_only",
+        ...mapped,
+        metadata: mapped.metadata ?? {}
+      };
+    }
+    var DEFAULT_TIMEOUT_MS = 5e3;
+    var RETRY_DELAY_MS = 250;
+    var AscendaEventSender = class {
+      config;
+      eventWriteToken;
+      lastState;
+      constructor(config) {
+        this.config = config;
+        this.eventWriteToken = config.eventWriteToken;
+      }
+      async send(mapped) {
+        return this.post(buildEventPayload(this.config, mapped));
+      }
+      /**
+       * Sends one of the six agent-observed types (dark-flow-gap-analysis §2.1).
+       * Distinct from {@link send} rather than an option on it, because the
+       * differences are non-negotiable, not caller preference:
+       *
+       *  - `consentScope`/`provenance` are always the semantic pair — a lease on
+       *    `ide_telemetry` alone does not cover these.
+       *  - `severity` is always `"low"`. The emitter has no baseline to judge
+       *    against; an elevated reading can only come from the backend's own
+       *    z-scored evaluation, never from this payload.
+       *  - `metadata.skillVersion` is required by the type, not merely
+       *    documented, and checked again here in case a caller building the
+       *    object dynamically bypasses the type system.
+       *
+       * Rejects locally (never reaches the network) for an eventType outside
+       * {@link SEMANTIC_WORK_SIGNAL_EVENT_TYPES} or a missing/blank
+       * `skillVersion` — a malformed semantic event is a bug in the caller, not
+       * something the backend should have to catch.
+       */
+      async sendSemanticSignal(mapped) {
+        if (!tool_contract_1.SEMANTIC_WORK_SIGNAL_EVENT_TYPES.includes(mapped.eventType)) {
+          throw new AscendaSemanticEventError(`"${mapped.eventType}" is not a semantic work-signal type. Use send() for a deterministic host event.`);
+        }
+        if (!mapped.metadata.skillVersion || !mapped.metadata.skillVersion.trim()) {
+          throw new AscendaSemanticEventError(`metadata.skillVersion is required for semantic event "${mapped.eventType}".`);
+        }
+        const payload = {
+          toolInstallationId: this.config.toolInstallationId,
+          source: this.config.source,
+          eventType: mapped.eventType,
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+          severity: "low",
+          sessionId: this.config.sessionId ?? void 0,
+          workspaceHash: this.config.workspaceHash ?? void 0,
+          consentScope: tool_contract_1.ASCENDA_SEMANTIC_CONSENT_SCOPE,
+          provenance: tool_contract_1.ASCENDA_SEMANTIC_PROVENANCE,
+          privacyMode: "metadata_only",
+          metadata: mapped.metadata
+        };
+        return this.post(payload);
+      }
+      /**
+       * Sends a collaboration event under `workflow_telemetry`.
+       *
+       * A separate method rather than an option on {@link send}, for the same
+       * reason {@link sendSemanticSignal} is: the consent scope is a property of
+       * what the event *is*, and an options bag would let the wrong one be passed
+       * by accident. Rejects locally for anything outside
+       * {@link COLLABORATION_EVENT_TYPES}.
+       */
+      async sendCollaborationSignal(mapped) {
+        if (!tool_contract_1.COLLABORATION_EVENT_TYPES.includes(mapped.eventType)) {
+          throw new AscendaSemanticEventError(`"${mapped.eventType}" is not a collaboration event type. Use send() for a deterministic host event.`);
+        }
+        const payload = {
+          toolInstallationId: this.config.toolInstallationId,
+          source: this.config.source,
+          eventType: mapped.eventType,
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+          severity: "low",
+          sessionId: this.config.sessionId ?? void 0,
+          workspaceHash: this.config.workspaceHash ?? void 0,
+          consentScope: tool_contract_1.ASCENDA_COLLABORATION_CONSENT_SCOPE,
+          provenance: tool_contract_1.ASCENDA_PROVENANCE,
+          privacyMode: "metadata_only",
+          metadata: mapped.metadata ?? {}
+        };
+        return this.post(payload);
+      }
+      /**
+       * The single choke point every event passes through, and therefore the only
+       * honest place to journal one. Recording here rather than in each adapter is
+       * deliberate: Claude Code, Codex, the GitHub collector and the MCP server all
+       * send through this method, and the defect being fixed showed up in three
+       * separate components because each was left to notice its own failures.
+       */
+      async post(payload) {
+        const outcome = await this.attempt(payload);
+        this.lastState = (0, stateStore_1.recordSendOutcome)(this.stateFilePath(), this.config.toolInstallationId, outcome.result, {
+          httpStatus: outcome.httpStatus,
+          errorCode: outcome.errorCode,
+          detail: outcome.detail
+        });
+        this.log(payload, outcome.result);
+        return outcome.result;
+      }
+      /**
+       * Two recoveries, each tried once. A rejected token gets a renewal and one
+       * replay — rotation is expected and should heal unattended. A transport
+       * error gets one retry, because the common cases (a restarting instance, a
+       * proxy blip, a 429) clear in well under a second and the alternative is
+       * losing the event outright.
+       */
+      async attempt(payload) {
+        const outcome = await (0, http_1.postToolEvent)(this.config.apiBaseUrl, this.eventWriteToken, payload, this.signal());
+        if (outcome.result === "auth_failed") {
+          if (!await this.renewEventToken())
+            return outcome;
+          return (0, http_1.postToolEvent)(this.config.apiBaseUrl, this.eventWriteToken, payload, this.signal());
+        }
+        if (outcome.result === "transport_error" && (outcome.httpStatus === void 0 || (0, http_1.isRetryableStatus)(outcome.httpStatus))) {
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+          return (0, http_1.postToolEvent)(this.config.apiBaseUrl, this.eventWriteToken, payload, this.signal());
+        }
+        return outcome;
+      }
+      /**
+       * The state written by the most recent send, so a caller can decide whether
+       * to surface a one-time notice without re-reading the journal it just wrote.
+       */
+      get state() {
+        return this.lastState;
+      }
+      stateFilePath() {
+        return this.config.stateFilePath ?? (0, stateStore_1.defaultStateFilePath)(this.config.toolInstallationId);
+      }
+      /** Never throws: a renewal that errors is a failed renewal, not a failed turn. */
+      /**
+       * Every send path funnels through {@link post}, so semantic and
+       * collaboration signals are logged on the same terms as host events — the
+       * log would be misleading as an audit of what left the machine otherwise.
+       *
+       * An unreachable backend used to be logged as `other` from a catch block.
+       * It is now `transport_error` through the ordinary path, because the
+       * transport returns that outcome instead of throwing.
+       */
+      log(payload, delivery) {
+        const logFile = this.config.eventLogFile === void 0 ? (0, eventLog_1.resolveEventLogPath)() : this.config.eventLogFile;
+        if (!logFile)
+          return;
+        (0, eventLog_1.appendEventLog)(logFile, { loggedAt: (/* @__PURE__ */ new Date()).toISOString(), delivery, payload });
+      }
+      async renewEventToken() {
+        try {
+          const renewed = await (0, http_1.renewToolToken)(this.config.apiBaseUrl, this.eventWriteToken, this.signal());
+          if (!renewed)
+            return false;
+          this.eventWriteToken = renewed.eventWriteToken;
+          (0, tokenStore_1.persistEventWriteToken)(this.config.tokenFilePath, renewed.eventWriteToken);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      signal() {
+        return AbortSignal.timeout(this.config.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+      }
+    };
+    exports.AscendaEventSender = AscendaEventSender;
+  }
+});
+
+// ../packages/tool-kit/out/hookAdapter.js
+var require_hookAdapter = __commonJS({
+  "../packages/tool-kit/out/hookAdapter.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_API_BASE_URL = void 0;
+    exports.loadCliAgentConfig = loadCliAgentConfig;
+    exports.deliverHookEvents = deliverHookEvents;
+    var eventLog_1 = require_eventLog();
+    var eventSender_1 = require_eventSender();
+    var tokenStore_1 = require_tokenStore();
+    exports.DEFAULT_API_BASE_URL = "https://api.ascenda.one";
+    function loadCliAgentConfig(toolType, sessionIdFromHook) {
+      const apiBaseUrl = (process.env.ASCENDA_API_BASE_URL ?? exports.DEFAULT_API_BASE_URL).replace(/\/$/, "");
+      const toolInstallationIdRaw = process.env.ASCENDA_TOOL_INSTALLATION_ID;
+      if (!toolInstallationIdRaw)
+        throw new Error("Missing ASCENDA_TOOL_INSTALLATION_ID");
+      const toolInstallationId = toolInstallationIdRaw.trim().includes(":") ? toolInstallationIdRaw.trim() : `${toolType}:${toolInstallationIdRaw.trim()}`;
+      const tokenFilePath = process.env.ASCENDA_EVENT_WRITE_TOKEN_FILE ?? (0, tokenStore_1.defaultTokenFilePath)(toolInstallationId);
+      const fileToken = (0, tokenStore_1.readTokenFile)(tokenFilePath);
+      const eventWriteToken = fileToken ?? process.env.ASCENDA_EVENT_WRITE_TOKEN;
+      if (!eventWriteToken)
+        throw new Error("Missing ASCENDA_EVENT_WRITE_TOKEN (or token file)");
+      if (!fileToken)
+        (0, tokenStore_1.persistEventWriteToken)(tokenFilePath, eventWriteToken);
+      return {
+        apiBaseUrl,
+        toolInstallationId,
+        eventWriteToken,
+        tokenFilePath,
+        sessionId: process.env.ASCENDA_SESSION_ID ?? sessionIdFromHook ?? null,
+        workspaceHash: process.env.ASCENDA_WORKSPACE_HASH ?? null,
+        // Agents await command hooks; fail fast rather than stall the user's turn.
+        timeoutMs: parsePositiveInt(process.env.ASCENDA_HTTP_TIMEOUT_MS) ?? 3e3
+      };
+    }
+    async function deliverHookEvents(events, options) {
+      if (events.length === 0)
+        return;
+      const notice = options.onNotice ?? ((message) => console.error(message));
+      let config;
+      try {
+        config = loadCliAgentConfig(options.toolType, options.sessionId);
+      } catch (error) {
+        const logFile = (0, eventLog_1.resolveEventLogPath)();
+        if (!logFile)
+          throw error;
+        for (const event of events) {
+          (0, eventLog_1.appendEventLog)(logFile, {
+            loggedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            delivery: "not_sent",
+            payload: (0, eventSender_1.buildEventPayload)({
+              toolInstallationId: `${options.toolType}:unpaired`,
+              source: options.source,
+              sessionId: options.sessionId ?? null,
+              workspaceHash: process.env.ASCENDA_WORKSPACE_HASH ?? null
+            }, event)
+          });
+        }
+        return;
+      }
+      const sender = new eventSender_1.AscendaEventSender({
+        apiBaseUrl: config.apiBaseUrl,
+        toolInstallationId: config.toolInstallationId,
+        source: options.source,
+        eventWriteToken: config.eventWriteToken,
+        tokenFilePath: config.tokenFilePath,
+        sessionId: config.sessionId,
+        workspaceHash: config.workspaceHash,
+        timeoutMs: config.timeoutMs
+      });
+      for (const event of events) {
+        const result = await sender.send(event);
+        if (result === "accepted")
+          continue;
+        if (result === "consent_missing") {
+          notice("Ascenda telemetry paused: renew IDE telemetry consent in the Ascenda app.");
+        } else if (result === "auth_failed") {
+          notice("Ascenda telemetry paused: connection revoked or expired. Re-pair via an Ascenda IDE extension or pairing-sim.");
+        } else if (result === "transport_error") {
+          notice("Ascenda telemetry paused: the ingest endpoint could not be reached. Your work is unaffected.");
+        } else {
+          notice(`Ascenda telemetry rejected: ${result}`);
+        }
+        return;
+      }
+    }
+    function parsePositiveInt(value) {
+      const n = Number(value);
+      return Number.isInteger(n) && n > 0 ? n : void 0;
+    }
+  }
+});
+
+// ../packages/tool-kit/out/turnState.js
+var require_turnState = __commonJS({
+  "../packages/tool-kit/out/turnState.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.recordTurnStart = recordTurnStart;
+    exports.consumeTurnDurationMs = consumeTurnDurationMs;
+    var fs9 = __importStar(__require("fs"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    var stateDir = () => process.env.ASCENDA_STATE_DIR ?? path9.join(os3.homedir(), ".ascenda", "state");
+    function turnFile(agent, sessionId) {
+      return path9.join(stateDir(), `${sanitize(agent)}-turn-${sanitize(sessionId)}`);
+    }
+    function sanitize(value) {
+      return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+    }
+    function recordTurnStart(agent, sessionId, now = Date.now()) {
+      if (!sessionId)
+        return;
+      try {
+        fs9.mkdirSync(stateDir(), { recursive: true });
+        fs9.writeFileSync(turnFile(agent, sessionId), String(now), { encoding: "utf8", mode: 384 });
+      } catch {
+      }
+    }
+    function consumeTurnDurationMs(agent, sessionId, now = Date.now()) {
+      if (!sessionId)
+        return void 0;
+      const file = turnFile(agent, sessionId);
+      try {
+        const started = Number(fs9.readFileSync(file, "utf8").trim());
+        fs9.rmSync(file, { force: true });
+        if (!Number.isFinite(started) || started <= 0 || started > now)
+          return void 0;
+        return now - started;
+      } catch {
+        return void 0;
+      }
+    }
+  }
+});
+
+// ../packages/tool-kit/out/salt.js
+var require_salt = __commonJS({
+  "../packages/tool-kit/out/salt.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.machineSaltFilePath = machineSaltFilePath;
+    exports.readOrCreateMachineSalt = readOrCreateMachineSalt;
+    exports.hashWithMachineSalt = hashWithMachineSalt2;
+    var crypto = __importStar(__require("crypto"));
+    var fs9 = __importStar(__require("fs"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    function machineSaltFilePath() {
+      return path9.join(os3.homedir(), ".ascenda", "salt");
+    }
+    var cache = /* @__PURE__ */ new Map();
+    function readOrCreateMachineSalt(saltFilePath = machineSaltFilePath()) {
+      const hit = cache.get(saltFilePath);
+      if (hit)
+        return hit;
+      const dir = path9.dirname(saltFilePath);
+      fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+      let salt;
+      try {
+        salt = crypto.randomBytes(32).toString("hex");
+        fs9.writeFileSync(saltFilePath, salt, { encoding: "utf8", mode: 384, flag: "wx" });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        salt = fs9.readFileSync(saltFilePath, "utf8").trim();
+      }
+      if (process.platform !== "win32") {
+        fs9.chmodSync(dir, 448);
+        fs9.chmodSync(saltFilePath, 384);
+      }
+      cache.set(saltFilePath, salt);
+      return salt;
+    }
+    function hashWithMachineSalt2(value, saltFilePath) {
+      if (!value)
+        return null;
+      return crypto.createHash("sha256").update(readOrCreateMachineSalt(saltFilePath)).update("\0").update(value).digest("hex").slice(0, 16);
+    }
+  }
+});
+
+// ../packages/tool-kit/out/liveBus.js
+var require_liveBus = __commonJS({
+  "../packages/tool-kit/out/liveBus.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.liveBusSocketCandidates = liveBusSocketCandidates;
+    exports.liveBusSocketPath = liveBusSocketPath;
+    exports.bucketPromptSize = bucketPromptSize;
+    exports.emitLiveSignal = emitLiveSignal;
+    var fs9 = __importStar(__require("fs"));
+    var net = __importStar(__require("net"));
+    var os3 = __importStar(__require("os"));
+    var path9 = __importStar(__require("path"));
+    var WRITE_TIMEOUT_MS = 50;
+    var APP_BUNDLE_ID2 = "one.ascenda.ascendaMissionControl";
+    function liveBusSocketCandidates() {
+      const override = process.env.ASCENDA_LIVE_BUS_SOCKET;
+      if (override)
+        return [override];
+      const home = os3.homedir();
+      return [
+        path9.join(home, ".ascenda", "live.sock"),
+        path9.join(home, "Library", "Containers", APP_BUNDLE_ID2, "Data", ".ascenda", "live.sock")
+      ];
+    }
+    function liveBusSocketPath() {
+      const candidates = liveBusSocketCandidates();
+      for (const candidate of candidates) {
+        try {
+          if (fs9.statSync(candidate).isSocket())
+            return candidate;
+        } catch {
+        }
+      }
+      return candidates[0];
+    }
+    function bucketPromptSize(text) {
+      const length = typeof text === "string" ? text.length : 0;
+      if (length <= 280)
+        return "s";
+      if (length <= 2e3)
+        return "m";
+      if (length <= 8e3)
+        return "l";
+      return "xl";
+    }
+    function emitLiveSignal(signal) {
+      return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled)
+            return;
+          settled = true;
+          try {
+            socket.destroy();
+          } catch {
+          }
+          resolve();
+        };
+        let socket;
+        try {
+          socket = net.createConnection(liveBusSocketPath());
+        } catch {
+          resolve();
+          return;
+        }
+        const timer = setTimeout(done, WRITE_TIMEOUT_MS);
+        if (typeof timer.unref === "function")
+          timer.unref();
+        if (typeof socket.unref === "function")
+          socket.unref();
+        socket.on("error", done);
+        socket.on("connect", () => {
+          try {
+            socket.write(`${JSON.stringify(signal)}
+`, () => {
+              clearTimeout(timer);
+              done();
+            });
+          } catch {
+            clearTimeout(timer);
+            done();
+          }
+        });
+      });
+    }
+  }
+});
+
+// ../packages/tool-kit/out/index.js
+var require_out2 = __commonJS({
+  "../packages/tool-kit/out/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.renewToolToken = exports.getPairingStatus = exports.createPairingSession = exports.AscendaApiError = exports.liveBusSocketCandidates = exports.liveBusSocketPath = exports.bucketPromptSize = exports.emitLiveSignal = exports.hashWithMachineSalt = exports.readOrCreateMachineSalt = exports.machineSaltFilePath = exports.markFailureNotified = exports.shouldAnnounceFailure = exports.recordSendOutcome = exports.readCollectorState = exports.defaultStateFilePath = exports.readTokenFile = exports.persistEventWriteToken = exports.defaultTokenFilePath = exports.recordTurnStart = exports.consumeTurnDurationMs = exports.loadCliAgentConfig = exports.deliverHookEvents = exports.DEFAULT_API_BASE_URL = exports.resolveEventLogPath = exports.expandUserPath = exports.appendEventLog = exports.EVENT_LOG_ENV_VAR = exports.buildEventPayload = exports.AscendaSemanticEventError = exports.AscendaEventSender = exports.looksLikeCorrection = exports.outcomeForHook = exports.inferOutcome = exports.getNestedNumber = exports.getNestedString = exports.getNested = exports.getNumber = exports.getString = exports.localHourAt = exports.utcOffsetMinutesAt = exports.isAfterHours = exports.bucketDurationMs = exports.bucketLinesChanged = exports.invitesDebrief = exports.classifyWorkMilestone = exports.isReworkGitAction = exports.classifyGitAction = exports.isVerificationCommand = exports.classifyCommand = void 0;
+    exports.isRetryableStatus = exports.parseIngestResponse = exports.postToolEventsBatch = exports.postToolEvent = void 0;
+    var commandClassifier_1 = require_commandClassifier();
+    Object.defineProperty(exports, "classifyCommand", { enumerable: true, get: function() {
+      return commandClassifier_1.classifyCommand;
+    } });
+    Object.defineProperty(exports, "isVerificationCommand", { enumerable: true, get: function() {
+      return commandClassifier_1.isVerificationCommand;
+    } });
+    var gitActionClassifier_1 = require_gitActionClassifier();
+    Object.defineProperty(exports, "classifyGitAction", { enumerable: true, get: function() {
+      return gitActionClassifier_1.classifyGitAction;
+    } });
+    Object.defineProperty(exports, "isReworkGitAction", { enumerable: true, get: function() {
+      return gitActionClassifier_1.isReworkGitAction;
+    } });
+    var workMilestoneClassifier_1 = require_workMilestoneClassifier();
+    Object.defineProperty(exports, "classifyWorkMilestone", { enumerable: true, get: function() {
+      return workMilestoneClassifier_1.classifyWorkMilestone;
+    } });
+    Object.defineProperty(exports, "invitesDebrief", { enumerable: true, get: function() {
+      return workMilestoneClassifier_1.invitesDebrief;
+    } });
+    var buckets_1 = require_buckets();
+    Object.defineProperty(exports, "bucketLinesChanged", { enumerable: true, get: function() {
+      return buckets_1.bucketLinesChanged;
+    } });
+    Object.defineProperty(exports, "bucketDurationMs", { enumerable: true, get: function() {
+      return buckets_1.bucketDurationMs;
+    } });
+    var afterHours_1 = require_afterHours();
+    Object.defineProperty(exports, "isAfterHours", { enumerable: true, get: function() {
+      return afterHours_1.isAfterHours;
+    } });
+    Object.defineProperty(exports, "utcOffsetMinutesAt", { enumerable: true, get: function() {
+      return afterHours_1.utcOffsetMinutesAt;
+    } });
+    Object.defineProperty(exports, "localHourAt", { enumerable: true, get: function() {
+      return afterHours_1.localHourAt;
+    } });
+    var payload_1 = require_payload();
+    Object.defineProperty(exports, "getString", { enumerable: true, get: function() {
+      return payload_1.getString;
+    } });
+    Object.defineProperty(exports, "getNumber", { enumerable: true, get: function() {
+      return payload_1.getNumber;
+    } });
+    Object.defineProperty(exports, "getNested", { enumerable: true, get: function() {
+      return payload_1.getNested;
+    } });
+    Object.defineProperty(exports, "getNestedString", { enumerable: true, get: function() {
+      return payload_1.getNestedString;
+    } });
+    Object.defineProperty(exports, "getNestedNumber", { enumerable: true, get: function() {
+      return payload_1.getNestedNumber;
+    } });
+    Object.defineProperty(exports, "inferOutcome", { enumerable: true, get: function() {
+      return payload_1.inferOutcome;
+    } });
+    Object.defineProperty(exports, "outcomeForHook", { enumerable: true, get: function() {
+      return payload_1.outcomeForHook;
+    } });
+    Object.defineProperty(exports, "looksLikeCorrection", { enumerable: true, get: function() {
+      return payload_1.looksLikeCorrection;
+    } });
+    var eventSender_1 = require_eventSender();
+    Object.defineProperty(exports, "AscendaEventSender", { enumerable: true, get: function() {
+      return eventSender_1.AscendaEventSender;
+    } });
+    Object.defineProperty(exports, "AscendaSemanticEventError", { enumerable: true, get: function() {
+      return eventSender_1.AscendaSemanticEventError;
+    } });
+    Object.defineProperty(exports, "buildEventPayload", { enumerable: true, get: function() {
+      return eventSender_1.buildEventPayload;
+    } });
+    var eventLog_1 = require_eventLog();
+    Object.defineProperty(exports, "EVENT_LOG_ENV_VAR", { enumerable: true, get: function() {
+      return eventLog_1.EVENT_LOG_ENV_VAR;
+    } });
+    Object.defineProperty(exports, "appendEventLog", { enumerable: true, get: function() {
+      return eventLog_1.appendEventLog;
+    } });
+    Object.defineProperty(exports, "expandUserPath", { enumerable: true, get: function() {
+      return eventLog_1.expandUserPath;
+    } });
+    Object.defineProperty(exports, "resolveEventLogPath", { enumerable: true, get: function() {
+      return eventLog_1.resolveEventLogPath;
+    } });
+    var hookAdapter_1 = require_hookAdapter();
+    Object.defineProperty(exports, "DEFAULT_API_BASE_URL", { enumerable: true, get: function() {
+      return hookAdapter_1.DEFAULT_API_BASE_URL;
+    } });
+    Object.defineProperty(exports, "deliverHookEvents", { enumerable: true, get: function() {
+      return hookAdapter_1.deliverHookEvents;
+    } });
+    Object.defineProperty(exports, "loadCliAgentConfig", { enumerable: true, get: function() {
+      return hookAdapter_1.loadCliAgentConfig;
+    } });
+    var turnState_1 = require_turnState();
+    Object.defineProperty(exports, "consumeTurnDurationMs", { enumerable: true, get: function() {
+      return turnState_1.consumeTurnDurationMs;
+    } });
+    Object.defineProperty(exports, "recordTurnStart", { enumerable: true, get: function() {
+      return turnState_1.recordTurnStart;
+    } });
+    var tokenStore_1 = require_tokenStore();
+    Object.defineProperty(exports, "defaultTokenFilePath", { enumerable: true, get: function() {
+      return tokenStore_1.defaultTokenFilePath;
+    } });
+    Object.defineProperty(exports, "persistEventWriteToken", { enumerable: true, get: function() {
+      return tokenStore_1.persistEventWriteToken;
+    } });
+    Object.defineProperty(exports, "readTokenFile", { enumerable: true, get: function() {
+      return tokenStore_1.readTokenFile;
+    } });
+    var stateStore_1 = require_stateStore();
+    Object.defineProperty(exports, "defaultStateFilePath", { enumerable: true, get: function() {
+      return stateStore_1.defaultStateFilePath;
+    } });
+    Object.defineProperty(exports, "readCollectorState", { enumerable: true, get: function() {
+      return stateStore_1.readCollectorState;
+    } });
+    Object.defineProperty(exports, "recordSendOutcome", { enumerable: true, get: function() {
+      return stateStore_1.recordSendOutcome;
+    } });
+    Object.defineProperty(exports, "shouldAnnounceFailure", { enumerable: true, get: function() {
+      return stateStore_1.shouldAnnounceFailure;
+    } });
+    Object.defineProperty(exports, "markFailureNotified", { enumerable: true, get: function() {
+      return stateStore_1.markFailureNotified;
+    } });
+    var salt_1 = require_salt();
+    Object.defineProperty(exports, "machineSaltFilePath", { enumerable: true, get: function() {
+      return salt_1.machineSaltFilePath;
+    } });
+    Object.defineProperty(exports, "readOrCreateMachineSalt", { enumerable: true, get: function() {
+      return salt_1.readOrCreateMachineSalt;
+    } });
+    Object.defineProperty(exports, "hashWithMachineSalt", { enumerable: true, get: function() {
+      return salt_1.hashWithMachineSalt;
+    } });
+    var liveBus_1 = require_liveBus();
+    Object.defineProperty(exports, "emitLiveSignal", { enumerable: true, get: function() {
+      return liveBus_1.emitLiveSignal;
+    } });
+    Object.defineProperty(exports, "bucketPromptSize", { enumerable: true, get: function() {
+      return liveBus_1.bucketPromptSize;
+    } });
+    Object.defineProperty(exports, "liveBusSocketPath", { enumerable: true, get: function() {
+      return liveBus_1.liveBusSocketPath;
+    } });
+    Object.defineProperty(exports, "liveBusSocketCandidates", { enumerable: true, get: function() {
+      return liveBus_1.liveBusSocketCandidates;
+    } });
+    var http_1 = require_http();
+    Object.defineProperty(exports, "AscendaApiError", { enumerable: true, get: function() {
+      return http_1.AscendaApiError;
+    } });
+    Object.defineProperty(exports, "createPairingSession", { enumerable: true, get: function() {
+      return http_1.createPairingSession;
+    } });
+    Object.defineProperty(exports, "getPairingStatus", { enumerable: true, get: function() {
+      return http_1.getPairingStatus;
+    } });
+    Object.defineProperty(exports, "renewToolToken", { enumerable: true, get: function() {
+      return http_1.renewToolToken;
+    } });
+    Object.defineProperty(exports, "postToolEvent", { enumerable: true, get: function() {
+      return http_1.postToolEvent;
+    } });
+    Object.defineProperty(exports, "postToolEventsBatch", { enumerable: true, get: function() {
+      return http_1.postToolEventsBatch;
+    } });
+    Object.defineProperty(exports, "parseIngestResponse", { enumerable: true, get: function() {
+      return http_1.parseIngestResponse;
+    } });
+    Object.defineProperty(exports, "isRetryableStatus", { enumerable: true, get: function() {
+      return http_1.isRetryableStatus;
+    } });
+  }
+});
+
+// src/cli.ts
+import * as fs8 from "node:fs/promises";
+import * as path8 from "node:path";
+
+// src/stores.ts
+import * as os from "node:os";
+import * as path from "node:path";
+function resolveStorePaths(home = os.homedir()) {
+  const appSupport = path.join(home, "Library", "Application Support");
+  return {
+    home,
+    claudeRoot: path.join(home, ".claude"),
+    claudeProjects: path.join(home, ".claude", "projects"),
+    claudeSettings: path.join(home, ".claude", "settings.json"),
+    cursorStateDb: path.join(appSupport, "Cursor", "User", "globalStorage", "state.vscdb"),
+    cursorSearchDb: path.join(
+      appSupport,
+      "Cursor",
+      "User",
+      "globalStorage",
+      "conversation-search.db"
+    ),
+    vscodeHistory: path.join(appSupport, "Code", "User", "History"),
+    vscodeWorkspaceStorage: path.join(appSupport, "Code", "User", "workspaceStorage"),
+    devRoot: path.join(home, "Dev"),
+    zshHistory: path.join(home, ".zsh_history")
+  };
+}
+
+// src/scan.ts
+import * as fs from "node:fs/promises";
+import * as path2 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function statOrNull(p) {
+  try {
+    return await fs.stat(p);
+  } catch {
+    return null;
+  }
+}
+var Window = class {
+  oldest = null;
+  newest = null;
+  see(d) {
+    if (!this.oldest || d < this.oldest) this.oldest = d;
+    if (!this.newest || d > this.newest) this.newest = d;
+  }
+};
+async function scanClaudeCode(paths) {
+  const inv = {
+    store: "claude_code",
+    rootPath: paths.claudeProjects,
+    present: false,
+    counts: {},
+    notes: []
+  };
+  const root = await statOrNull(paths.claudeProjects);
+  if (!root) return inv;
+  inv.present = true;
+  const window = new Window();
+  let transcripts = 0;
+  let bytes = 0;
+  const projects = await fs.readdir(paths.claudeProjects, { withFileTypes: true });
+  for (const project of projects) {
+    if (!project.isDirectory()) continue;
+    const dir = path2.join(paths.claudeProjects, project.name);
+    for (const entry of await fs.readdir(dir)) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const st = await statOrNull(path2.join(dir, entry));
+      if (!st) continue;
+      transcripts += 1;
+      bytes += st.size;
+      window.see(st.mtime);
+    }
+  }
+  inv.counts = { projects: projects.length, transcripts, bytes };
+  inv.oldest = window.oldest?.toISOString();
+  inv.newest = window.newest?.toISOString();
+  let cleanupPeriodDays = null;
+  try {
+    const settings = JSON.parse(await fs.readFile(paths.claudeSettings, "utf8"));
+    if (typeof settings.cleanupPeriodDays === "number") {
+      cleanupPeriodDays = settings.cleanupPeriodDays;
+    }
+  } catch {
+  }
+  if (cleanupPeriodDays === null || cleanupPeriodDays <= 30) {
+    inv.retentionRisk = `rolling purge active (cleanupPeriodDays: ${cleanupPeriodDays ?? "30 by default"}) \u2014 the oldest transcript is deleted daily`;
+  }
+  return inv;
+}
+async function scanCursor(paths) {
+  const inv = {
+    store: "cursor",
+    rootPath: paths.cursorStateDb,
+    present: false,
+    counts: {},
+    notes: []
+  };
+  const st = await statOrNull(paths.cursorStateDb);
+  if (!st) return inv;
+  inv.present = true;
+  inv.counts = { bytes: st.size };
+  inv.newest = st.mtime.toISOString();
+  try {
+    const uri = `file:${paths.cursorStateDb}?mode=ro&immutable=1`;
+    const { stdout } = await execFileAsync("sqlite3", [
+      uri,
+      "SELECT (SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'composerData:%'), (SELECT count(*) FROM cursorDiskKV WHERE key LIKE 'bubbleId:%');"
+    ]);
+    const [conversations, bubbles] = stdout.trim().split("|").map(Number);
+    if (Number.isFinite(conversations)) inv.counts.conversations = conversations;
+    if (Number.isFinite(bubbles)) inv.counts.bubbles = bubbles;
+  } catch (error) {
+    inv.notes.push(
+      `row counts unavailable (${error instanceof Error ? error.message.split("\n")[0] : "sqlite3 failed"}); file-level facts only`
+    );
+  }
+  return inv;
+}
+async function scanVsCode(paths) {
+  const inv = {
+    store: "vscode",
+    rootPath: paths.vscodeHistory,
+    present: false,
+    counts: {},
+    notes: []
+  };
+  const root = await statOrNull(paths.vscodeHistory);
+  if (root) {
+    inv.present = true;
+    const window = new Window();
+    let fileHistories = 0;
+    for (const entry of await fs.readdir(paths.vscodeHistory, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      fileHistories += 1;
+      const st = await statOrNull(path2.join(paths.vscodeHistory, entry.name));
+      if (st) window.see(st.mtime);
+    }
+    inv.counts.fileHistories = fileHistories;
+    inv.oldest = window.oldest?.toISOString();
+    inv.newest = window.newest?.toISOString();
+  }
+  let chatSessions = 0;
+  const wsRoot = await statOrNull(paths.vscodeWorkspaceStorage);
+  if (wsRoot) {
+    inv.present = true;
+    for (const ws of await fs.readdir(paths.vscodeWorkspaceStorage, { withFileTypes: true })) {
+      if (!ws.isDirectory()) continue;
+      const sessions = path2.join(paths.vscodeWorkspaceStorage, ws.name, "chatSessions");
+      try {
+        chatSessions += (await fs.readdir(sessions)).filter((f) => f.endsWith(".json")).length;
+      } catch {
+      }
+    }
+  }
+  inv.counts.chatSessions = chatSessions;
+  return inv;
+}
+async function scanGit(paths) {
+  const inv = {
+    store: "git",
+    rootPath: paths.devRoot,
+    present: false,
+    counts: {},
+    notes: ["the only fully durable, fully supported source \u2014 the spine other stores hang off"]
+  };
+  const root = await statOrNull(paths.devRoot);
+  if (!root) return inv;
+  inv.present = true;
+  let repos = 0;
+  const level1 = await fs.readdir(paths.devRoot, { withFileTypes: true });
+  for (const entry of level1) {
+    if (!entry.isDirectory()) continue;
+    const dir = path2.join(paths.devRoot, entry.name);
+    if (await statOrNull(path2.join(dir, ".git"))) {
+      repos += 1;
+      continue;
+    }
+    let nested = [];
+    try {
+      nested = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const sub of nested) {
+      if (!sub.isDirectory()) continue;
+      if (await statOrNull(path2.join(dir, sub.name, ".git"))) repos += 1;
+    }
+  }
+  inv.counts.repos = repos;
+  return inv;
+}
+async function scanAll(paths) {
+  return [
+    await scanClaudeCode(paths),
+    await scanCursor(paths),
+    await scanVsCode(paths),
+    await scanGit(paths)
+  ];
+}
+
+// src/retention.ts
+import * as fs2 from "node:fs/promises";
+var PROPOSED_CLEANUP_PERIOD_DAYS = 3650;
+async function planClaudeRetentionFix(paths) {
+  let current = null;
+  try {
+    const settings = JSON.parse(await fs2.readFile(paths.claudeSettings, "utf8"));
+    if (typeof settings.cleanupPeriodDays === "number") current = settings.cleanupPeriodDays;
+  } catch {
+  }
+  return {
+    settingsPath: paths.claudeSettings,
+    currentCleanupPeriodDays: current,
+    proposedCleanupPeriodDays: PROPOSED_CLEANUP_PERIOD_DAYS,
+    changeNeeded: current === null || current < PROPOSED_CLEANUP_PERIOD_DAYS
+  };
+}
+async function applyClaudeRetentionFix(plan) {
+  if (!plan.changeNeeded) return;
+  let settings = {};
+  let raw = null;
+  try {
+    raw = await fs2.readFile(plan.settingsPath, "utf8");
+  } catch {
+  }
+  if (raw !== null) {
+    try {
+      settings = JSON.parse(raw);
+    } catch {
+      throw new Error(
+        `${plan.settingsPath} exists but is not valid JSON \u2014 refusing to overwrite it`
+      );
+    }
+  }
+  settings.cleanupPeriodDays = plan.proposedCleanupPeriodDays;
+  await fs2.writeFile(plan.settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+
+// src/staging.ts
+import * as fs3 from "node:fs/promises";
+import { constants } from "node:fs";
+import * as path3 from "node:path";
+import { randomUUID } from "node:crypto";
+var CLONE = constants.COPYFILE_FICLONE;
+function defaultStagingRoot(home) {
+  return path3.join(home, ".ascenda", "history-import", "staging");
+}
+async function createStagingArea(stagingRoot) {
+  const extractionId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+  const root = path3.join(stagingRoot, extractionId);
+  await fs3.mkdir(root, { recursive: true });
+  return { extractionId, root };
+}
+async function snapshotPath(area, sourcePath, label) {
+  const dest = path3.join(area.root, label);
+  await fs3.mkdir(path3.dirname(dest), { recursive: true });
+  const st = await fs3.stat(sourcePath);
+  if (st.isDirectory()) {
+    await fs3.cp(sourcePath, dest, {
+      recursive: true,
+      errorOnExist: false,
+      force: true,
+      mode: CLONE
+    });
+  } else {
+    await fs3.copyFile(sourcePath, dest, CLONE);
+    for (const suffix of ["-wal", "-shm"]) {
+      try {
+        await fs3.copyFile(sourcePath + suffix, dest + suffix, CLONE);
+      } catch {
+      }
+    }
+  }
+  return dest;
+}
+async function snapshotVsCodeWorkspaceStorage(area, sourceRoot, label) {
+  const dest = path3.join(area.root, label);
+  await fs3.mkdir(dest, { recursive: true });
+  let hashDirs = [];
+  try {
+    hashDirs = (await fs3.readdir(sourceRoot, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return dest;
+  }
+  for (const hash of hashDirs) {
+    const destHashDir = path3.join(dest, hash);
+    const workspaceJson = path3.join(sourceRoot, hash, "workspace.json");
+    try {
+      await fs3.mkdir(destHashDir, { recursive: true });
+      await fs3.copyFile(workspaceJson, path3.join(destHashDir, "workspace.json"), CLONE);
+    } catch {
+    }
+    const chatSessionsDir = path3.join(sourceRoot, hash, "chatSessions");
+    let sessionFiles = [];
+    try {
+      sessionFiles = (await fs3.readdir(chatSessionsDir)).filter(
+        (f) => f.endsWith(".json") || f.endsWith(".jsonl")
+      );
+    } catch {
+      continue;
+    }
+    if (sessionFiles.length === 0) continue;
+    const destSessionsDir = path3.join(destHashDir, "chatSessions");
+    await fs3.mkdir(destSessionsDir, { recursive: true });
+    for (const file of sessionFiles) {
+      await fs3.copyFile(path3.join(chatSessionsDir, file), path3.join(destSessionsDir, file), CLONE);
+    }
+  }
+  return dest;
+}
+
+// src/extractors/claudeCode.ts
+var import_tool_kit = __toESM(require_out2(), 1);
+import * as fs4 from "node:fs/promises";
+import * as path4 from "node:path";
+
+// src/types.ts
+var import_tool_contract = __toESM(require_out(), 1);
+var STORE_SOURCE = {
+  claude_code: "claude_code",
+  cursor: "cursor_mcp",
+  vscode: "vscode_extension",
+  git: "code_forge"
+};
+var HISTORICAL_PROVENANCE = {
+  direct: "historical_direct",
+  derived: "historical_derived",
+  unparsed: "historical_unparsed"
+};
+var HISTORICAL_CONSENT_SCOPE = import_tool_contract.ASCENDA_HISTORICAL_CONSENT_SCOPE;
+var EXTRACTION_EPOCH_KIND = "extraction_epoch";
+
+// src/daySlice.ts
+var LOCAL_TIMEZONE = Intl.DateTimeFormat().resolvedOptions().timeZone ?? null;
+function localDayKey(t) {
+  const y = t.getFullYear();
+  const m = String(t.getMonth() + 1).padStart(2, "0");
+  const d = String(t.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function nextLocalMidnight(t) {
+  return new Date(t.getFullYear(), t.getMonth(), t.getDate() + 1, 0, 0, 0, 0);
+}
+function addSpan(into, from, to) {
+  let cursor = from;
+  while (cursor < to) {
+    const boundary = nextLocalMidnight(cursor);
+    const segmentEnd = boundary < to ? boundary : to;
+    const key = localDayKey(cursor);
+    into.set(key, (into.get(key) ?? 0) + (segmentEnd.getTime() - cursor.getTime()));
+    cursor = segmentEnd;
+  }
+}
+function sliceSessionByLocalDay(timestamps, options = {}) {
+  const instants = timestamps.filter((t) => typeof t === "string" && t.length > 0).map((t) => new Date(t)).filter((d) => Number.isFinite(d.getTime())).sort((a, b) => a.getTime() - b.getTime());
+  if (instants.length === 0) return [];
+  const prompts = /* @__PURE__ */ new Map();
+  for (const t of instants) {
+    const key = localDayKey(t);
+    prompts.set(key, (prompts.get(key) ?? 0) + 1);
+  }
+  const activeMs = /* @__PURE__ */ new Map();
+  const gapMs = options.activeGapMs;
+  if (gapMs !== void 0) {
+    for (let i = 1; i < instants.length; i += 1) {
+      const gap = instants[i].getTime() - instants[i - 1].getTime();
+      if (gap > 0 && gap <= gapMs) addSpan(activeMs, instants[i - 1], instants[i]);
+    }
+  }
+  const days = [.../* @__PURE__ */ new Set([...prompts.keys(), ...activeMs.keys()])].sort();
+  return days.map((day) => {
+    const slice = { day, prompts: prompts.get(day) ?? 0 };
+    if (gapMs !== void 0) {
+      slice.activeMinutes = Math.round((activeMs.get(day) ?? 0) / 6e4);
+    }
+    return slice;
+  });
+}
+
+// src/extractors/claudeCode.ts
+var KNOWN_CLAUDE_LINE_TYPES = [
+  "user",
+  "assistant",
+  "attachment",
+  "system",
+  "queue-operation",
+  "last-prompt",
+  "custom-title"
+];
+function sniffClaudeLine(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") return { kind: "unparsed", raw: line };
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { kind: "unparsed", raw: line };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { kind: "unparsed", raw: line };
+  }
+  const record = parsed;
+  const type = record.type;
+  if (typeof type !== "string") return { kind: "unparsed", raw: line };
+  if (!KNOWN_CLAUDE_LINE_TYPES.includes(type)) {
+    return { kind: "unknown", type };
+  }
+  const message = record.message;
+  return {
+    kind: type,
+    sourceVersion: typeof record.version === "string" ? record.version : null,
+    occurredAt: typeof record.timestamp === "string" ? record.timestamp : null,
+    sessionId: typeof record.sessionId === "string" ? record.sessionId : null,
+    model: message && typeof message.model === "string" ? message.model : null
+  };
+}
+function isToolResultUserLine(record) {
+  if ("toolUseResult" in record) return true;
+  const message = record.message;
+  const content = message?.content;
+  if (Array.isArray(content)) {
+    return content.some(
+      (item) => typeof item === "object" && item !== null && item.type === "tool_result"
+    );
+  }
+  return false;
+}
+function isToolFailureLine(record) {
+  const message = record.message;
+  const content = message?.content;
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (item) => typeof item === "object" && item !== null && item.type === "tool_result" && item.is_error === true
+  );
+}
+function countChangedLines(structuredPatch) {
+  let count = 0;
+  for (const hunk of structuredPatch) {
+    if (typeof hunk !== "object" || hunk === null) continue;
+    const lines = hunk.lines;
+    if (!Array.isArray(lines)) continue;
+    for (const l of lines) {
+      if (typeof l === "string" && (l.startsWith("+") || l.startsWith("-"))) count += 1;
+    }
+  }
+  return count;
+}
+function isAbandonedPromptRemoval(content) {
+  return typeof content === "string" && content.length > 0 && !content.startsWith("<task-notification>");
+}
+function newFold(sessionId, projectSlug) {
+  return {
+    sessionId,
+    projectSlug,
+    cwd: null,
+    gitBranch: null,
+    sourceVersion: null,
+    firstTs: null,
+    lastTs: null,
+    humanPrompts: 0,
+    afterHoursPrompts: 0,
+    assistantTurns: 0,
+    toolResults: 0,
+    queuedPrompts: 0,
+    unknownLines: 0,
+    unparsedLines: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    models: /* @__PURE__ */ new Map(),
+    lastMainModel: null,
+    modelSwitchCount: 0,
+    compactionCount: 0,
+    compactionManualCount: 0,
+    compactionAutoCount: 0,
+    toolResultErrorCount: 0,
+    apiErrorCount: 0,
+    contextWindowPeakTokens: 0,
+    userModifiedEditCount: 0,
+    linesChangedTotal: 0,
+    abandonedPromptCount: 0,
+    subagentTranscripts: 0,
+    subagentPrompts: 0,
+    subagentAssistantTurns: 0,
+    subagentTokensTotal: 0,
+    timelinePoints: [],
+    humanPromptTimestamps: []
+  };
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function sessionDurationMs(fold) {
+  if (!fold.firstTs || !fold.lastTs) return null;
+  const ms = Date.parse(fold.lastTs) - Date.parse(fold.firstTs);
+  return Number.isFinite(ms) && ms >= 0 ? ms : null;
+}
+function durationBucketOf(fold) {
+  const ms = sessionDurationMs(fold);
+  if (ms === null) return "unknown";
+  return (0, import_tool_kit.bucketDurationMs)(ms) ?? "unknown";
+}
+var ACTIVE_GAP_MS = 5 * 6e4;
+function activeMinutesOf(fold) {
+  if (fold.timelinePoints.length < 2) return 0;
+  const sorted = [...fold.timelinePoints].sort((a, b) => a - b);
+  let activeMs = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1];
+    if (gap > 0 && gap <= ACTIVE_GAP_MS) activeMs += gap;
+  }
+  return Math.round(activeMs / 6e4);
+}
+var RAPID_REPROMPT_MS = 2 * 6e4;
+function rapidRepromptCountOf(fold) {
+  const timestamps = fold.humanPromptTimestamps.filter((t) => t !== null);
+  let count = 0;
+  for (let i = 1; i < timestamps.length; i++) {
+    const gap = Date.parse(timestamps[i]) - Date.parse(timestamps[i - 1]);
+    if (Number.isFinite(gap) && gap >= 0 && gap < RAPID_REPROMPT_MS) count += 1;
+  }
+  return count;
+}
+var ASSUMED_CONTEXT_WINDOW_TOKENS = 2e5;
+function contextWindowPeakPctOf(fold) {
+  if (fold.contextWindowPeakTokens <= 0) return 0;
+  const pct = fold.contextWindowPeakTokens / ASSUMED_CONTEXT_WINDOW_TOKENS;
+  return Math.round(Math.min(1, pct) * 1e3) / 1e3;
+}
+async function foldLinesInto(fold, filePath, opts) {
+  const handle = await fs4.open(filePath);
+  try {
+    for await (const line of handle.readLines({ encoding: "utf8" })) {
+      const sniffed = sniffClaudeLine(line);
+      if (sniffed.kind === "unparsed") {
+        if (line.trim() !== "") fold.unparsedLines += 1;
+        continue;
+      }
+      if (sniffed.kind === "unknown") {
+        fold.unknownLines += 1;
+        continue;
+      }
+      if (!opts.isSidechain && sniffed.sessionId && fold.sessionId !== sniffed.sessionId) {
+        fold.sessionId = sniffed.sessionId;
+      }
+      if (sniffed.sourceVersion) fold.sourceVersion = sniffed.sourceVersion;
+      if (sniffed.occurredAt) {
+        if (!fold.firstTs || sniffed.occurredAt < fold.firstTs) fold.firstTs = sniffed.occurredAt;
+        if (!fold.lastTs || sniffed.occurredAt > fold.lastTs) fold.lastTs = sniffed.occurredAt;
+        const ms = Date.parse(sniffed.occurredAt);
+        if (Number.isFinite(ms)) fold.timelinePoints.push(ms);
+      }
+      switch (sniffed.kind) {
+        case "user": {
+          const record = JSON.parse(line);
+          if (typeof record.cwd === "string" && !fold.cwd) fold.cwd = record.cwd;
+          if (typeof record.gitBranch === "string" && !fold.gitBranch) {
+            fold.gitBranch = record.gitBranch;
+          }
+          if (isToolFailureLine(record)) fold.toolResultErrorCount += 1;
+          if (isToolResultUserLine(record)) {
+            fold.toolResults += 1;
+            const tur = record.toolUseResult;
+            if (tur && typeof tur === "object" && !Array.isArray(tur)) {
+              const turRecord = tur;
+              if (turRecord.userModified === true) fold.userModifiedEditCount += 1;
+              if (Array.isArray(turRecord.structuredPatch)) {
+                fold.linesChangedTotal += countChangedLines(turRecord.structuredPatch);
+              }
+            }
+          } else if (opts.isSidechain) {
+            fold.subagentPrompts += 1;
+          } else {
+            fold.humanPrompts += 1;
+            if (sniffed.occurredAt && (0, import_tool_kit.isAfterHours)(new Date(sniffed.occurredAt))) {
+              fold.afterHoursPrompts += 1;
+            }
+            fold.humanPromptTimestamps.push(sniffed.occurredAt);
+          }
+          break;
+        }
+        case "assistant": {
+          const record = JSON.parse(line);
+          const usage = record.message?.usage;
+          if (opts.isSidechain) {
+            fold.subagentAssistantTurns += 1;
+            if (usage) {
+              fold.subagentTokensTotal += asNumber(usage.input_tokens) + asNumber(usage.output_tokens) + asNumber(usage.cache_read_input_tokens);
+            }
+            break;
+          }
+          fold.assistantTurns += 1;
+          if (sniffed.model) {
+            fold.models.set(sniffed.model, (fold.models.get(sniffed.model) ?? 0) + 1);
+            if (fold.lastMainModel && fold.lastMainModel !== sniffed.model) {
+              fold.modelSwitchCount += 1;
+            }
+            fold.lastMainModel = sniffed.model;
+          }
+          if (usage) {
+            fold.inputTokens += asNumber(usage.input_tokens);
+            fold.outputTokens += asNumber(usage.output_tokens);
+            fold.cacheReadTokens += asNumber(usage.cache_read_input_tokens);
+            const contextTokens = asNumber(usage.input_tokens) + asNumber(usage.cache_read_input_tokens) + asNumber(usage.cache_creation_input_tokens);
+            if (contextTokens > fold.contextWindowPeakTokens) fold.contextWindowPeakTokens = contextTokens;
+          }
+          break;
+        }
+        case "system": {
+          const record = JSON.parse(line);
+          if (record.subtype === "compact_boundary") {
+            fold.compactionCount += 1;
+            const trigger = record.compactMetadata?.trigger;
+            if (trigger === "manual") fold.compactionManualCount += 1;
+            else if (trigger === "auto") fold.compactionAutoCount += 1;
+          } else if (record.subtype === "api_error") {
+            fold.apiErrorCount += 1;
+          }
+          break;
+        }
+        case "queue-operation": {
+          const record = JSON.parse(line);
+          if (record.operation === "enqueue") {
+            fold.queuedPrompts += 1;
+          } else if (record.operation === "remove" && isAbandonedPromptRemoval(record.content)) {
+            fold.abandonedPromptCount += 1;
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+  } finally {
+    await handle.close();
+  }
+}
+async function foldTranscript(filePath, projectSlug) {
+  const fold = newFold(path4.basename(filePath, ".jsonl"), projectSlug);
+  await foldLinesInto(fold, filePath, { isSidechain: false });
+  return fold;
+}
+async function walkJsonlFiles(root) {
+  const out = [];
+  let otherFiles = 0;
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs4.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+      const full = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        out.push(full);
+      } else if (entry.isFile()) {
+        otherFiles += 1;
+      }
+    }
+  }
+  await walk(root);
+  return { files: out, otherFiles };
+}
+function topModel(models) {
+  let best = null;
+  let bestCount = 0;
+  for (const [model, count] of models) {
+    if (count > bestCount) {
+      best = model;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+async function* extractClaudeCode(snapshotDir, extractionId) {
+  const projectsDir = path4.join(snapshotDir, "projects");
+  let projectSlugs = [];
+  try {
+    projectSlugs = (await fs4.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return;
+  }
+  let windowOldest = null;
+  let windowNewest = null;
+  let sessionCount = 0;
+  let projectsWithNoReadableTranscript = 0;
+  for (const slug of projectSlugs.sort()) {
+    const dir = path4.join(projectsDir, slug);
+    let entries;
+    try {
+      entries = await fs4.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const topLevelFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => e.name).sort();
+    let slugJsonlFiles = topLevelFiles.length;
+    let slugOtherFiles = entries.filter((e) => e.isFile() && !e.name.endsWith(".jsonl")).length;
+    const sessionDirNames = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+    const foldsByKey = /* @__PURE__ */ new Map();
+    for (const name of topLevelFiles) {
+      const fold = await foldTranscript(path4.join(dir, name), slug);
+      foldsByKey.set(path4.basename(name, ".jsonl"), fold);
+    }
+    for (const sessionDirName of sessionDirNames) {
+      const nested = await walkJsonlFiles(path4.join(dir, sessionDirName));
+      const nestedFiles = nested.files;
+      slugJsonlFiles += nestedFiles.length;
+      slugOtherFiles += nested.otherFiles;
+      if (nestedFiles.length === 0) continue;
+      let fold = foldsByKey.get(sessionDirName);
+      if (!fold) {
+        fold = newFold(sessionDirName, slug);
+        foldsByKey.set(sessionDirName, fold);
+      }
+      for (const nestedPath of nestedFiles) {
+        fold.subagentTranscripts += 1;
+        await foldLinesInto(fold, nestedPath, { isSidechain: true });
+      }
+    }
+    if (slugJsonlFiles === 0 && slugOtherFiles > 0) projectsWithNoReadableTranscript += 1;
+    for (const fold of foldsByKey.values()) {
+      if (!fold.firstTs || !fold.lastTs) continue;
+      sessionCount += 1;
+      if (!windowOldest || fold.firstTs < windowOldest) windowOldest = fold.firstTs;
+      if (!windowNewest || fold.lastTs > windowNewest) windowNewest = fold.lastTs;
+      for (const ts of fold.humanPromptTimestamps) {
+        if (!ts) continue;
+        yield {
+          occurredAt: ts,
+          store: "claude_code",
+          sourceVersion: fold.sourceVersion,
+          sessionRef: fold.sessionId,
+          repoRef: fold.cwd ?? fold.projectSlug,
+          eventKind: "ai_prompt_submitted",
+          metrics: {},
+          provenance: HISTORICAL_PROVENANCE.direct,
+          extractionId
+        };
+      }
+      const durationMs = sessionDurationMs(fold);
+      const toolFailureCount = fold.toolResultErrorCount + fold.apiErrorCount;
+      const sessionMetrics = {
+        promptCount: fold.humanPrompts,
+        assistantTurns: fold.assistantTurns,
+        toolResultCount: fold.toolResults,
+        queuedPrompts: fold.queuedPrompts,
+        inputTokens: fold.inputTokens,
+        outputTokens: fold.outputTokens,
+        cacheReadTokens: fold.cacheReadTokens,
+        durationBucket: durationBucketOf(fold),
+        afterHoursPrompts: fold.afterHoursPrompts,
+        unknownLines: fold.unknownLines,
+        unparsedLines: fold.unparsedLines,
+        modelCount: fold.models.size,
+        modelSwitchCount: fold.modelSwitchCount,
+        compactionCount: fold.compactionCount,
+        compactionManualCount: fold.compactionManualCount,
+        compactionAutoCount: fold.compactionAutoCount,
+        toolResultErrorCount: fold.toolResultErrorCount,
+        apiErrorCount: fold.apiErrorCount,
+        toolFailureCount,
+        contextWindowPeakTokens: fold.contextWindowPeakTokens,
+        contextWindowPeakPct: contextWindowPeakPctOf(fold),
+        userModifiedEditCount: fold.userModifiedEditCount,
+        linesChanged: fold.linesChangedTotal,
+        linesChangedBucket: (0, import_tool_kit.bucketLinesChanged)(fold.linesChangedTotal),
+        rapidRepromptCount: rapidRepromptCountOf(fold),
+        abandonedPromptCount: fold.abandonedPromptCount,
+        activeMinutes: activeMinutesOf(fold),
+        subagentTranscripts: fold.subagentTranscripts,
+        subagentPrompts: fold.subagentPrompts,
+        subagentAssistantTurns: fold.subagentAssistantTurns,
+        subagentTokensTotal: fold.subagentTokensTotal
+      };
+      if (durationMs !== null) sessionMetrics.sessionMinutes = Math.round(durationMs / 6e4);
+      sessionMetrics.sessionStartedAt = fold.firstTs;
+      const primaryModel = topModel(fold.models);
+      if (primaryModel) sessionMetrics.primaryModel = primaryModel;
+      if (fold.gitBranch) sessionMetrics.gitBranch = fold.gitBranch;
+      yield {
+        occurredAt: fold.lastTs,
+        store: "claude_code",
+        sourceVersion: fold.sourceVersion,
+        sessionRef: fold.sessionId,
+        repoRef: fold.cwd ?? fold.projectSlug,
+        eventKind: "create_focus_session",
+        metrics: sessionMetrics,
+        // Same gap threshold the session-level activeMinutes uses, passed in
+        // rather than redeclared: two definitions of "active" would drift.
+        dayBreakdown: sliceSessionByLocalDay(fold.humanPromptTimestamps, {
+          activeGapMs: ACTIVE_GAP_MS
+        }),
+        provenance: HISTORICAL_PROVENANCE.derived,
+        extractionId
+      };
+      if (fold.afterHoursPrompts > 0) {
+        yield {
+          occurredAt: fold.lastTs,
+          store: "claude_code",
+          sourceVersion: fold.sourceVersion,
+          sessionRef: fold.sessionId,
+          repoRef: fold.cwd ?? fold.projectSlug,
+          eventKind: "after_hours_ai_session",
+          metrics: { afterHoursPrompts: fold.afterHoursPrompts },
+          provenance: HISTORICAL_PROVENANCE.derived,
+          extractionId
+        };
+      }
+      if (fold.compactionManualCount > 0) {
+        yield {
+          occurredAt: fold.lastTs,
+          store: "claude_code",
+          sourceVersion: fold.sourceVersion,
+          sessionRef: fold.sessionId,
+          repoRef: fold.cwd ?? fold.projectSlug,
+          eventKind: "context_compression_manual",
+          metrics: { compactionCount: fold.compactionManualCount },
+          provenance: HISTORICAL_PROVENANCE.derived,
+          extractionId
+        };
+      }
+      if (fold.compactionAutoCount > 0) {
+        yield {
+          occurredAt: fold.lastTs,
+          store: "claude_code",
+          sourceVersion: fold.sourceVersion,
+          sessionRef: fold.sessionId,
+          repoRef: fold.cwd ?? fold.projectSlug,
+          eventKind: "context_compression_auto",
+          metrics: { compactionCount: fold.compactionAutoCount },
+          provenance: HISTORICAL_PROVENANCE.derived,
+          extractionId
+        };
+      }
+      if (toolFailureCount > 0) {
+        yield {
+          occurredAt: fold.lastTs,
+          store: "claude_code",
+          sourceVersion: fold.sourceVersion,
+          sessionRef: fold.sessionId,
+          repoRef: fold.cwd ?? fold.projectSlug,
+          eventKind: "tool_failure",
+          metrics: {
+            toolFailureCount,
+            toolResultErrorCount: fold.toolResultErrorCount,
+            apiErrorCount: fold.apiErrorCount
+          },
+          provenance: HISTORICAL_PROVENANCE.derived,
+          extractionId
+        };
+      }
+    }
+  }
+  if (windowOldest && windowNewest || projectsWithNoReadableTranscript > 0) {
+    const window = windowOldest && windowNewest ? { windowOldest, windowNewest } : {};
+    yield {
+      // No window means nothing datable was read; the only honest timestamp
+      // left is when the read happened.
+      occurredAt: windowNewest ?? (/* @__PURE__ */ new Date()).toISOString(),
+      store: "claude_code",
+      sourceVersion: null,
+      sessionRef: null,
+      repoRef: null,
+      eventKind: "extraction_epoch",
+      metrics: {
+        ...window,
+        sessionCount,
+        projectsWithNoReadableTranscript
+      },
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+  }
+}
+
+// src/extractors/cursor.ts
+var import_tool_kit2 = __toESM(require_out2(), 1);
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var KNOWN_CURSOR_BUBBLE_VERSIONS = /* @__PURE__ */ new Set([3]);
+var KNOWN_CURSOR_HEADER_TYPES = /* @__PURE__ */ new Set(["head"]);
+var BUBBLE_TYPE_USER = 1;
+var BUBBLE_TYPE_ASSISTANT = 2;
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function pickTop(counts) {
+  let best = null;
+  let bestCount = 0;
+  for (const [key, count] of counts) {
+    if (count > bestCount) {
+      best = key;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+var MAX_QUERY_BUFFER = 256 * 1024 * 1024;
+async function queryJson(dbPath, sql) {
+  const { stdout } = await execFileAsync2("sqlite3", ["-json", dbPath, sql], {
+    maxBuffer: MAX_QUERY_BUFFER
+  });
+  const trimmed = stdout.trim();
+  if (trimmed === "") return [];
+  return JSON.parse(trimmed);
+}
+var HEADER_QUERY = `
+SELECT
+  composerId,
+  createdAt,
+  lastUpdatedAt,
+  recency,
+  checkpointAt,
+  isSubagent,
+  json_extract(value,'$.type') AS recordType,
+  json_extract(value,'$.totalLinesAdded') AS linesAdded,
+  json_extract(value,'$.totalLinesRemoved') AS linesRemoved,
+  json_extract(value,'$.filesChangedCount') AS filesChangedCount,
+  json_extract(value,'$.contextUsagePercent') AS contextUsagePercent,
+  json_extract(value,'$.unifiedMode') AS mode,
+  json_extract(value,'$.trackedGitRepos') AS trackedGitReposJson,
+  json_extract(value,'$.workspaceIdentifier.uri.fsPath') AS workspaceFsPath,
+  json_extract(value,'$.subagentInfo.parentComposerId') AS parentComposerId
+FROM composerHeaders;
+`;
+var BUBBLE_QUERY = `
+SELECT
+  key,
+  json_extract(value,'$._v') AS v,
+  json_extract(value,'$.type') AS btype,
+  json_extract(value,'$.createdAt') AS createdAt,
+  json_extract(value,'$.tokenCount.inputTokens') AS inputTokens,
+  json_extract(value,'$.tokenCount.outputTokens') AS outputTokens,
+  coalesce(json_array_length(value,'$.humanChanges'),0) AS humanChangesCount,
+  coalesce(json_array_length(value,'$.approximateLintErrors'),0) AS lintErrorsCount,
+  json_extract(value,'$.modelInfo.modelName') AS modelName
+FROM cursorDiskKV WHERE key LIKE 'bubbleId:%';
+`;
+function repoInfoOf(row) {
+  let repoRef = null;
+  let gitBranch = null;
+  if (row.trackedGitReposJson) {
+    try {
+      const repos = JSON.parse(row.trackedGitReposJson);
+      if (Array.isArray(repos) && repos.length > 0) {
+        const first = repos[0];
+        if (typeof first.repoPath === "string") repoRef = first.repoPath;
+        const branches = first.branches;
+        if (Array.isArray(branches) && branches.length > 0) {
+          const branch = branches[0];
+          if (typeof branch.branchName === "string") gitBranch = branch.branchName;
+        }
+      }
+    } catch {
+    }
+  }
+  if (!repoRef && row.workspaceFsPath) repoRef = row.workspaceFsPath;
+  return { repoRef, gitBranch };
+}
+function sniffCursorHeaderRow(row) {
+  if (row.recordType === null) return { kind: "unparsed" };
+  if (!KNOWN_CURSOR_HEADER_TYPES.has(row.recordType)) {
+    return { kind: "unknown", type: row.recordType };
+  }
+  const { repoRef, gitBranch } = repoInfoOf(row);
+  return {
+    kind: "head",
+    linesAdded: asNumber2(row.linesAdded),
+    linesRemoved: asNumber2(row.linesRemoved),
+    filesChangedCount: asNumber2(row.filesChangedCount),
+    contextUsagePercent: typeof row.contextUsagePercent === "number" ? row.contextUsagePercent : null,
+    mode: row.mode,
+    repoRef,
+    gitBranch,
+    isSubagent: row.isSubagent === 1,
+    parentComposerId: row.parentComposerId
+  };
+}
+function sniffCursorBubbleRow(row) {
+  const parts = row.key.split(":");
+  const composerId = parts.length >= 3 && parts[0] === "bubbleId" ? parts[1] : null;
+  if (row.v === null || !KNOWN_CURSOR_BUBBLE_VERSIONS.has(row.v) || composerId === null) {
+    return { kind: "unparsed", composerId };
+  }
+  if (row.btype !== BUBBLE_TYPE_USER && row.btype !== BUBBLE_TYPE_ASSISTANT) {
+    return { kind: "unknown", composerId };
+  }
+  return {
+    kind: row.btype === BUBBLE_TYPE_USER ? "user" : "assistant",
+    composerId,
+    createdAt: row.createdAt,
+    inputTokens: asNumber2(row.inputTokens),
+    outputTokens: asNumber2(row.outputTokens),
+    humanChangesCount: asNumber2(row.humanChangesCount),
+    lintErrorsCount: asNumber2(row.lintErrorsCount),
+    modelName: row.modelName,
+    sourceVersion: String(row.v)
+  };
+}
+function newFold2(row, sniffed) {
+  return {
+    composerId: row.composerId,
+    createdAtMs: Number.isFinite(row.createdAt) ? row.createdAt : null,
+    lastUpdatedAtMs: Number.isFinite(row.lastUpdatedAt) ? row.lastUpdatedAt : null,
+    recencyMs: Number.isFinite(row.recency) ? row.recency : null,
+    checkpointAtMs: Number.isFinite(row.checkpointAt) ? row.checkpointAt : null,
+    lastBubbleMs: null,
+    mode: sniffed.mode,
+    linesAdded: sniffed.linesAdded,
+    linesRemoved: sniffed.linesRemoved,
+    filesChangedCount: sniffed.filesChangedCount,
+    contextUsagePercent: sniffed.contextUsagePercent,
+    repoRef: sniffed.repoRef,
+    gitBranch: sniffed.gitBranch,
+    humanPrompts: 0,
+    afterHoursPrompts: 0,
+    assistantTurns: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    humanChangesCount: 0,
+    lintErrorsCount: 0,
+    unknownBubbles: 0,
+    unparsedBubbles: 0,
+    ownBubbles: 0,
+    models: /* @__PURE__ */ new Map(),
+    bubbleVersions: /* @__PURE__ */ new Map(),
+    humanPromptTimestamps: [],
+    subagentComposerIds: /* @__PURE__ */ new Set(),
+    subagentPromptCount: 0,
+    subagentAssistantTurns: 0,
+    subagentTokensTotal: 0
+  };
+}
+function resolveTimeline(fold) {
+  if (fold.createdAtMs === null) return null;
+  if (fold.lastUpdatedAtMs !== null) return { endedAtMs: fold.lastUpdatedAtMs, source: "header" };
+  const candidates = [
+    [fold.lastBubbleMs, "bubbles"],
+    [fold.recencyMs, "recency"],
+    [fold.checkpointAtMs, "checkpoint"]
+  ];
+  for (const [ms, source] of candidates) {
+    if (ms !== null && Number.isFinite(ms) && ms >= fold.createdAtMs) {
+      return { endedAtMs: ms, source };
+    }
+  }
+  return null;
+}
+function sessionDurationMs2(fold) {
+  const timeline = resolveTimeline(fold);
+  if (timeline === null) return null;
+  const ms = timeline.endedAtMs - fold.createdAtMs;
+  return Number.isFinite(ms) && ms >= 0 ? ms : null;
+}
+function durationBucketOf2(fold) {
+  const ms = sessionDurationMs2(fold);
+  if (ms === null) return "unknown";
+  return (0, import_tool_kit2.bucketDurationMs)(ms) ?? "unknown";
+}
+async function* extractCursor(snapshotDir, extractionId) {
+  const dbPath = path5.join(snapshotDir, "state.vscdb");
+  try {
+    await fs5.stat(dbPath);
+  } catch {
+    return;
+  }
+  let headerRows;
+  try {
+    headerRows = await queryJson(dbPath, HEADER_QUERY);
+  } catch {
+    yield {
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      store: "cursor",
+      sourceVersion: null,
+      sessionRef: null,
+      repoRef: null,
+      eventKind: "extraction_epoch",
+      metrics: {
+        sessionCount: 0,
+        schemaUnreadable: 1
+      },
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+    return;
+  }
+  const folds = /* @__PURE__ */ new Map();
+  const subagentParentOf = /* @__PURE__ */ new Map();
+  let unparsedComposerHeaders = 0;
+  let unknownComposerHeaderTypes = 0;
+  for (const row of headerRows) {
+    const sniffed = sniffCursorHeaderRow(row);
+    if (sniffed.kind === "unparsed") {
+      unparsedComposerHeaders += 1;
+      continue;
+    }
+    if (sniffed.kind === "unknown") {
+      unknownComposerHeaderTypes += 1;
+      continue;
+    }
+    if (sniffed.isSubagent) {
+      if (sniffed.parentComposerId) subagentParentOf.set(row.composerId, sniffed.parentComposerId);
+      continue;
+    }
+    folds.set(row.composerId, newFold2(row, sniffed));
+  }
+  let bubbleRows = [];
+  try {
+    bubbleRows = await queryJson(dbPath, BUBBLE_QUERY);
+  } catch {
+  }
+  let orphanedSubagentBubbles = 0;
+  let orphanedBubbles = 0;
+  for (const row of bubbleRows) {
+    const sniffed = sniffCursorBubbleRow(row);
+    if (sniffed.kind === "unparsed") {
+      const fold = sniffed.composerId ? folds.get(sniffed.composerId) : void 0;
+      if (fold) {
+        fold.unparsedBubbles += 1;
+        fold.ownBubbles += 1;
+      } else if (sniffed.composerId && subagentParentOf.has(sniffed.composerId)) {
+        const parent = folds.get(subagentParentOf.get(sniffed.composerId));
+        if (parent) parent.unparsedBubbles += 1;
+      } else orphanedBubbles += 1;
+      continue;
+    }
+    const ownFold = folds.get(sniffed.composerId);
+    if (ownFold) {
+      ownFold.ownBubbles += 1;
+      if (sniffed.kind === "unknown") {
+        ownFold.unknownBubbles += 1;
+        continue;
+      }
+      ownFold.bubbleVersions.set(
+        sniffed.sourceVersion,
+        (ownFold.bubbleVersions.get(sniffed.sourceVersion) ?? 0) + 1
+      );
+      ownFold.inputTokens += sniffed.inputTokens;
+      ownFold.outputTokens += sniffed.outputTokens;
+      ownFold.humanChangesCount += sniffed.humanChangesCount;
+      ownFold.lintErrorsCount += sniffed.lintErrorsCount;
+      if (sniffed.modelName) {
+        ownFold.models.set(sniffed.modelName, (ownFold.models.get(sniffed.modelName) ?? 0) + 1);
+      }
+      if (sniffed.createdAt) {
+        const ms = Date.parse(sniffed.createdAt);
+        if (Number.isFinite(ms) && (ownFold.lastBubbleMs === null || ms > ownFold.lastBubbleMs)) {
+          ownFold.lastBubbleMs = ms;
+        }
+      }
+      if (sniffed.kind === "user") {
+        ownFold.humanPrompts += 1;
+        if (sniffed.createdAt && (0, import_tool_kit2.isAfterHours)(new Date(sniffed.createdAt))) {
+          ownFold.afterHoursPrompts += 1;
+        }
+        ownFold.humanPromptTimestamps.push(sniffed.createdAt);
+      } else {
+        ownFold.assistantTurns += 1;
+      }
+      continue;
+    }
+    const parentId = subagentParentOf.get(sniffed.composerId);
+    const parentFold = parentId ? folds.get(parentId) : void 0;
+    if (!parentFold) {
+      orphanedSubagentBubbles += parentId ? 1 : 0;
+      orphanedBubbles += parentId ? 0 : 1;
+      continue;
+    }
+    if (sniffed.kind === "unknown") {
+      parentFold.unknownBubbles += 1;
+      continue;
+    }
+    parentFold.subagentComposerIds.add(sniffed.composerId);
+    parentFold.subagentTokensTotal += sniffed.inputTokens + sniffed.outputTokens;
+    if (sniffed.kind === "user") {
+      parentFold.subagentPromptCount += 1;
+    } else {
+      parentFold.subagentAssistantTurns += 1;
+    }
+  }
+  let windowOldest = null;
+  let windowNewest = null;
+  let sessionCount = 0;
+  const derivedTimelines = /* @__PURE__ */ new Map();
+  let sessionsWithoutTimeline = 0;
+  let emptyComposers = 0;
+  for (const composerId of [...folds.keys()].sort()) {
+    const fold = folds.get(composerId);
+    if (fold.ownBubbles === 0 && fold.subagentComposerIds.size === 0) {
+      emptyComposers += 1;
+      continue;
+    }
+    const timeline = resolveTimeline(fold);
+    if (timeline === null) {
+      sessionsWithoutTimeline += 1;
+      continue;
+    }
+    if (timeline.source !== "header") {
+      derivedTimelines.set(timeline.source, (derivedTimelines.get(timeline.source) ?? 0) + 1);
+    }
+    const startedAt = new Date(fold.createdAtMs).toISOString();
+    const endedAt = new Date(timeline.endedAtMs).toISOString();
+    sessionCount += 1;
+    if (!windowOldest || startedAt < windowOldest) windowOldest = startedAt;
+    if (!windowNewest || endedAt > windowNewest) windowNewest = endedAt;
+    const sourceVersion = pickTop(fold.bubbleVersions);
+    for (const ts of fold.humanPromptTimestamps) {
+      if (!ts) continue;
+      yield {
+        occurredAt: ts,
+        store: "cursor",
+        sourceVersion,
+        sessionRef: fold.composerId,
+        repoRef: fold.repoRef,
+        eventKind: "ai_prompt_submitted",
+        metrics: {},
+        provenance: HISTORICAL_PROVENANCE.direct,
+        extractionId
+      };
+    }
+    const durationMs = sessionDurationMs2(fold);
+    const sessionMetrics = {
+      promptCount: fold.humanPrompts,
+      assistantTurns: fold.assistantTurns,
+      inputTokens: fold.inputTokens,
+      outputTokens: fold.outputTokens,
+      linesAdded: fold.linesAdded,
+      linesRemoved: fold.linesRemoved,
+      filesChangedCount: fold.filesChangedCount,
+      humanChangesCount: fold.humanChangesCount,
+      approximateLintErrorsCount: fold.lintErrorsCount,
+      durationBucket: durationBucketOf2(fold),
+      afterHoursPrompts: fold.afterHoursPrompts,
+      unknownBubbles: fold.unknownBubbles,
+      unparsedBubbles: fold.unparsedBubbles,
+      modelCount: fold.models.size,
+      subagentComposers: fold.subagentComposerIds.size,
+      subagentPrompts: fold.subagentPromptCount,
+      subagentAssistantTurns: fold.subagentAssistantTurns,
+      subagentTokensTotal: fold.subagentTokensTotal,
+      sessionStartedAt: startedAt
+    };
+    if (durationMs !== null) sessionMetrics.sessionMinutes = Math.round(durationMs / 6e4);
+    if (fold.mode) sessionMetrics.mode = fold.mode;
+    if (fold.contextUsagePercent !== null) {
+      sessionMetrics.contextUsagePercent = Math.round(fold.contextUsagePercent * 100) / 100;
+    }
+    const primaryModel = pickTop(fold.models);
+    if (primaryModel) sessionMetrics.primaryModel = primaryModel;
+    if (fold.gitBranch) sessionMetrics.gitBranch = fold.gitBranch;
+    yield {
+      occurredAt: endedAt,
+      store: "cursor",
+      sourceVersion,
+      sessionRef: fold.composerId,
+      repoRef: fold.repoRef,
+      eventKind: "create_focus_session",
+      metrics: sessionMetrics,
+      dayBreakdown: sliceSessionByLocalDay(fold.humanPromptTimestamps),
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+    if (fold.afterHoursPrompts > 0) {
+      yield {
+        occurredAt: endedAt,
+        store: "cursor",
+        sourceVersion,
+        sessionRef: fold.composerId,
+        repoRef: fold.repoRef,
+        eventKind: "after_hours_ai_session",
+        metrics: { afterHoursPrompts: fold.afterHoursPrompts },
+        provenance: HISTORICAL_PROVENANCE.derived,
+        extractionId
+      };
+    }
+  }
+  const readFailures = unparsedComposerHeaders + unknownComposerHeaderTypes + orphanedSubagentBubbles + orphanedBubbles + sessionsWithoutTimeline;
+  if (windowOldest && windowNewest || readFailures > 0) {
+    const window = windowOldest && windowNewest ? { windowOldest, windowNewest } : {};
+    yield {
+      occurredAt: windowNewest ?? (/* @__PURE__ */ new Date()).toISOString(),
+      store: "cursor",
+      sourceVersion: null,
+      sessionRef: null,
+      repoRef: null,
+      eventKind: "extraction_epoch",
+      metrics: {
+        ...window,
+        sessionCount,
+        schemaUnreadable: 0,
+        unparsedComposerHeaders,
+        unknownComposerHeaderTypes,
+        orphanedSubagentBubbles,
+        orphanedBubbles,
+        sessionsWithoutTimeline,
+        emptyComposers,
+        sessionsFromBubbleTimeline: derivedTimelines.get("bubbles") ?? 0,
+        sessionsFromRecencyTimeline: derivedTimelines.get("recency") ?? 0,
+        sessionsFromCheckpointTimeline: derivedTimelines.get("checkpoint") ?? 0
+      },
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+  }
+}
+
+// src/extractors/vscode.ts
+var import_tool_kit3 = __toESM(require_out2(), 1);
+import * as fs6 from "node:fs/promises";
+import * as path6 from "node:path";
+import { fileURLToPath } from "node:url";
+var KNOWN_HISTORY_VERSION = 1;
+var KNOWN_CHAT_SESSION_VERSION = 3;
+var CHAT_EDIT_PREFIX = "Chat Edit:";
+function uriToPath(uri) {
+  if (typeof uri !== "string" || !uri.startsWith("file://")) return null;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+}
+async function buildWorkspaceFolderIndex(workspaceStorageDir) {
+  let hashDirs = [];
+  try {
+    hashDirs = (await fs6.readdir(workspaceStorageDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const folders = [];
+  for (const hash of hashDirs) {
+    let raw;
+    try {
+      raw = await fs6.readFile(path6.join(workspaceStorageDir, hash, "workspace.json"), "utf8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) continue;
+    const folderPath = uriToPath(parsed.folder);
+    if (folderPath) folders.push({ folderPath });
+  }
+  return folders.sort((a, b) => b.folderPath.length - a.folderPath.length);
+}
+function workspaceRootOf(filePath, index) {
+  for (const folder of index) {
+    const withSlash = folder.folderPath.endsWith("/") ? folder.folderPath : `${folder.folderPath}/`;
+    if (filePath === folder.folderPath || filePath.startsWith(withSlash)) {
+      return folder.folderPath;
+    }
+  }
+  return path6.dirname(filePath);
+}
+function sniffHistoryFile(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record = parsed;
+  if (record.version !== KNOWN_HISTORY_VERSION) return null;
+  if (typeof record.resource !== "string" || !Array.isArray(record.entries)) return null;
+  return { resource: record.resource, entries: record.entries };
+}
+async function foldEditDays(historyDir, index) {
+  const result = {
+    days: /* @__PURE__ */ new Map(),
+    unparsedFiles: 0,
+    malformedEntries: 0,
+    oldest: null,
+    newest: null
+  };
+  let hashDirs = [];
+  try {
+    hashDirs = (await fs6.readdir(historyDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return result;
+  }
+  for (const hash of hashDirs.sort()) {
+    let raw;
+    try {
+      raw = await fs6.readFile(path6.join(historyDir, hash, "entries.json"), "utf8");
+    } catch {
+      continue;
+    }
+    const sniffed = sniffHistoryFile(raw);
+    if (!sniffed) {
+      result.unparsedFiles += 1;
+      continue;
+    }
+    const resourcePath = uriToPath(sniffed.resource);
+    if (!resourcePath) {
+      result.unparsedFiles += 1;
+      continue;
+    }
+    const workspaceRoot = workspaceRootOf(resourcePath, index);
+    for (const entry of sniffed.entries) {
+      const ts = typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp) ? entry.timestamp : null;
+      if (ts === null) {
+        result.malformedEntries += 1;
+        continue;
+      }
+      const iso = new Date(ts).toISOString();
+      const date = iso.slice(0, 10);
+      if (!result.oldest || iso < result.oldest) result.oldest = iso;
+      if (!result.newest || iso > result.newest) result.newest = iso;
+      const key = `${date}\0${workspaceRoot}`;
+      let fold = result.days.get(key);
+      if (!fold) {
+        fold = { date, workspaceRoot, chatEditCount: 0, totalEntryCount: 0, lastTs: iso };
+        result.days.set(key, fold);
+      }
+      fold.totalEntryCount += 1;
+      if (iso > fold.lastTs) fold.lastTs = iso;
+      if (typeof entry.source === "string" && entry.source.startsWith(CHAT_EDIT_PREFIX)) {
+        fold.chatEditCount += 1;
+      }
+    }
+  }
+  return result;
+}
+var JSONL_KIND_HEADER = 0;
+var JSONL_KIND_SET = 1;
+var JSONL_KIND_SPLICE = 2;
+function resolvePath(root, path9) {
+  let cur = root;
+  for (const seg of path9) {
+    if (typeof seg === "number") {
+      if (!Array.isArray(cur) || seg >= cur.length) return null;
+      cur = cur[seg];
+    } else {
+      if (typeof cur !== "object" || cur === null || Array.isArray(cur)) return null;
+      cur = cur[seg];
+    }
+  }
+  return cur ?? null;
+}
+function applySet(root, path9, value) {
+  if (path9.length === 0) return;
+  const parent = resolvePath(root, path9.slice(0, -1));
+  const last = path9[path9.length - 1];
+  if (typeof last === "number") {
+    if (!Array.isArray(parent)) return;
+    while (parent.length <= last) parent.push(null);
+    parent[last] = value;
+  } else {
+    if (typeof parent !== "object" || parent === null || Array.isArray(parent)) return;
+    parent[last] = value;
+  }
+}
+function applySplice(root, path9, values, index) {
+  const target = resolvePath(root, path9);
+  if (!Array.isArray(target)) return;
+  if (index !== null && index >= 0 && index <= target.length) target.splice(index, 0, ...values);
+  else target.push(...values);
+}
+function parseJsonlChatSession(raw) {
+  let malformedLines = 0;
+  let record = null;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      malformedLines += 1;
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      malformedLines += 1;
+      continue;
+    }
+    const delta = parsed;
+    if (delta.kind === JSONL_KIND_HEADER) {
+      if (record === null && typeof delta.v === "object" && delta.v !== null) {
+        record = delta.v;
+      }
+      continue;
+    }
+    if (record === null || !Array.isArray(delta.k)) continue;
+    const keyPath = delta.k.filter(
+      (seg) => typeof seg === "string" || typeof seg === "number"
+    );
+    if (keyPath.length !== delta.k.length) continue;
+    if (delta.kind === JSONL_KIND_SET) {
+      applySet(record, keyPath, delta.v);
+    } else if (delta.kind === JSONL_KIND_SPLICE && Array.isArray(delta.v)) {
+      applySplice(record, keyPath, delta.v, typeof delta.i === "number" ? delta.i : null);
+    }
+  }
+  return { record, malformedLines };
+}
+function topModel2(models) {
+  let best = null;
+  let bestCount = 0;
+  for (const [model, count] of models) {
+    if (count > bestCount) {
+      best = model;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+async function foldChatSessions(workspaceStorageDir) {
+  const result = {
+    sessions: [],
+    unparsedFiles: 0,
+    unrecognisedFiles: 0,
+    emptyDrafts: 0,
+    malformedLines: 0
+  };
+  let wsHashes = [];
+  try {
+    wsHashes = (await fs6.readdir(workspaceStorageDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return result;
+  }
+  for (const hash of wsHashes.sort()) {
+    const wsDir = path6.join(workspaceStorageDir, hash);
+    let workspaceRoot = null;
+    try {
+      const raw = await fs6.readFile(path6.join(wsDir, "workspace.json"), "utf8");
+      const parsed = JSON.parse(raw);
+      workspaceRoot = uriToPath(parsed.folder);
+    } catch {
+    }
+    let files = [];
+    try {
+      const entries = await fs6.readdir(path6.join(wsDir, "chatSessions"));
+      files = entries.filter((f) => f.endsWith(".json") || f.endsWith(".jsonl"));
+      result.unrecognisedFiles += entries.length - files.length;
+    } catch {
+      continue;
+    }
+    for (const file of files.sort()) {
+      let raw;
+      try {
+        raw = await fs6.readFile(path6.join(wsDir, "chatSessions", file), "utf8");
+      } catch {
+        continue;
+      }
+      let record = null;
+      if (file.endsWith(".jsonl")) {
+        const folded = parseJsonlChatSession(raw);
+        result.malformedLines += folded.malformedLines;
+        record = folded.record;
+      } else {
+        try {
+          const parsed = JSON.parse(raw);
+          if (typeof parsed === "object" && parsed !== null) {
+            record = parsed;
+          }
+        } catch {
+          record = null;
+        }
+      }
+      if (record === null) {
+        result.unparsedFiles += 1;
+        continue;
+      }
+      if (record.version !== KNOWN_CHAT_SESSION_VERSION) {
+        result.unparsedFiles += 1;
+        continue;
+      }
+      const requests = Array.isArray(record.requests) ? record.requests : [];
+      if (requests.length === 0) {
+        result.emptyDrafts += 1;
+        continue;
+      }
+      const fold = {
+        sessionId: typeof record.sessionId === "string" ? record.sessionId : path6.basename(file, path6.extname(file)),
+        workspaceRoot,
+        firstTs: null,
+        lastTs: null,
+        requestCount: 0,
+        afterHoursRequests: 0,
+        canceledCount: 0,
+        errorCount: 0,
+        models: /* @__PURE__ */ new Map(),
+        requestTimestamps: []
+      };
+      for (const r of requests) {
+        if (typeof r !== "object" || r === null) continue;
+        const req = r;
+        const ts = typeof req.timestamp === "number" && Number.isFinite(req.timestamp) ? req.timestamp : null;
+        if (ts === null) continue;
+        const iso = new Date(ts).toISOString();
+        fold.requestCount += 1;
+        fold.requestTimestamps.push(iso);
+        if (!fold.firstTs || iso < fold.firstTs) fold.firstTs = iso;
+        if (!fold.lastTs || iso > fold.lastTs) fold.lastTs = iso;
+        if ((0, import_tool_kit3.isAfterHours)(new Date(iso))) fold.afterHoursRequests += 1;
+        if (req.isCanceled === true) fold.canceledCount += 1;
+        const requestResult = req.result;
+        if (requestResult && requestResult.errorDetails) fold.errorCount += 1;
+        if (typeof req.modelId === "string") {
+          fold.models.set(req.modelId, (fold.models.get(req.modelId) ?? 0) + 1);
+        }
+      }
+      if (fold.requestCount > 0) result.sessions.push(fold);
+    }
+  }
+  return result;
+}
+async function* extractVsCode(snapshotDir, extractionId) {
+  const historyDir = path6.join(snapshotDir, "history");
+  const workspaceStorageDir = path6.join(snapshotDir, "workspaceStorage");
+  const index = await buildWorkspaceFolderIndex(workspaceStorageDir);
+  const editDays = await foldEditDays(historyDir, index);
+  const chatSessions = await foldChatSessions(workspaceStorageDir);
+  let windowOldest = editDays.oldest;
+  let windowNewest = editDays.newest;
+  const sortedDays = [...editDays.days.values()].sort(
+    (a, b) => `${a.date}\0${a.workspaceRoot}`.localeCompare(`${b.date}\0${b.workspaceRoot}`)
+  );
+  for (const fold of sortedDays) {
+    yield {
+      occurredAt: fold.lastTs,
+      store: "vscode",
+      sourceVersion: String(KNOWN_HISTORY_VERSION),
+      sessionRef: null,
+      repoRef: fold.workspaceRoot,
+      eventKind: "editor_activity",
+      metrics: {
+        date: fold.date,
+        chatEditCount: fold.chatEditCount,
+        totalEntryCount: fold.totalEntryCount
+      },
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+  }
+  let sessionCount = 0;
+  for (const fold of chatSessions.sessions) {
+    if (!fold.firstTs || !fold.lastTs) continue;
+    sessionCount += 1;
+    if (!windowOldest || fold.firstTs < windowOldest) windowOldest = fold.firstTs;
+    if (!windowNewest || fold.lastTs > windowNewest) windowNewest = fold.lastTs;
+    for (const ts of fold.requestTimestamps) {
+      yield {
+        occurredAt: ts,
+        store: "vscode",
+        sourceVersion: String(KNOWN_CHAT_SESSION_VERSION),
+        sessionRef: fold.sessionId,
+        repoRef: fold.workspaceRoot,
+        eventKind: "ai_prompt_submitted",
+        metrics: {},
+        provenance: HISTORICAL_PROVENANCE.direct,
+        extractionId
+      };
+    }
+    const durationMs = Date.parse(fold.lastTs) - Date.parse(fold.firstTs);
+    const sessionMetrics = {
+      requestCount: fold.requestCount,
+      afterHoursRequests: fold.afterHoursRequests,
+      canceledCount: fold.canceledCount,
+      errorCount: fold.errorCount,
+      modelCount: fold.models.size,
+      sessionStartedAt: fold.firstTs
+    };
+    const primaryModel = topModel2(fold.models);
+    if (primaryModel) sessionMetrics.primaryModel = primaryModel;
+    if (Number.isFinite(durationMs) && durationMs >= 0) {
+      sessionMetrics.sessionMinutes = Math.round(durationMs / 6e4);
+      const bucket = (0, import_tool_kit3.bucketDurationMs)(durationMs);
+      if (bucket) sessionMetrics.durationBucket = bucket;
+    }
+    yield {
+      occurredAt: fold.lastTs,
+      store: "vscode",
+      sourceVersion: String(KNOWN_CHAT_SESSION_VERSION),
+      sessionRef: fold.sessionId,
+      repoRef: fold.workspaceRoot,
+      eventKind: "create_focus_session",
+      metrics: sessionMetrics,
+      dayBreakdown: sliceSessionByLocalDay(fold.requestTimestamps),
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+    if (fold.afterHoursRequests > 0) {
+      yield {
+        occurredAt: fold.lastTs,
+        store: "vscode",
+        sourceVersion: String(KNOWN_CHAT_SESSION_VERSION),
+        sessionRef: fold.sessionId,
+        repoRef: fold.workspaceRoot,
+        eventKind: "after_hours_ai_session",
+        metrics: { afterHoursPrompts: fold.afterHoursRequests },
+        provenance: HISTORICAL_PROVENANCE.derived,
+        extractionId
+      };
+    }
+    if (fold.errorCount > 0) {
+      yield {
+        occurredAt: fold.lastTs,
+        store: "vscode",
+        sourceVersion: String(KNOWN_CHAT_SESSION_VERSION),
+        sessionRef: fold.sessionId,
+        repoRef: fold.workspaceRoot,
+        eventKind: "tool_failure",
+        metrics: { toolFailureCount: fold.errorCount },
+        provenance: HISTORICAL_PROVENANCE.derived,
+        extractionId
+      };
+    }
+  }
+  const readFailures = editDays.unparsedFiles + editDays.malformedEntries + chatSessions.unparsedFiles + chatSessions.unrecognisedFiles + chatSessions.malformedLines;
+  if (windowOldest && windowNewest || readFailures > 0) {
+    const window = windowOldest && windowNewest ? { windowOldest, windowNewest } : {};
+    yield {
+      // No window means nothing datable was read; the only honest timestamp
+      // left is when the read happened.
+      occurredAt: windowNewest ?? (/* @__PURE__ */ new Date()).toISOString(),
+      store: "vscode",
+      sourceVersion: null,
+      sessionRef: null,
+      repoRef: null,
+      eventKind: "extraction_epoch",
+      metrics: {
+        ...window,
+        editDayCount: editDays.days.size,
+        sessionCount,
+        unparsedHistoryFiles: editDays.unparsedFiles,
+        malformedHistoryEntries: editDays.malformedEntries,
+        unparsedChatSessionFiles: chatSessions.unparsedFiles,
+        unrecognisedChatSessionFiles: chatSessions.unrecognisedFiles,
+        emptyChatSessions: chatSessions.emptyDrafts,
+        malformedChatSessionLines: chatSessions.malformedLines
+      },
+      provenance: HISTORICAL_PROVENANCE.derived,
+      extractionId
+    };
+  }
+}
+
+// src/ship.ts
+var import_tool_kit4 = __toESM(require_out2(), 1);
+import { createHash } from "node:crypto";
+var DEFAULT_API_BASE_URL = "https://api.ascenda.one";
+function loadShipConfig() {
+  const apiBaseUrl = (process.env.ASCENDA_API_BASE_URL ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
+  const idRaw = process.env.ASCENDA_TOOL_INSTALLATION_ID;
+  if (!idRaw) {
+    throw new Error(
+      "Missing ASCENDA_TOOL_INSTALLATION_ID \u2014 the importer ships as the machine's paired tool; pair it first"
+    );
+  }
+  const toolInstallationId = idRaw.trim().includes(":") ? idRaw.trim() : `claude_code:${idRaw.trim()}`;
+  const tokenFilePath = process.env.ASCENDA_EVENT_WRITE_TOKEN_FILE ?? (0, import_tool_kit4.defaultTokenFilePath)(toolInstallationId);
+  const eventWriteToken = (0, import_tool_kit4.readTokenFile)(tokenFilePath) ?? process.env.ASCENDA_EVENT_WRITE_TOKEN;
+  if (!eventWriteToken) {
+    throw new Error(`No event write token at ${tokenFilePath} (or ASCENDA_EVENT_WRITE_TOKEN)`);
+  }
+  return { apiBaseUrl, toolInstallationId, eventWriteToken };
+}
+function importOrdinals(events) {
+  const seen = /* @__PURE__ */ new Map();
+  return events.map((event) => {
+    const identity = [event.store, event.sessionRef ?? "", event.eventKind, event.occurredAt].join(
+      "|"
+    );
+    const ordinal = seen.get(identity) ?? 0;
+    seen.set(identity, ordinal + 1);
+    return ordinal;
+  });
+}
+function importKeyOf(event, ordinal) {
+  return createHash("sha256").update(
+    [event.store, event.sessionRef ?? "", event.eventKind, event.occurredAt, String(ordinal)].join(
+      "|"
+    )
+  ).digest("hex").slice(0, 16);
+}
+function toWirePayload(event, ordinal, toolInstallationId) {
+  const metadata = {
+    importKey: importKeyOf(event, ordinal),
+    extractionId: event.extractionId,
+    importSchema: 1
+  };
+  if (event.sourceVersion) metadata.sourceVersion = event.sourceVersion;
+  for (const [key, value] of Object.entries(event.metrics)) {
+    metadata[key] = value;
+  }
+  if (typeof metadata.gitBranch === "string") {
+    metadata.gitBranchHash = (0, import_tool_kit4.hashWithMachineSalt)(metadata.gitBranch) ?? "";
+    delete metadata.gitBranch;
+  }
+  const workspaceHash = event.repoRef ? (0, import_tool_kit4.hashWithMachineSalt)(event.repoRef) : null;
+  return {
+    toolInstallationId,
+    source: STORE_SOURCE[event.store],
+    // Always a canonical catalog type. `eventKind` is typed against the
+    // contract union and the epoch marker is filtered out upstream in
+    // `shippableEvents`, so no cast is needed here — and an off-catalog name
+    // cannot reach the wire to be silently bucketed as `unclassified`.
+    eventType: event.eventKind,
+    occurredAt: event.occurredAt,
+    // The offset in force WHEN THE EVENT HAPPENED, not when the import ran.
+    // A nine-month backfill crosses DST boundaries; stamping today's
+    // offset on all of it would shift a whole season by an hour.
+    utcOffsetMinutes: (0, import_tool_kit4.utcOffsetMinutesAt)(new Date(event.occurredAt)),
+    severity: "low",
+    sessionId: event.sessionRef,
+    workspaceHash,
+    projectHash: workspaceHash,
+    // A real contract ToolConsentScope now, and a real gate: the backend
+    // requires an active historical-import consent lease for anything carrying
+    // one of the provenance classes below, and decides that on the provenance
+    // rather than on this string — sending `ide_telemetry` here would not buy
+    // the event a way in.
+    consentScope: HISTORICAL_CONSENT_SCOPE,
+    provenance: event.provenance,
+    privacyMode: "metadata_only",
+    metadata
+  };
+}
+var BATCH_SIZE = 200;
+function shippableEvents(events) {
+  return events.filter(
+    (e) => e.eventKind !== EXTRACTION_EPOCH_KIND
+  );
+}
+async function shipEvents(events, config, onProgress) {
+  const result = {
+    sent: 0,
+    accepted: 0,
+    duplicate: 0,
+    rejected: 0,
+    rejectionReasons: {},
+    httpFailures: 0
+  };
+  const wireEvents = shippableEvents(events);
+  const ordinals = importOrdinals(wireEvents);
+  for (let offset = 0; offset < wireEvents.length; offset += BATCH_SIZE) {
+    const chunk = wireEvents.slice(offset, offset + BATCH_SIZE);
+    const payloads = chunk.map(
+      (event, i) => toWirePayload(event, ordinals[offset + i], config.toolInstallationId)
+    );
+    let response;
+    try {
+      response = await fetch(`${config.apiBaseUrl}/v1/tool-events/batch`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${config.eventWriteToken}`
+        },
+        body: JSON.stringify({ events: payloads })
+      });
+    } catch {
+      result.httpFailures += 1;
+      continue;
+    }
+    result.sent += chunk.length;
+    if (!response.ok) {
+      result.httpFailures += 1;
+      if (response.status === 401 || response.status === 403) {
+        throw new Error(
+          `Ingest refused (${response.status}) \u2014 token invalid/revoked or consent missing; aborting rather than burning ${wireEvents.length - offset} more events`
+        );
+      }
+      continue;
+    }
+    try {
+      const body = await response.json();
+      result.accepted += body.accepted ?? 0;
+      result.duplicate += body.duplicate ?? 0;
+      result.rejected += body.rejected ?? 0;
+      for (const item of body.results ?? []) {
+        if (item.status !== "accepted" && item.status !== "duplicate") {
+          const reason = item.reason ?? "unknown";
+          result.rejectionReasons[reason] = (result.rejectionReasons[reason] ?? 0) + 1;
+        }
+      }
+    } catch {
+      result.httpFailures += 1;
+    }
+    onProgress?.(Math.min(offset + BATCH_SIZE, wireEvents.length), wireEvents.length);
+  }
+  return result;
+}
+
+// src/localHandoff.ts
+import * as fs7 from "node:fs/promises";
+import * as os2 from "node:os";
+import * as path7 from "node:path";
+var APP_BUNDLE_ID = "one.ascenda.ascendaMissionControl";
+var HANDOFF_SCHEMA = 2;
+function handoffDir(home = os2.homedir()) {
+  return path7.join(home, "Library", "Containers", APP_BUNDLE_ID, "Data", ".ascenda", "history-import");
+}
+function handoffFilePath(home = os2.homedir(), store = "claude_code") {
+  return path7.join(handoffDir(home), `${store}.json`);
+}
+function projectLabelOf(repoRef) {
+  if (!repoRef) return null;
+  const trimmed = repoRef.replace(/\/+$/, "");
+  const segment = trimmed.split("/").filter(Boolean).pop() ?? null;
+  return segment && segment.length > 0 ? segment : null;
+}
+function buildHandoff(events, extractionId, generatedAt) {
+  const sessions = [];
+  let windowOldest = null;
+  let windowNewest = null;
+  for (const event of events) {
+    if (event.eventKind === "extraction_epoch") {
+      const oldest = event.metrics.windowOldest;
+      const newest = event.metrics.windowNewest;
+      if (typeof oldest === "string") windowOldest = oldest;
+      if (typeof newest === "string") windowNewest = newest;
+      continue;
+    }
+    if (event.eventKind !== "create_focus_session") continue;
+    sessions.push({
+      at: event.occurredAt,
+      startedAt: typeof event.metrics.sessionStartedAt === "string" ? event.metrics.sessionStartedAt : null,
+      sessionRef: event.sessionRef,
+      projectLabel: projectLabelOf(event.repoRef),
+      promptCount: Number(event.metrics.promptCount ?? 0),
+      durationBucket: String(event.metrics.durationBucket ?? "unknown"),
+      afterHoursPrompts: Number(event.metrics.afterHoursPrompts ?? 0),
+      primaryModel: typeof event.metrics.primaryModel === "string" ? event.metrics.primaryModel : null,
+      activeMinutes: Number(event.metrics.activeMinutes ?? 0),
+      compactionCount: Number(event.metrics.compactionCount ?? 0),
+      toolFailureCount: Number(event.metrics.toolFailureCount ?? 0),
+      contextWindowPeakPct: Number(event.metrics.contextWindowPeakPct ?? 0),
+      userModifiedEditCount: Number(event.metrics.userModifiedEditCount ?? 0),
+      subagentTranscripts: Number(event.metrics.subagentTranscripts ?? 0),
+      days: event.dayBreakdown ?? [],
+      provenance: event.provenance
+    });
+  }
+  sessions.sort((a, b) => a.at.localeCompare(b.at));
+  return {
+    schema: HANDOFF_SCHEMA,
+    extractionId,
+    generatedAt,
+    timezone: LOCAL_TIMEZONE,
+    store: "claude_code",
+    windowOldest,
+    windowNewest,
+    sessions
+  };
+}
+function buildCursorHandoff(events, extractionId, generatedAt) {
+  const sessions = [];
+  let windowOldest = null;
+  let windowNewest = null;
+  for (const event of events) {
+    if (event.eventKind === "extraction_epoch") {
+      const oldest = event.metrics.windowOldest;
+      const newest = event.metrics.windowNewest;
+      if (typeof oldest === "string") windowOldest = oldest;
+      if (typeof newest === "string") windowNewest = newest;
+      continue;
+    }
+    if (event.eventKind !== "create_focus_session") continue;
+    sessions.push({
+      at: event.occurredAt,
+      startedAt: typeof event.metrics.sessionStartedAt === "string" ? event.metrics.sessionStartedAt : null,
+      sessionRef: event.sessionRef,
+      projectLabel: projectLabelOf(event.repoRef),
+      promptCount: Number(event.metrics.promptCount ?? 0),
+      durationBucket: String(event.metrics.durationBucket ?? "unknown"),
+      afterHoursPrompts: Number(event.metrics.afterHoursPrompts ?? 0),
+      primaryModel: typeof event.metrics.primaryModel === "string" ? event.metrics.primaryModel : null,
+      linesAdded: Number(event.metrics.linesAdded ?? 0),
+      linesRemoved: Number(event.metrics.linesRemoved ?? 0),
+      filesChangedCount: Number(event.metrics.filesChangedCount ?? 0),
+      contextUsagePercent: typeof event.metrics.contextUsagePercent === "number" ? event.metrics.contextUsagePercent : null,
+      humanChangesCount: Number(event.metrics.humanChangesCount ?? 0),
+      approximateLintErrorsCount: Number(event.metrics.approximateLintErrorsCount ?? 0),
+      subagentComposers: Number(event.metrics.subagentComposers ?? 0),
+      days: event.dayBreakdown ?? [],
+      provenance: event.provenance
+    });
+  }
+  sessions.sort((a, b) => a.at.localeCompare(b.at));
+  return {
+    schema: HANDOFF_SCHEMA,
+    extractionId,
+    generatedAt,
+    timezone: LOCAL_TIMEZONE,
+    store: "cursor",
+    windowOldest,
+    windowNewest,
+    sessions
+  };
+}
+function buildVsCodeHandoff(events, extractionId, generatedAt) {
+  const editDays = [];
+  const chatSessions = [];
+  let windowOldest = null;
+  let windowNewest = null;
+  for (const event of events) {
+    if (event.eventKind === "extraction_epoch") {
+      const oldest = event.metrics.windowOldest;
+      const newest = event.metrics.windowNewest;
+      if (typeof oldest === "string") windowOldest = oldest;
+      if (typeof newest === "string") windowNewest = newest;
+      continue;
+    }
+    if (event.eventKind === "editor_activity") {
+      editDays.push({
+        date: typeof event.metrics.date === "string" ? event.metrics.date : event.occurredAt.slice(0, 10),
+        projectLabel: projectLabelOf(event.repoRef),
+        chatEditCount: Number(event.metrics.chatEditCount ?? 0),
+        totalEntryCount: Number(event.metrics.totalEntryCount ?? 0),
+        provenance: event.provenance
+      });
+      continue;
+    }
+    if (event.eventKind !== "create_focus_session") continue;
+    chatSessions.push({
+      at: event.occurredAt,
+      startedAt: typeof event.metrics.sessionStartedAt === "string" ? event.metrics.sessionStartedAt : null,
+      sessionRef: event.sessionRef,
+      projectLabel: projectLabelOf(event.repoRef),
+      requestCount: Number(event.metrics.requestCount ?? 0),
+      durationBucket: String(event.metrics.durationBucket ?? "unknown"),
+      afterHoursRequests: Number(event.metrics.afterHoursRequests ?? 0),
+      primaryModel: typeof event.metrics.primaryModel === "string" ? event.metrics.primaryModel : null,
+      canceledCount: Number(event.metrics.canceledCount ?? 0),
+      errorCount: Number(event.metrics.errorCount ?? 0),
+      days: event.dayBreakdown ?? [],
+      provenance: event.provenance
+    });
+  }
+  editDays.sort((a, b) => a.date.localeCompare(b.date) || (a.projectLabel ?? "").localeCompare(b.projectLabel ?? ""));
+  chatSessions.sort((a, b) => a.at.localeCompare(b.at));
+  return {
+    schema: HANDOFF_SCHEMA,
+    extractionId,
+    generatedAt,
+    timezone: LOCAL_TIMEZONE,
+    store: "vscode",
+    windowOldest,
+    windowNewest,
+    editDays,
+    chatSessions
+  };
+}
+async function writeHandoff(handoff, home = os2.homedir()) {
+  const containerRoot = path7.join(home, "Library", "Containers", APP_BUNDLE_ID, "Data");
+  try {
+    await fs7.stat(containerRoot);
+  } catch {
+    return null;
+  }
+  const dir = handoffDir(home);
+  await fs7.mkdir(dir, { recursive: true });
+  const target = handoffFilePath(home, handoff.store);
+  const temp = `${target}.tmp`;
+  await fs7.writeFile(temp, JSON.stringify(handoff, null, 2) + "\n", "utf8");
+  await fs7.rename(temp, target);
+  return target;
+}
+
+// src/cli.ts
+function formatInventory(inv) {
+  const lines = [];
+  const status = inv.present ? "found" : "not found";
+  lines.push(`${inv.store}  (${status})  ${inv.rootPath}`);
+  if (inv.present) {
+    if (inv.oldest || inv.newest) {
+      lines.push(`  window: ${inv.oldest ?? "?"} \u2192 ${inv.newest ?? "?"}`);
+    }
+    const counts = Object.entries(inv.counts).map(([k, v]) => `${k}=${v.toLocaleString("en-US")}`).join("  ");
+    if (counts) lines.push(`  ${counts}`);
+    if (inv.retentionRisk) lines.push(`  \u26A0 ${inv.retentionRisk}`);
+    for (const note of inv.notes) lines.push(`  note: ${note}`);
+  }
+  return lines.join("\n");
+}
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const paths = resolveStorePaths();
+  switch (command) {
+    case "scan": {
+      const inventories = await scanAll(paths);
+      if (rest.includes("--json")) {
+        process.stdout.write(JSON.stringify(inventories, null, 2) + "\n");
+      } else {
+        process.stdout.write(inventories.map(formatInventory).join("\n\n") + "\n");
+      }
+      return 0;
+    }
+    case "import": {
+      const ship = rest.includes("--ship");
+      const claudeInventory = await scanClaudeCode(paths);
+      const cursorInventory = await scanCursor(paths);
+      const vsCodeInventory = await scanVsCode(paths);
+      if (!claudeInventory.present && !cursorInventory.present && !vsCodeInventory.present) {
+        process.stderr.write(
+          `no Claude Code store at ${claudeInventory.rootPath}, no Cursor store at ${cursorInventory.rootPath}, and no VS Code store at ${vsCodeInventory.rootPath} \u2014 nothing to import
+`
+        );
+        return 2;
+      }
+      const area = await createStagingArea(defaultStagingRoot(paths.home));
+      process.stdout.write(`staging: ${area.root}
+
+`);
+      const allEvents = [];
+      if (claudeInventory.present) {
+        process.stdout.write(formatInventory(claudeInventory) + "\n\n");
+        const snapshotRoot = path8.join(area.root, "claude_code");
+        await snapshotPath(area, paths.claudeProjects, path8.join("claude_code", "projects"));
+        const claudeEvents = [];
+        const kindCounts = {};
+        for await (const event of extractClaudeCode(snapshotRoot, area.extractionId)) {
+          claudeEvents.push(event);
+          kindCounts[event.eventKind] = (kindCounts[event.eventKind] ?? 0) + 1;
+        }
+        allEvents.push(...claudeEvents);
+        const epoch = claudeEvents.find((e) => e.eventKind === "extraction_epoch");
+        process.stdout.write(`claude_code extracted: ${claudeEvents.length.toLocaleString("en-US")} events
+`);
+        for (const [kind, n] of Object.entries(kindCounts)) {
+          process.stdout.write(`  ${kind}: ${n.toLocaleString("en-US")}
+`);
+        }
+        if (epoch) {
+          process.stdout.write(`  window: ${epoch.metrics.windowOldest} \u2192 ${epoch.metrics.windowNewest}
+`);
+        }
+        const handoff = buildHandoff(claudeEvents, area.extractionId, (/* @__PURE__ */ new Date()).toISOString());
+        const handoffPath = await writeHandoff(handoff);
+        if (handoffPath) {
+          process.stdout.write(`  handoff: ${handoff.sessions.length} sessions \u2192 ${handoffPath}
+
+`);
+        } else {
+          process.stdout.write("  handoff: desktop app container not found \u2014 skipped\n\n");
+        }
+      } else {
+        process.stdout.write(formatInventory(claudeInventory) + "\n\n");
+      }
+      if (cursorInventory.present) {
+        process.stdout.write(formatInventory(cursorInventory) + "\n\n");
+        const cursorSnapshotRoot = path8.join(area.root, "cursor");
+        await snapshotPath(area, paths.cursorStateDb, path8.join("cursor", "state.vscdb"));
+        const cursorEvents = [];
+        const kindCounts = {};
+        for await (const event of extractCursor(cursorSnapshotRoot, area.extractionId)) {
+          cursorEvents.push(event);
+          kindCounts[event.eventKind] = (kindCounts[event.eventKind] ?? 0) + 1;
+        }
+        allEvents.push(...cursorEvents);
+        const epoch = cursorEvents.find((e) => e.eventKind === "extraction_epoch");
+        process.stdout.write(`cursor extracted: ${cursorEvents.length.toLocaleString("en-US")} events
+`);
+        for (const [kind, n] of Object.entries(kindCounts)) {
+          process.stdout.write(`  ${kind}: ${n.toLocaleString("en-US")}
+`);
+        }
+        if (epoch) {
+          process.stdout.write(`  window: ${epoch.metrics.windowOldest} \u2192 ${epoch.metrics.windowNewest}
+`);
+        }
+        const handoff = buildCursorHandoff(cursorEvents, area.extractionId, (/* @__PURE__ */ new Date()).toISOString());
+        const handoffPath = await writeHandoff(handoff);
+        if (handoffPath) {
+          process.stdout.write(`  handoff: ${handoff.sessions.length} sessions \u2192 ${handoffPath}
+
+`);
+        } else {
+          process.stdout.write("  handoff: desktop app container not found \u2014 skipped\n\n");
+        }
+      } else {
+        process.stdout.write(formatInventory(cursorInventory) + "\n\n");
+      }
+      if (vsCodeInventory.present) {
+        process.stdout.write(formatInventory(vsCodeInventory) + "\n\n");
+        const vsCodeSnapshotRoot = path8.join(area.root, "vscode");
+        await snapshotPath(area, paths.vscodeHistory, path8.join("vscode", "history"));
+        await snapshotVsCodeWorkspaceStorage(area, paths.vscodeWorkspaceStorage, path8.join("vscode", "workspaceStorage"));
+        const vsCodeEvents = [];
+        const kindCounts = {};
+        for await (const event of extractVsCode(vsCodeSnapshotRoot, area.extractionId)) {
+          vsCodeEvents.push(event);
+          kindCounts[event.eventKind] = (kindCounts[event.eventKind] ?? 0) + 1;
+        }
+        allEvents.push(...vsCodeEvents);
+        const epoch = vsCodeEvents.find((e) => e.eventKind === "extraction_epoch");
+        process.stdout.write(`vscode extracted: ${vsCodeEvents.length.toLocaleString("en-US")} events
+`);
+        for (const [kind, n] of Object.entries(kindCounts)) {
+          process.stdout.write(`  ${kind}: ${n.toLocaleString("en-US")}
+`);
+        }
+        if (epoch) {
+          process.stdout.write(`  window: ${epoch.metrics.windowOldest} \u2192 ${epoch.metrics.windowNewest}
+`);
+        }
+        const handoff = buildVsCodeHandoff(vsCodeEvents, area.extractionId, (/* @__PURE__ */ new Date()).toISOString());
+        const handoffPath = await writeHandoff(handoff);
+        if (handoffPath) {
+          process.stdout.write(
+            `  handoff: ${handoff.editDays.length} edit-days, ${handoff.chatSessions.length} chat sessions \u2192 ${handoffPath}
+
+`
+          );
+        } else {
+          process.stdout.write("  handoff: desktop app container not found \u2014 skipped\n\n");
+        }
+      } else {
+        process.stdout.write(formatInventory(vsCodeInventory) + "\n\n");
+      }
+      const eventsFile = path8.join(area.root, "events.jsonl");
+      await fs8.writeFile(eventsFile, allEvents.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+      process.stdout.write(`total extracted: ${allEvents.length.toLocaleString("en-US")} events
+`);
+      process.stdout.write(`events file: ${eventsFile}
+`);
+      if (!ship) {
+        process.stdout.write("dry run \u2014 pass --ship to send these over the batch wire.\n");
+        return 0;
+      }
+      const config = loadShipConfig();
+      process.stdout.write(`shipping to ${config.apiBaseUrl} as ${config.toolInstallationId}\u2026
+`);
+      const result = await shipEvents(allEvents, config, (done, total) => {
+        process.stdout.write(`  ${done.toLocaleString("en-US")}/${total.toLocaleString("en-US")}\r`);
+      });
+      process.stdout.write("\n");
+      process.stdout.write(
+        `shipped: sent=${result.sent} accepted=${result.accepted} duplicate=${result.duplicate} rejected=${result.rejected} httpFailures=${result.httpFailures}
+`
+      );
+      if (result.duplicate > 0) {
+        process.stdout.write(
+          `  ${result.duplicate.toLocaleString("en-US")} already imported \u2014 the backend kept its existing copy and stored nothing new.
+`
+        );
+      }
+      for (const [reason, n] of Object.entries(result.rejectionReasons)) {
+        process.stdout.write(`  rejected ${reason}: ${n}
+`);
+      }
+      return result.accepted + result.duplicate > 0 && result.rejected === 0 && result.httpFailures === 0 ? 0 : 1;
+    }
+    case "fix-retention": {
+      const plan = await planClaudeRetentionFix(paths);
+      if (!plan.changeNeeded) {
+        process.stdout.write(
+          `cleanupPeriodDays is already ${plan.currentCleanupPeriodDays} \u2014 nothing to do.
+`
+        );
+        return 0;
+      }
+      process.stdout.write(
+        `${plan.settingsPath}: cleanupPeriodDays ${plan.currentCleanupPeriodDays ?? "(unset, 30 by default)"} \u2192 ${plan.proposedCleanupPeriodDays}
+`
+      );
+      if (rest.includes("--apply")) {
+        await applyClaudeRetentionFix(plan);
+        process.stdout.write("applied.\n");
+      } else {
+        process.stdout.write("dry run \u2014 pass --apply to write it.\n");
+      }
+      return 0;
+    }
+    default: {
+      process.stderr.write(
+        "usage: ascenda-history-import <scan [--json] | import [--ship] | fix-retention [--apply]>\n"
+      );
+      return command === void 0 || command === "--help" ? 0 : 2;
+    }
+  }
+}
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+);