@ascenda-one/cursor-hooks 0.1.16

package/dist/cli.js

@@ -0,0 +1,3847 @@
+#!/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 = classifyCommand2;
+    exports.isVerificationCommand = isVerificationCommand2;
+    function classifyCommand2(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 isVerificationCommand2(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/autonomyBand.js
+var require_autonomyBand = __commonJS({
+  "../packages/tool-kit/out/autonomyBand.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.autonomyBand = autonomyBand;
+    function autonomyBand(mode) {
+      if (typeof mode !== "string")
+        return "unknown";
+      return BAND_BY_MODE[mode] ?? "unknown";
+    }
+    var BAND_BY_MODE = {
+      plan: "planning",
+      default: "supervised",
+      accept_edits: "edits_auto",
+      // Two tokens, one band — and the reason the tokens stayed two. They differ
+      // in how the user arrived at the posture rather than in how much the agent
+      // may then do unasked, so today they read the same. If that ever stops being
+      // true, this line changes and the whole corpus re-reads correctly, because
+      // the wire never collapsed them.
+      auto: "delegated",
+      dont_ask: "delegated",
+      bypass_permissions: "unsupervised"
+    };
+  }
+});
+
+// ../packages/tool-kit/out/modelClassifier.js
+var require_modelClassifier = __commonJS({
+  "../packages/tool-kit/out/modelClassifier.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.classifyModelClass = classifyModelClass;
+    function classifyModelClass(raw) {
+      const candidate = raw;
+      if (candidate === void 0 || candidate === null)
+        return void 0;
+      if (typeof candidate !== "string")
+        return "unknown";
+      const value = candidate.trim().toLowerCase();
+      if (!value)
+        return void 0;
+      if (ROUTER_SENTINEL.test(value))
+        return "router:auto";
+      const vendor = readModelVendor(value);
+      if (vendor === void 0)
+        return "unknown";
+      for (const [pattern, modelClass] of TIER_PATTERNS_BY_VENDOR[vendor]) {
+        if (pattern.test(value))
+          return modelClass;
+      }
+      return UNKNOWN_TIER_BY_VENDOR[vendor];
+    }
+    function readModelVendor(value) {
+      for (const [pattern, vendor] of VENDOR_PATTERNS) {
+        if (pattern.test(value))
+          return vendor;
+      }
+      return void 0;
+    }
+    var ROUTER_SENTINEL = /^(?:[a-z0-9][a-z0-9._-]*\/)?(?:auto|default)$/;
+    var VENDOR_PATTERNS = [
+      [/\b(anthropic|claude|opus|sonnet|haiku|fable)\b/, "anthropic"],
+      [/\b(openai|gpt|o[1-9])\b/, "openai"],
+      [/\b(google|gemini|vertex)\b/, "google"],
+      // xAI carries no corporate prefix in any observed id — the family name is
+      // the whole marker, exactly as `claude` and `gemini` are for theirs.
+      [/\b(xai|grok)\b/, "xai"],
+      [/\b(ollama|llamacpp|on[-_]?device|local)\b/, "local"]
+    ];
+    var TIER_PATTERNS_BY_VENDOR = {
+      anthropic: [
+        [/\bopus\b/, "anthropic:opus"],
+        [/\bsonnet\b/, "anthropic:sonnet"],
+        [/\bhaiku\b/, "anthropic:haiku"],
+        [/\bfable\b/, "anthropic:fable"]
+      ],
+      openai: [[/\bgpt\b/, "openai:gpt"]],
+      google: [[/\bgemini\b/, "google:gemini"]],
+      // One tier for now. The line's coding variants (`grok-code-fast-1`) are the
+      // same tier word plus a suffix, and splitting them off would be inventing a
+      // distinction the ids do not yet draw — `<vendor>:unknown` is waiting for
+      // the day one does.
+      xai: [[/\bgrok\b/, "xai:grok"]],
+      local: [[/\b(ollama|llamacpp|on[-_]?device)\b/, "local:on_device"]]
+    };
+    var UNKNOWN_TIER_BY_VENDOR = {
+      anthropic: "anthropic:unknown",
+      openai: "openai:unknown",
+      google: "google:unknown",
+      xai: "xai:unknown",
+      local: "local:unknown"
+    };
+  }
+});
+
+// ../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 = bucketLinesChanged;
+    exports.bucketDurationMs = bucketDurationMs2;
+    function bucketLinesChanged(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 bucketDurationMs2(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.BUSINESS_DAY = void 0;
+    exports.isOutsideBusinessHours = isOutsideBusinessHours;
+    exports.isAfterHours = isAfterHours;
+    exports.utcOffsetMinutesAt = utcOffsetMinutesAt;
+    exports.localHourAt = localHourAt;
+    exports.BUSINESS_DAY = {
+      /** 0 = Sunday … 6 = Saturday. */
+      days: [1, 2, 3, 4, 5],
+      start: "09:00",
+      end: "17:00"
+    };
+    function isOutsideBusinessHours(at = /* @__PURE__ */ new Date(), opts = {}) {
+      const days = opts.days ?? exports.BUSINESS_DAY.days;
+      if (!days.includes(at.getDay()))
+        return true;
+      const minutes = at.getHours() * 60 + at.getMinutes();
+      const start = parseTimeToMinutes(opts.start ?? exports.BUSINESS_DAY.start, 9 * 60);
+      const end = parseTimeToMinutes(opts.end ?? exports.BUSINESS_DAY.end, 17 * 60);
+      if (start >= end)
+        return false;
+      return minutes < start || minutes >= end;
+    }
+    function isAfterHours(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 utcOffsetMinutesAt(at) {
+      return -at.getTimezoneOffset();
+    }
+    function localHourAt(at, utcOffsetMinutes) {
+      const shifted = new Date(at.getTime() + utcOffsetMinutes * 6e4);
+      return shifted.getUTCHours();
+    }
+  }
+});
+
+// ../packages/tool-contract/out/metricKeys.js
+var require_metricKeys = __commonJS({
+  "../packages/tool-contract/out/metricKeys.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.METRIC_KEYS = void 0;
+    exports.backendMetricKeys = backendMetricKeys;
+    var CONTEXT_WINDOW_CANONICAL_ALIASES = [
+      "contextWindowPeakPct",
+      "context_window_peak_pct",
+      "contextWindowPct",
+      "context_window_pct"
+    ];
+    var CONTEXT_WINDOW_CURSOR_PERCENT_ALIASES = ["contextUsagePercent"];
+    exports.METRIC_KEYS = {
+      // ── Read by a backend reader ────────────────────────────────────────────
+      contextWindowPeakPct: {
+        readBy: ["backend", "handoff"],
+        backendAliases: CONTEXT_WINDOW_CANONICAL_ALIASES,
+        unit: "fraction of the context window (0\u20131; uncapped for >200k contexts)",
+        note: "Claude Code reports a true per-session peak. Cursor reports its composer's last known occupancy under the same key \u2014 the closest its store can answer, and not the same measurement."
+      },
+      contextUsagePercent: {
+        readBy: ["backend", "handoff"],
+        backendAliases: CONTEXT_WINDOW_CURSOR_PERCENT_ALIASES,
+        unit: "percent (0\u2013100)",
+        note: "Cursor's own column name. Superseded by contextWindowPeakPct on the wire; kept because the handoff reads it and imported rows carry it. Unit-explicit on the backend: always divided by 100, never put through the fraction-or-percent heuristic."
+      },
+      promptCount: { readBy: ["backend", "handoff"], backendAliases: ["promptCount", "prompt_count"] },
+      sessionMinutes: { readBy: ["backend"], backendAliases: ["sessionMinutes", "session_minutes"], unit: "minutes" },
+      durationBucket: { readBy: ["backend", "handoff"], backendAliases: ["durationBucket", "duration_bucket"] },
+      afterHoursPrompts: { readBy: ["backend", "handoff"], backendAliases: ["afterHoursPrompts", "after_hours_prompts"] },
+      inputTokens: { readBy: ["backend"], backendAliases: ["inputTokens", "input_tokens"], unit: "tokens" },
+      outputTokens: { readBy: ["backend"], backendAliases: ["outputTokens", "output_tokens"], unit: "tokens" },
+      cacheReadTokens: { readBy: ["backend"], backendAliases: ["cacheReadTokens", "cache_read_tokens"], unit: "tokens" },
+      queuedPrompts: { readBy: ["backend"], backendAliases: ["queuedPrompts", "queued_prompts"] },
+      linesChangedBucket: { readBy: ["backend"], backendAliases: ["linesChangedBucket", "lines_changed_bucket"] },
+      // ── Read by the local handoff only ──────────────────────────────────────
+      activeMinutes: { readBy: ["handoff"], unit: "minutes" },
+      /**
+       * The two halves of `activeMinutes`, and deliberately two keys.
+       *
+       * They partition it exactly, so a reader can add them — but there is no
+       * third key holding the sum, because the sum is `activeMinutes` and it
+       * already exists. Presenting one combined "active" figure in place of these
+       * is the thing the split was added to stop: an hour of typing and an hour of
+       * watching an agent work are not the same hour, and a single number says
+       * they are.
+       */
+      handsOnMinutes: {
+        readBy: ["handoff"],
+        unit: "minutes",
+        note: "Active time immediately preceding a human prompt \u2014 the only interval a transcript can show a person present for, because the prompt at its end is the evidence."
+      },
+      agentSupervisingMinutes: {
+        readBy: ["handoff"],
+        unit: "minutes",
+        note: "The remaining active time: the agent was working and the person was not typing. NOT a claim that anyone watched it \u2014 nothing in a transcript could show that. Never render as attention."
+      },
+      // The split's honesty counters. Read by neither the backend nor the handoff
+      // on purpose: they exist so a thin or posture-blind session can be told from
+      // a complete one, and a reader that ignores them is choosing to, rather than
+      // being unable to.
+      activeSplitInstants: {
+        readBy: ["diagnostic"],
+        note: "Distinct timestamps the split ran over, after collapsing ties. The denominator: two minutes off four instants and off four hundred are not the same measurement."
+      },
+      activeSplitUndatedLines: {
+        readBy: ["diagnostic"],
+        note: "Known lines carrying a timestamp that would not parse. Absent from the timeline, so both halves are short by an unknown amount and only this says so."
+      },
+      activeSplitUnposturedInstants: {
+        readBy: ["diagnostic"],
+        note: "Instants reached before any permissionMode had been declared. Their supervising time lands in the unknown band, which is a blind spot rather than a posture."
+      },
+      afterHoursRequests: { readBy: ["handoff"] },
+      approximateLintErrorsCount: { readBy: ["handoff"] },
+      canceledCount: { readBy: ["handoff"] },
+      chatEditCount: { readBy: ["handoff"] },
+      compactionCount: {
+        readBy: ["handoff"],
+        note: "The backend counts context_compression_* event rows, not this key. Both are emitted; this one is for the handoff."
+      },
+      contextWindowPeakTokens: {
+        readBy: ["handoff"],
+        unit: "tokens",
+        note: "The measured quantity, with no assumed denominator. Prefer this to the ratio for any within-person baseline."
+      },
+      date: { readBy: ["handoff"] },
+      errorCount: { readBy: ["handoff"] },
+      filesChangedCount: { readBy: ["handoff"] },
+      humanChangesCount: { readBy: ["handoff"] },
+      linesAdded: { readBy: ["handoff"] },
+      linesRemoved: { readBy: ["handoff"] },
+      primaryModel: { readBy: ["handoff"] },
+      requestCount: { readBy: ["handoff"] },
+      sessionStartedAt: { readBy: ["handoff"] },
+      subagentComposers: { readBy: ["handoff"] },
+      subagentToolCallCount: {
+        readBy: ["handoff"],
+        note: "Claude Code only: calls made inside subagent transcripts, kept out of toolCallCount so the main-loop count matches what the wire events carry."
+      },
+      subagentTranscripts: { readBy: ["handoff"] },
+      toolCallCount: {
+        readBy: ["handoff"],
+        note: "The backend counts ai_tool_call_started event rows, not this key \u2014 same split as compactionCount. Deduplicated on the tool-call id; see each extractor for what one call means in its store."
+      },
+      toolCallsUndated: {
+        readBy: ["handoff"],
+        note: "Cursor only: calls whose every record carries an empty createdAt. Counted in toolCallCount, but no event exists for them \u2014 the wire total is smaller than this session count by exactly this number."
+      },
+      toolFailureCount: { readBy: ["handoff"] },
+      totalEntryCount: { readBy: ["handoff"] },
+      userModifiedEditCount: {
+        readBy: ["handoff"],
+        note: "Null, never 0 \u2014 Claude Code never sets userModified true, so 0 would assert 'no AI edit was ever corrected by hand'."
+      },
+      // ── Diagnostic: read by nobody, on purpose ──────────────────────────────
+      abandonedPromptCount: { readBy: ["diagnostic"] },
+      // Epoch-marker metrics. The marker is local-only and never reaches the wire
+      // (see EXTRACTION_EPOCH_KIND), but it travels as a NormalizedHistoricalEvent
+      // and so is keyed by the same vocabulary.
+      windowOldest: { readBy: ["handoff"], note: "Oldest event the extraction saw \u2014 the marker's left edge." },
+      windowNewest: { readBy: ["handoff"], note: "Newest event the extraction saw \u2014 the marker's right edge." },
+      projectsWithNoReadableTranscript: { readBy: ["diagnostic"] },
+      unparsedComposerHeaders: { readBy: ["diagnostic"] },
+      unknownComposerHeaderTypes: { readBy: ["diagnostic"] },
+      orphanedBubbles: { readBy: ["diagnostic"] },
+      orphanedSubagentBubbles: { readBy: ["diagnostic"] },
+      sessionsWithoutTimeline: { readBy: ["diagnostic"] },
+      emptyComposers: { readBy: ["diagnostic"] },
+      apiErrorCount: { readBy: ["diagnostic"] },
+      assistantTurns: { readBy: ["diagnostic"] },
+      compactionAutoCount: { readBy: ["diagnostic"] },
+      compactionManualCount: { readBy: ["diagnostic"] },
+      editDayCount: { readBy: ["diagnostic"] },
+      emptyChatSessions: { readBy: ["diagnostic"] },
+      gitBranch: { readBy: ["diagnostic"] },
+      linesChanged: { readBy: ["diagnostic"] },
+      malformedChatSessionLines: { readBy: ["diagnostic"] },
+      malformedHistoryEntries: { readBy: ["diagnostic"] },
+      mode: { readBy: ["diagnostic"] },
+      modelCount: { readBy: ["diagnostic"] },
+      modelSwitchCount: { readBy: ["diagnostic"] },
+      rapidRepromptCount: { readBy: ["diagnostic"] },
+      schemaUnreadable: { readBy: ["diagnostic"] },
+      sessionCount: { readBy: ["diagnostic"] },
+      sessionsFromBubbleTimeline: { readBy: ["diagnostic"] },
+      sessionsFromCheckpointTimeline: { readBy: ["diagnostic"] },
+      sessionsFromRecencyTimeline: { readBy: ["diagnostic"] },
+      subagentAssistantTurns: { readBy: ["diagnostic"] },
+      subagentPrompts: { readBy: ["diagnostic"] },
+      subagentTokensTotal: { readBy: ["diagnostic"] },
+      toolName: {
+        readBy: ["diagnostic"],
+        note: "Set per ai_tool_call_started event by #43's extractors and shipped in wire metadata, but no reader resolves it server-side yet (the backend's ToolName column is MCP audit, not telemetry). Registered after the fact: #38 and #43 merged past each other, and the union caught it on the next compile \u2014 metaLines all over again."
+      },
+      toolResultCount: { readBy: ["diagnostic"] },
+      toolResultErrorCount: { readBy: ["diagnostic"] },
+      unknownBubbles: { readBy: ["diagnostic"] },
+      unknownLines: { readBy: ["diagnostic"] },
+      metaLines: {
+        readBy: ["diagnostic"],
+        note: 'Recognised-but-skipped transcript machinery (file-history-snapshot, queued-command, \u2026). Split out of unknownLines by #43 so that number keeps meaning "a type nobody has looked at". Registered here after the fact: #41 and #43 merged past each other, and the union caught it on the next compile \u2014 which is this module doing its job.'
+      },
+      unparsedBubbles: { readBy: ["diagnostic"] },
+      unparsedChatSessionFiles: { readBy: ["diagnostic"] },
+      unparsedHistoryFiles: { readBy: ["diagnostic"] },
+      unparsedLines: { readBy: ["diagnostic"] },
+      unreadableChatSessionFiles: { readBy: ["diagnostic"] },
+      unreadableHistoryFiles: { readBy: ["diagnostic"] },
+      unrecognisedChatSessionFiles: { readBy: ["diagnostic"] }
+    };
+    function backendMetricKeys() {
+      return Object.entries(exports.METRIC_KEYS).filter(([, spec]) => spec.readBy.includes("backend")).map(([key, spec]) => [key, spec.backendAliases ?? [key]]);
+    }
+  }
+});
+
+// ../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.backendMetricKeys = exports.METRIC_KEYS = 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.TOOL_EVENT_DELIVERED_STATUSES = exports.IDEMPOTENCY_KEY_MAX_LENGTH = exports.EVENT_METADATA_FIELDS = 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_METADATA_FIELDS = [
+      "language",
+      "fileType",
+      "durationBucket",
+      "tokenPressureBucket",
+      "linesChangedBucket",
+      "commandClass",
+      "gitAction",
+      "milestoneKind",
+      "branchHash",
+      "autonomyMode",
+      "modelClass",
+      "modelId",
+      "userModified",
+      "outcome",
+      "trigger",
+      "promptClass",
+      "reason",
+      "afterHours",
+      "activity",
+      "message",
+      "host",
+      "toolName",
+      "simulated",
+      "relatedEventType",
+      "skillVersion",
+      "taskFingerprint",
+      "importKey",
+      "extractionId",
+      "importSchema"
+    ];
+    exports.IDEMPOTENCY_KEY_MAX_LENGTH = 128;
+    exports.TOOL_EVENT_DELIVERED_STATUSES = ["accepted", "duplicate"];
+    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";
+    var metricKeys_1 = require_metricKeys();
+    Object.defineProperty(exports, "METRIC_KEYS", { enumerable: true, get: function() {
+      return metricKeys_1.METRIC_KEYS;
+    } });
+    Object.defineProperty(exports, "backendMetricKeys", { enumerable: true, get: function() {
+      return metricKeys_1.backendMetricKeys;
+    } });
+  }
+});
+
+// ../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.mintIdempotencyKey = mintIdempotencyKey;
+    exports.getString = getString2;
+    exports.getNumber = getNumber2;
+    exports.getNested = getNested;
+    exports.getNestedString = getNestedString2;
+    exports.getNestedNumber = getNestedNumber;
+    exports.inferOutcome = inferOutcome2;
+    exports.outcomeForHook = outcomeForHook;
+    exports.looksLikeCorrection = looksLikeCorrection2;
+    var node_crypto_1 = __require("node:crypto");
+    var tool_contract_1 = require_out();
+    function mintIdempotencyKey() {
+      const key = (0, node_crypto_1.randomUUID)();
+      if (key.length > tool_contract_1.IDEMPOTENCY_KEY_MAX_LENGTH)
+        throw new Error("idempotency key exceeds the wire limit");
+      return key;
+    }
+    function getString2(input, keys) {
+      for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string" && value.trim())
+          return value;
+      }
+      return void 0;
+    }
+    function getNumber2(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, path2) {
+      let current = input;
+      for (const segment of path2) {
+        if (!current || typeof current !== "object")
+          return void 0;
+        current = current[segment];
+      }
+      return current;
+    }
+    function getNestedString2(input, paths) {
+      for (const path2 of paths) {
+        const value = getNested(input, path2);
+        if (typeof value === "string" && value.trim())
+          return value;
+      }
+      return void 0;
+    }
+    function getNestedNumber(input, paths) {
+      for (const path2 of paths) {
+        const value = getNested(input, path2);
+        if (typeof value === "number" && Number.isFinite(value))
+          return value;
+      }
+      return void 0;
+    }
+    function inferOutcome2(input) {
+      const exitCode = getNumber2(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 = getString2(input, ["error", "errorMessage"]) ?? getNestedString2(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 looksLikeCorrection2(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-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 fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __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 os2.homedir();
+      if (value.startsWith("~/"))
+        return path2.join(os2.homedir(), value.slice(2));
+      return path2.resolve(value);
+    }
+    function resolveEventLogPath() {
+      return expandUserPath(process.env[exports.EVENT_LOG_ENV_VAR]);
+    }
+    function appendEventLog(logFilePath, entry) {
+      try {
+        rotateIfLarge(logFilePath);
+        const dir = path2.dirname(logFilePath);
+        fs.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs.appendFileSync(logFilePath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+        if (process.platform !== "win32")
+          fs.chmodSync(logFilePath, 384);
+      } catch {
+      }
+    }
+    function rotateIfLarge(logFilePath) {
+      try {
+        if (fs.statSync(logFilePath).size < MAX_BYTES)
+          return;
+        fs.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 tool_contract_1 = require_out();
+    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 isDeliveredStatus(value) {
+      return typeof value === "string" && tool_contract_1.TOOL_EVENT_DELIVERED_STATUSES.includes(value);
+    }
+    function readSuccessBody(body) {
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        return { duplicates: 0 };
+      }
+      if (!parsed || typeof parsed !== "object")
+        return { duplicates: 0 };
+      const single = parsed.status;
+      if (isDeliveredStatus(single))
+        return { duplicates: single === "duplicate" ? 1 : 0 };
+      const raw = parsed.results;
+      if (!Array.isArray(raw))
+        return { duplicates: 0 };
+      const results = [];
+      for (const item of raw) {
+        if (!item || typeof item !== "object")
+          continue;
+        const { index, status, reason } = item;
+        if (typeof index !== "number" || typeof status !== "string")
+          continue;
+        results.push({ index, status, ...typeof reason === "string" ? { reason } : {} });
+      }
+      return { duplicates: results.filter((item) => item.status === "duplicate").length, results };
+    }
+    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) {
+        const outcome = { result: "accepted", httpStatus: response.status };
+        let read = { duplicates: 0 };
+        try {
+          read = readSuccessBody(await response.text());
+        } catch {
+          read = { duplicates: 0 };
+        }
+        return {
+          ...outcome,
+          ...read.duplicates > 0 ? { duplicates: read.duplicates } : {},
+          ...read.results !== void 0 ? { results: read.results } : {}
+        };
+      }
+      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.ascendaHome = ascendaHome;
+    exports.defaultTokenFilePath = defaultTokenFilePath;
+    exports.persistEventWriteToken = persistEventWriteToken;
+    exports.listPersistedToolInstallationIds = listPersistedToolInstallationIds;
+    exports.readTokenFile = readTokenFile;
+    exports.sanitizeFilePart = sanitizeFilePart;
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    function ascendaHome() {
+      return process.env.ASCENDA_HOME ?? path2.join(os2.homedir(), ".ascenda");
+    }
+    function defaultTokenFilePath(toolInstallationId) {
+      return path2.join(ascendaHome(), "tokens", sanitizeFilePart(toolInstallationId));
+    }
+    function persistEventWriteToken(tokenFilePath, token) {
+      const dir = path2.dirname(tokenFilePath);
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs.writeFileSync(tokenFilePath, token, { encoding: "utf8", mode: 384 });
+      if (process.platform !== "win32") {
+        fs.chmodSync(dir, 448);
+        fs.chmodSync(tokenFilePath, 384);
+      }
+    }
+    function listPersistedToolInstallationIds(toolType) {
+      const prefix = `${sanitizeFilePart(toolType)}_`;
+      const dir = path2.join(ascendaHome(), "tokens");
+      let names;
+      try {
+        names = fs.readdirSync(dir);
+      } catch {
+        return [];
+      }
+      const ids = [];
+      for (const name of names.sort()) {
+        if (!name.startsWith(prefix) || name.length === prefix.length)
+          continue;
+        const file = path2.join(dir, name);
+        try {
+          if (!fs.statSync(file).isFile())
+            continue;
+        } catch {
+          continue;
+        }
+        if (readTokenFile(file) === void 0)
+          continue;
+        ids.push(`${toolType}:${name.slice(prefix.length)}`);
+      }
+      return ids;
+    }
+    function readTokenFile(tokenFilePath) {
+      try {
+        if (!fs.existsSync(tokenFilePath))
+          return void 0;
+        const value = fs.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.unresolvedToolInstallationId = unresolvedToolInstallationId;
+    exports.unresolvedStateFilePath = unresolvedStateFilePath;
+    exports.readCollectorState = readCollectorState;
+    exports.recordSendOutcome = recordSendOutcome;
+    exports.recordOutboxDiscard = recordOutboxDiscard;
+    exports.shouldAnnounceFailure = shouldAnnounceFailure;
+    exports.markFailureNotified = markFailureNotified;
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    var tokenStore_1 = require_tokenStore();
+    function defaultStateFilePath(toolInstallationId) {
+      const dir = process.env.ASCENDA_STATE_DIR?.trim();
+      const base = dir ? dir : path2.join(os2.homedir(), ".ascenda", "state");
+      return path2.join(base, `${(0, tokenStore_1.sanitizeFilePart)(toolInstallationId)}.json`);
+    }
+    function unresolvedToolInstallationId(toolType) {
+      return `${toolType}:unresolved`;
+    }
+    function unresolvedStateFilePath(toolType) {
+      return defaultStateFilePath(unresolvedToolInstallationId(toolType));
+    }
+    function readCollectorState(stateFilePath) {
+      try {
+        if (!fs.existsSync(stateFilePath))
+          return void 0;
+        const raw = fs.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 } : {},
+        // Cumulative by design: a send outcome, success included, never erases
+        // the record of what the outbox had to throw away.
+        ...previous?.outboxDiscarded !== void 0 ? { outboxDiscarded: previous.outboxDiscarded } : {}
+      };
+      writeStateFile(stateFilePath, next);
+      return next;
+    }
+    function recordOutboxDiscard(stateFilePath, toolInstallationId, discard) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const previous = readCollectorState(stateFilePath);
+      const next = {
+        ...previous ?? { lastAttemptAt: now, consecutiveFailures: 0 },
+        toolInstallationId,
+        lastOutcome: "outbox_discarded",
+        outboxDiscarded: {
+          total: (previous?.outboxDiscarded?.total ?? 0) + discard.count,
+          lastAt: now,
+          lastCount: discard.count,
+          lastReasons: discard.reasons,
+          ...discard.oldestQueuedAt !== void 0 ? { lastOldestQueuedAt: discard.oldestQueuedAt } : {}
+        }
+      };
+      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 = path2.dirname(stateFilePath);
+        fs.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs.writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+        fs.renameSync(temporaryPath, stateFilePath);
+        if (process.platform !== "win32")
+          fs.chmodSync(stateFilePath, 384);
+      } catch {
+        try {
+          if (fs.existsSync(temporaryPath))
+            fs.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/outbox.js
+var require_outbox = __commonJS({
+  "../packages/tool-kit/out/outbox.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.DEFAULT_OUTBOX_DRAIN_BATCH_SIZE = exports.DEFAULT_OUTBOX_MAX_AGE_MS = exports.DEFAULT_OUTBOX_MAX_ENTRIES = exports.OUTBOX_DRAIN_ENV_VAR = void 0;
+    exports.outboxDrainEnabled = outboxDrainEnabled;
+    exports.defaultOutboxFilePath = defaultOutboxFilePath;
+    exports.appendToOutbox = appendToOutbox;
+    exports.readOutboxSummary = readOutboxSummary;
+    exports.claimOutbox = claimOutbox;
+    exports.enforceOutboxBounds = enforceOutboxBounds;
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var stateStore_1 = require_stateStore();
+    var tokenStore_1 = require_tokenStore();
+    exports.OUTBOX_DRAIN_ENV_VAR = "ASCENDA_OUTBOX_DRAIN";
+    exports.DEFAULT_OUTBOX_MAX_ENTRIES = 1e4;
+    exports.DEFAULT_OUTBOX_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+    exports.DEFAULT_OUTBOX_DRAIN_BATCH_SIZE = 100;
+    var ORPHANED_CLAIM_AGE_MS = 6e4;
+    var CLAIM_SUFFIX = ".draining";
+    function outboxDrainEnabled(env = process.env) {
+      const value = env[exports.OUTBOX_DRAIN_ENV_VAR]?.trim().toLowerCase();
+      return value === "1" || value === "true" || value === "yes" || value === "on";
+    }
+    function defaultOutboxFilePath(toolInstallationId) {
+      const dir = path2.dirname((0, stateStore_1.defaultStateFilePath)(toolInstallationId));
+      return path2.join(dir, `${(0, tokenStore_1.sanitizeFilePart)(toolInstallationId)}.outbox.jsonl`);
+    }
+    function appendToOutbox(outboxFilePath, payload, now = /* @__PURE__ */ new Date()) {
+      try {
+        const dir = path2.dirname(outboxFilePath);
+        fs.mkdirSync(dir, { recursive: true, mode: 448 });
+        const entry = { queuedAt: now.toISOString(), payload };
+        fs.appendFileSync(outboxFilePath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+        if (process.platform !== "win32")
+          fs.chmodSync(outboxFilePath, 384);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function readOutboxSummary(outboxFilePath) {
+      const files = [outboxFilePath, ...listClaimFiles(outboxFilePath)].filter((file) => fs.existsSync(file));
+      if (files.length === 0)
+        return void 0;
+      let depth = 0;
+      let unreadableLines = 0;
+      let oldestQueuedAt;
+      for (const file of files) {
+        const { entries, unreadable } = readEntries(file);
+        depth += entries.length;
+        unreadableLines += unreadable;
+        for (const entry of entries) {
+          if (oldestQueuedAt === void 0 || entry.queuedAt < oldestQueuedAt)
+            oldestQueuedAt = entry.queuedAt;
+        }
+      }
+      return { depth, unreadableLines, ...oldestQueuedAt !== void 0 ? { oldestQueuedAt } : {} };
+    }
+    function claimOutbox(outboxFilePath, now = Date.now()) {
+      const claimPath = `${outboxFilePath}.${process.pid}${CLAIM_SUFFIX}`;
+      const claimed = [];
+      try {
+        fs.renameSync(outboxFilePath, claimPath);
+        claimed.push(claimPath);
+      } catch {
+      }
+      let orphanIndex = 0;
+      for (const orphan of listClaimFiles(outboxFilePath)) {
+        if (claimed.includes(orphan))
+          continue;
+        try {
+          if (now - fs.statSync(orphan).mtimeMs < ORPHANED_CLAIM_AGE_MS)
+            continue;
+          const mine = `${claimPath}.${orphanIndex++}`;
+          fs.renameSync(orphan, mine);
+          claimed.push(mine);
+        } catch {
+        }
+      }
+      if (claimed.length === 0)
+        return void 0;
+      const entries = [];
+      let unreadable = 0;
+      for (const file of claimed) {
+        const read = readEntries(file);
+        entries.push(...read.entries);
+        unreadable += read.unreadable;
+      }
+      entries.sort((a, b) => a.queuedAt < b.queuedAt ? -1 : a.queuedAt > b.queuedAt ? 1 : 0);
+      let released = false;
+      return {
+        entries,
+        unreadable,
+        release(remainder) {
+          if (released)
+            return;
+          released = true;
+          if (remainder.length > 0) {
+            try {
+              fs.mkdirSync(path2.dirname(outboxFilePath), { recursive: true, mode: 448 });
+              fs.appendFileSync(outboxFilePath, remainder.map((entry) => `${JSON.stringify(entry)}
+`).join(""), { encoding: "utf8", mode: 384 });
+              if (process.platform !== "win32")
+                fs.chmodSync(outboxFilePath, 384);
+            } catch {
+              return;
+            }
+          }
+          for (const file of claimed) {
+            try {
+              fs.unlinkSync(file);
+            } catch {
+            }
+          }
+        }
+      };
+    }
+    function enforceOutboxBounds(entries, bounds, now = Date.now()) {
+      const reasons = {};
+      let oldestQueuedAt;
+      const cutoff = new Date(now - bounds.maxAgeMs).toISOString();
+      const fresh = [];
+      for (const entry of entries) {
+        if (entry.queuedAt < cutoff) {
+          reasons.age = (reasons.age ?? 0) + 1;
+          if (oldestQueuedAt === void 0 || entry.queuedAt < oldestQueuedAt)
+            oldestQueuedAt = entry.queuedAt;
+        } else {
+          fresh.push(entry);
+        }
+      }
+      const excess = Math.max(0, fresh.length - bounds.maxEntries);
+      if (excess > 0) {
+        reasons.count = excess;
+        const first = fresh[0]?.queuedAt;
+        if (first !== void 0 && (oldestQueuedAt === void 0 || first < oldestQueuedAt))
+          oldestQueuedAt = first;
+      }
+      const kept = excess > 0 ? fresh.slice(excess) : fresh;
+      const count = Object.values(reasons).reduce((sum, n) => sum + (n ?? 0), 0);
+      return { kept, discarded: { count, reasons, ...oldestQueuedAt !== void 0 ? { oldestQueuedAt } : {} } };
+    }
+    function listClaimFiles(outboxFilePath) {
+      const dir = path2.dirname(outboxFilePath);
+      const prefix = `${path2.basename(outboxFilePath)}.`;
+      try {
+        return fs.readdirSync(dir).filter((name) => name.startsWith(prefix) && name.includes(CLAIM_SUFFIX)).map((name) => path2.join(dir, name)).sort();
+      } catch {
+        return [];
+      }
+    }
+    function readEntries(file) {
+      let raw;
+      try {
+        raw = fs.readFileSync(file, "utf8");
+      } catch {
+        return { entries: [], unreadable: 0 };
+      }
+      const entries = [];
+      let unreadable = 0;
+      for (const line of raw.split("\n")) {
+        if (!line.trim())
+          continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (!parsed || typeof parsed !== "object" || typeof parsed.queuedAt !== "string" || !parsed.payload || typeof parsed.payload !== "object") {
+            unreadable += 1;
+            continue;
+          }
+          entries.push({ queuedAt: parsed.queuedAt, payload: parsed.payload });
+        } catch {
+          unreadable += 1;
+        }
+      }
+      return { entries, unreadable };
+    }
+  }
+});
+
+// ../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 outbox_1 = require_outbox();
+    var tokenStore_1 = require_tokenStore();
+    var stateStore_1 = require_stateStore();
+    var payload_1 = require_payload();
+    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(),
+        idempotencyKey: (0, payload_1.mintIdempotencyKey)(),
+        utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+        sessionId: identity.sessionId ?? void 0,
+        workspaceHash: identity.workspaceHash ?? void 0,
+        projectHash: identity.projectHash ?? 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;
+      lastDrain;
+      /** One outbox pass per sender, i.e. per hook process. The hook is on the user's critical path. */
+      outboxServiced = false;
+      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(),
+          idempotencyKey: (0, payload_1.mintIdempotencyKey)(),
+          utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+          severity: "low",
+          sessionId: this.config.sessionId ?? void 0,
+          workspaceHash: this.config.workspaceHash ?? void 0,
+          projectHash: this.config.projectHash ?? 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(),
+          idempotencyKey: (0, payload_1.mintIdempotencyKey)(),
+          utcOffsetMinutes: (0, afterHours_1.utcOffsetMinutesAt)(/* @__PURE__ */ new Date()),
+          severity: "low",
+          sessionId: this.config.sessionId ?? void 0,
+          workspaceHash: this.config.workspaceHash ?? void 0,
+          projectHash: this.config.projectHash ?? 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.
+       *
+       * The outbox is serviced first, once per process. If that pass just watched
+       * the ingest door refuse a batch, the live event is not offered to the same
+       * door a second time in the same instant: it inherits the pass's outcome,
+       * and a retryable one puts it straight in the queue. That is what keeps a
+       * hook during an outage to one bounded round trip instead of three.
+       */
+      async post(payload) {
+        const halted = await this.serviceOutbox();
+        let outcome;
+        let queued = false;
+        if (halted) {
+          outcome = halted;
+          queued = this.isRetryable(outcome) && this.enqueue(payload);
+        } else {
+          outcome = await this.attempt(payload);
+          queued = this.isRetryable(outcome) && this.enqueue(payload);
+        }
+        this.lastState = (0, stateStore_1.recordSendOutcome)(this.stateFilePath(), this.config.toolInstallationId, outcome.result, {
+          httpStatus: outcome.httpStatus,
+          errorCode: outcome.errorCode,
+          detail: queued ? withNote(outcome.detail, "queued in outbox") : outcome.detail
+        });
+        this.log(payload, outcome.result, queued ? "queued" : void 0);
+        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.
+       *
+       * Both recoveries resend the same `payload` object, so the `idempotencyKey`
+       * minted at construction is what the server sees on every attempt. That is
+       * what lets a retry of a request the server actually processed (a timeout
+       * after the write, a 502 from a proxy in front of a 200) come back
+       * `duplicate` instead of landing twice. Never rebuild the payload here.
+       *
+       * When the retry fails too, the caller queues the payload: anything longer
+       * than the pause here is the outbox's job, not another in-process wait.
+       */
+      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 (this.isRetryable(outcome)) {
+          await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+          return (0, http_1.postToolEvent)(this.config.apiBaseUrl, this.eventWriteToken, payload, this.signal());
+        }
+        return outcome;
+      }
+      /** A failure that never reached a verdict. Replaying can change the answer. */
+      isRetryable(outcome) {
+        return outcome.result === "transport_error" && (outcome.httpStatus === void 0 || (0, http_1.isRetryableStatus)(outcome.httpStatus));
+      }
+      /**
+       * Keeps a refused payload for a later drain. Returns whether it is now on
+       * disk; when it is not (read-only home, full disk) the event is lost and the
+       * journal's detail says so instead of implying it was kept.
+       */
+      enqueue(payload) {
+        return (0, outbox_1.appendToOutbox)(this.outboxFilePath(), payload);
+      }
+      /**
+       * One pass over the outbox: claim it, apply the bounds, and — when sending
+       * is enabled — offer one batch, oldest first, to the batch door.
+       *
+       * Entries are deleted on `accepted` or `duplicate`, decided on `status`
+       * alone; `reason` is for a person reading their logs. A per-item `rejected`
+       * is a verdict, and replaying a verdict cannot change it, so those are
+       * discarded and journaled rather than kept forever. A whole-batch
+       * `validation_failed` is the same verdict for every item. Anything else
+       * stops the pass with everything still on disk, and is returned so the live
+       * send can skip a door that just refused.
+       *
+       * Never loops, never backs off, never sends more than one batch: the next
+       * hook invocation is usually seconds away, and a hook sitting in a retry
+       * loop delays the tool call the user is waiting on.
+       */
+      async serviceOutbox() {
+        if (this.outboxServiced)
+          return void 0;
+        this.outboxServiced = true;
+        const sendEnabled = this.config.outboxDrain ?? (0, outbox_1.outboxDrainEnabled)();
+        const claimed = (0, outbox_1.claimOutbox)(this.outboxFilePath());
+        if (!claimed) {
+          this.lastDrain = { found: 0, discarded: 0, delivered: 0, remaining: 0, sendEnabled };
+          return void 0;
+        }
+        const found = claimed.entries.length + claimed.unreadable;
+        const { kept, discarded } = (0, outbox_1.enforceOutboxBounds)(claimed.entries, {
+          maxEntries: this.config.outboxMaxEntries ?? outbox_1.DEFAULT_OUTBOX_MAX_ENTRIES,
+          maxAgeMs: this.config.outboxMaxAgeMs ?? outbox_1.DEFAULT_OUTBOX_MAX_AGE_MS
+        });
+        if (claimed.unreadable > 0) {
+          discarded.count += claimed.unreadable;
+          discarded.reasons.unreadable = claimed.unreadable;
+        }
+        let discardedTotal = this.journalDiscard(discarded);
+        if (!sendEnabled || kept.length === 0) {
+          claimed.release(kept);
+          this.lastDrain = { found, discarded: discardedTotal, delivered: 0, remaining: kept.length, sendEnabled };
+          return void 0;
+        }
+        const batchSize = this.config.outboxDrainBatchSize ?? outbox_1.DEFAULT_OUTBOX_DRAIN_BATCH_SIZE;
+        const batch = kept.slice(0, batchSize);
+        const rest = kept.slice(batchSize);
+        const outcome = await this.attemptBatch(batch.map((entry) => entry.payload));
+        let delivered = [];
+        let rejected = [];
+        let undecided = [];
+        let halted;
+        if (outcome.result === "accepted") {
+          if (outcome.results === void 0) {
+            delivered = batch;
+          } else {
+            const byIndex = new Map(outcome.results.map((item) => [item.index, item.status]));
+            for (const [index, entry] of batch.entries()) {
+              const status = byIndex.get(index);
+              if (status !== void 0 && tool_contract_1.TOOL_EVENT_DELIVERED_STATUSES.includes(status))
+                delivered.push(entry);
+              else if (status === "rejected")
+                rejected.push(entry);
+              else
+                undecided.push(entry);
+            }
+          }
+        } else if (outcome.result === "validation_failed") {
+          rejected = batch;
+        } else {
+          undecided = batch;
+          halted = outcome;
+        }
+        if (rejected.length > 0) {
+          discardedTotal += this.journalDiscard({ count: rejected.length, reasons: { rejected: rejected.length }, oldestQueuedAt: rejected[0]?.queuedAt });
+        }
+        if (!halted) {
+          this.lastState = (0, stateStore_1.recordSendOutcome)(this.stateFilePath(), this.config.toolInstallationId, outcome.result, {
+            httpStatus: outcome.httpStatus,
+            errorCode: outcome.errorCode,
+            detail: withNote(outcome.detail, `outbox drain: ${delivered.length} delivered`)
+          });
+        }
+        for (const entry of delivered)
+          this.log(entry.payload, "accepted", "drained");
+        const remainder = [...undecided, ...rest];
+        claimed.release(remainder);
+        this.lastDrain = {
+          found,
+          discarded: discardedTotal,
+          delivered: delivered.length,
+          remaining: remainder.length,
+          sendEnabled,
+          ...halted ? { halted: halted.result } : {}
+        };
+        return halted;
+      }
+      /** The batch door, with the same single token renewal as the live path and no in-process retry. */
+      async attemptBatch(payloads) {
+        const outcome = await (0, http_1.postToolEventsBatch)(this.config.apiBaseUrl, this.eventWriteToken, payloads, this.signal());
+        if (outcome.result !== "auth_failed")
+          return outcome;
+        if (!await this.renewEventToken())
+          return outcome;
+        return (0, http_1.postToolEventsBatch)(this.config.apiBaseUrl, this.eventWriteToken, payloads, this.signal());
+      }
+      journalDiscard(discard) {
+        if (discard.count === 0)
+          return 0;
+        const reasons = discard.reasons;
+        this.lastState = (0, stateStore_1.recordOutboxDiscard)(this.stateFilePath(), this.config.toolInstallationId, {
+          count: discard.count,
+          reasons,
+          oldestQueuedAt: discard.oldestQueuedAt
+        });
+        return discard.count;
+      }
+      /**
+       * 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;
+      }
+      /** What this sender's one outbox pass did; undefined before the first send. */
+      get drain() {
+        return this.lastDrain;
+      }
+      stateFilePath() {
+        return this.config.stateFilePath ?? (0, stateStore_1.defaultStateFilePath)(this.config.toolInstallationId);
+      }
+      outboxFilePath() {
+        return this.config.outboxFilePath ?? (0, outbox_1.defaultOutboxFilePath)(this.config.toolInstallationId);
+      }
+      /**
+       * 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, outbox) {
+        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, ...outbox ? { outbox } : {} });
+      }
+      /** Never throws: a renewal that errors is a failed renewal, not a failed turn. */
+      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;
+    function withNote(detail, note) {
+      return detail ? `${detail} (${note})` : note;
+    }
+  }
+});
+
+// ../packages/tool-kit/out/contextRegistry.js
+var require_contextRegistry = __commonJS({
+  "../packages/tool-kit/out/contextRegistry.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.workContextRegistryFilePath = workContextRegistryFilePath;
+    exports.readWorkContextRegistry = readWorkContextRegistry;
+    exports.recordWorkContext = recordWorkContext;
+    exports.recordWorkContextAlias = recordWorkContextAlias;
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    var MAX_PATHS_PER_ENTRY = 8;
+    function workContextRegistryFilePath() {
+      return path2.join(os2.homedir(), ".ascenda", "work-contexts.json");
+    }
+    function readWorkContextRegistry(registryFilePath = workContextRegistryFilePath()) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(registryFilePath, "utf8"));
+        if (parsed && parsed.version === 1 && parsed.contexts && typeof parsed.contexts === "object") {
+          return parsed;
+        }
+      } catch {
+      }
+      return { version: 1, contexts: {} };
+    }
+    function recordWorkContext(context, options) {
+      if (!context)
+        return false;
+      const updates = [];
+      if (context.projectHash && context.projectLabel) {
+        updates.push({ hash: context.projectHash, kind: "project", label: context.projectLabel, observedPath: context.projectPath ?? context.workspacePath });
+      }
+      if (context.workspaceHash && context.workspaceLabel && context.workspaceHash !== context.projectHash) {
+        updates.push({ hash: context.workspaceHash, kind: "workspace", label: context.workspaceLabel, observedPath: context.workspacePath });
+      }
+      return upsert(updates, options);
+    }
+    function recordWorkContextAlias(hash, label, observedPath, options) {
+      if (!hash || !label)
+        return false;
+      return upsert([{ hash, kind: "alias", label, observedPath: observedPath ?? null }], options);
+    }
+    function upsert(updates, options) {
+      if (updates.length === 0)
+        return false;
+      try {
+        const registryFilePath = options?.registryFilePath ?? workContextRegistryFilePath();
+        const nowIso = (options?.now ?? /* @__PURE__ */ new Date()).toISOString();
+        const registry = readWorkContextRegistry(registryFilePath);
+        let dirty = false;
+        for (const update of updates) {
+          const existing = registry.contexts[update.hash];
+          if (!existing) {
+            registry.contexts[update.hash] = {
+              kind: update.kind,
+              label: update.label,
+              paths: update.observedPath ? [update.observedPath] : [],
+              firstSeenAt: nowIso,
+              lastSeenAt: nowIso
+            };
+            dirty = true;
+            continue;
+          }
+          if (existing.kind === "alias" && update.kind !== "alias") {
+            existing.kind = update.kind;
+            dirty = true;
+          }
+          if (existing.label !== update.label && update.kind !== "alias") {
+            existing.label = update.label;
+            dirty = true;
+          }
+          if (update.observedPath && !existing.paths.includes(update.observedPath)) {
+            if (existing.paths.length < MAX_PATHS_PER_ENTRY)
+              existing.paths.push(update.observedPath);
+            dirty = true;
+          }
+          if (dayOf(existing.lastSeenAt) !== dayOf(nowIso)) {
+            existing.lastSeenAt = nowIso;
+            dirty = true;
+          }
+        }
+        if (!dirty)
+          return false;
+        writeRegistry(registryFilePath, registry);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function dayOf(iso) {
+      return iso.slice(0, 10);
+    }
+    function writeRegistry(registryFilePath, registry) {
+      const dir = path2.dirname(registryFilePath);
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+      const tmp = `${registryFilePath}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, `${JSON.stringify(registry, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+      fs.renameSync(tmp, registryFilePath);
+      if (process.platform !== "win32") {
+        fs.chmodSync(registryFilePath, 384);
+      }
+    }
+  }
+});
+
+// ../packages/tool-kit/out/credentials.js
+var require_credentials = __commonJS({
+  "../packages/tool-kit/out/credentials.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.credentialsFilePath = credentialsFilePath;
+    exports.readMachineCredentials = readMachineCredentials;
+    exports.writeMachineCredentials = writeMachineCredentials;
+    exports.writeTopLevelCredentials = writeTopLevelCredentials;
+    exports.readHostCredentials = readHostCredentials;
+    exports.writeHostCredentials = writeHostCredentials;
+    exports.removeHostCredentials = removeHostCredentials;
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var tokenStore_1 = require_tokenStore();
+    function credentialsFilePath() {
+      return path2.join((0, tokenStore_1.ascendaHome)(), "credentials.json");
+    }
+    function readMachineCredentials() {
+      try {
+        const raw = fs.readFileSync(credentialsFilePath(), "utf8").trim();
+        if (!raw)
+          return void 0;
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+          return void 0;
+        return parsed;
+      } catch {
+        return void 0;
+      }
+    }
+    function writeMachineCredentials(credentials) {
+      const file = credentialsFilePath();
+      fs.mkdirSync(path2.dirname(file), { recursive: true, mode: 448 });
+      fs.writeFileSync(file, `${JSON.stringify(credentials, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+      if (process.platform !== "win32") {
+        fs.chmodSync(path2.dirname(file), 448);
+        fs.chmodSync(file, 384);
+      }
+    }
+    function writeTopLevelCredentials(credentials) {
+      const existing = readMachineCredentials();
+      writeMachineCredentials({ ...credentials, ...existing?.tools ? { tools: existing.tools } : {} });
+    }
+    function readHostCredentials(host) {
+      const entry = readMachineCredentials()?.tools?.[host];
+      if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return void 0;
+      return entry;
+    }
+    function writeHostCredentials(host, credentials) {
+      const existing = readMachineCredentials() ?? {};
+      writeMachineCredentials({ ...existing, tools: { ...existing.tools ?? {}, [host]: credentials } });
+    }
+    function removeHostCredentials(host) {
+      const existing = readMachineCredentials();
+      if (!existing?.tools || !(host in existing.tools))
+        return;
+      const tools = { ...existing.tools };
+      delete tools[host];
+      const next = { ...existing };
+      if (Object.keys(tools).length)
+        next.tools = tools;
+      else
+        delete next.tools;
+      writeMachineCredentials(next);
+    }
+  }
+});
+
+// ../packages/tool-kit/out/forgeProject.js
+var require_forgeProject = __commonJS({
+  "../packages/tool-kit/out/forgeProject.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.forgeProjectHash = forgeProjectHash;
+    exports.parseForgeFullName = parseForgeFullName;
+    exports.readForgeFullName = readForgeFullName;
+    exports.forgeFullNameFromConfig = forgeFullNameFromConfig;
+    exports.recordForgeProjectAlias = recordForgeProjectAlias;
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var contextRegistry_1 = require_contextRegistry();
+    function forgeProjectHash(value) {
+      let h = 2166136261;
+      for (let i = 0; i < value.length; i++) {
+        h ^= value.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+      }
+      return h.toString(16).padStart(8, "0");
+    }
+    function parseForgeFullName(remoteUrl) {
+      if (!remoteUrl)
+        return null;
+      const trimmed = remoteUrl.trim();
+      if (!trimmed)
+        return null;
+      const scp = /^(?:[^@/]+@)?([^/:]+):(.+)$/.exec(trimmed);
+      const scheme = /^([a-z][a-z0-9+.-]*):\/\/(?:[^@/]*@)?([^/:]+)(?::\d+)?\/(.+)$/i.exec(trimmed);
+      let host;
+      let repoPath;
+      if (scheme) {
+        host = scheme[2];
+        repoPath = scheme[3];
+      } else if (scp && !/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+        host = scp[1];
+        repoPath = scp[2];
+      } else {
+        return null;
+      }
+      const normalizedHost = host.toLowerCase().replace(/^www\./, "");
+      if (normalizedHost !== "github.com")
+        return null;
+      const segments = repoPath.split("/").filter((segment) => segment.length > 0);
+      if (segments.length < 2)
+        return null;
+      const owner = segments[0];
+      const repo = segments[1].replace(/\.git$/, "");
+      if (!owner || !repo)
+        return null;
+      return `${owner}/${repo}`;
+    }
+    function readForgeFullName(repositoryRoot) {
+      if (!repositoryRoot)
+        return null;
+      let config;
+      try {
+        config = fs.readFileSync(path2.join(repositoryRoot, ".git", "config"), "utf8");
+      } catch {
+        return null;
+      }
+      return forgeFullNameFromConfig(config);
+    }
+    function forgeFullNameFromConfig(config) {
+      const remotes = /* @__PURE__ */ new Map();
+      let currentRemote = null;
+      for (const rawLine of config.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#") || line.startsWith(";"))
+          continue;
+        const section = /^\[([^\]]*)\]$/.exec(line);
+        if (section) {
+          const remote = /^remote\s+"(.*)"$/.exec(section[1].trim());
+          currentRemote = remote ? remote[1] : null;
+          continue;
+        }
+        if (!currentRemote)
+          continue;
+        const entry = /^url\s*=\s*(.*)$/.exec(line);
+        if (entry && !remotes.has(currentRemote))
+          remotes.set(currentRemote, entry[1].trim());
+      }
+      const ordered = [
+        ...remotes.has("origin") ? ["origin"] : [],
+        ...remotes.has("upstream") ? ["upstream"] : [],
+        ...[...remotes.keys()].filter((name) => name !== "origin" && name !== "upstream")
+      ];
+      for (const name of ordered) {
+        const fullName = parseForgeFullName(remotes.get(name));
+        if (fullName)
+          return fullName;
+      }
+      return null;
+    }
+    function recordForgeProjectAlias(context, options) {
+      try {
+        if (!context?.projectHash || !context.projectLabel || !context.projectPath)
+          return false;
+        const fullName = readForgeFullName(context.projectPath);
+        if (!fullName)
+          return false;
+        const variants = [fullName, fullName.toLowerCase()].filter((value, index, all) => all.indexOf(value) === index);
+        let wrote = false;
+        for (const variant of variants) {
+          const hash = forgeProjectHash(variant);
+          if (hash === context.projectHash || hash === context.workspaceHash)
+            continue;
+          if ((0, contextRegistry_1.recordWorkContextAlias)(hash, context.projectLabel, context.projectPath, options))
+            wrote = true;
+        }
+        return wrote;
+      } catch {
+        return false;
+      }
+    }
+  }
+});
+
+// ../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 = hashWithMachineSalt;
+    var crypto = __importStar(__require("crypto"));
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    function machineSaltFilePath() {
+      return path2.join(os2.homedir(), ".ascenda", "salt");
+    }
+    var cache = /* @__PURE__ */ new Map();
+    function readOrCreateMachineSalt(saltFilePath = machineSaltFilePath()) {
+      const hit = cache.get(saltFilePath);
+      if (hit)
+        return hit;
+      const dir = path2.dirname(saltFilePath);
+      fs.mkdirSync(dir, { recursive: true, mode: 448 });
+      let salt;
+      try {
+        salt = crypto.randomBytes(32).toString("hex");
+        fs.writeFileSync(saltFilePath, salt, { encoding: "utf8", mode: 384, flag: "wx" });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        salt = fs.readFileSync(saltFilePath, "utf8").trim();
+      }
+      if (process.platform !== "win32") {
+        fs.chmodSync(dir, 448);
+        fs.chmodSync(saltFilePath, 384);
+      }
+      cache.set(saltFilePath, salt);
+      return salt;
+    }
+    function hashWithMachineSalt(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/workContext.js
+var require_workContext = __commonJS({
+  "../packages/tool-kit/out/workContext.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.deriveWorkContext = deriveWorkContext;
+    exports.normalizeBranchName = normalizeBranchName;
+    exports.deriveBranchHash = deriveBranchHash;
+    exports.readBranchName = readBranchName;
+    exports.deriveBranchHashForCwd = deriveBranchHashForCwd;
+    var fs = __importStar(__require("fs"));
+    var path2 = __importStar(__require("path"));
+    var salt_1 = require_salt();
+    var MAX_WALK_DEPTH = 64;
+    function deriveWorkContext(cwd, saltFilePath) {
+      if (!cwd || !cwd.trim())
+        return null;
+      const startPath = stripTrailingSeparators(cwd.trim());
+      let roots = null;
+      try {
+        roots = resolveRepositoryRoots(startPath);
+      } catch {
+        roots = null;
+      }
+      if (!roots)
+        roots = inferRootsFromPath(startPath);
+      const workspacePath = roots?.checkoutRoot ?? startPath;
+      const workspaceLabel = basenameOf(workspacePath);
+      if (!workspaceLabel)
+        return null;
+      const projectPath = roots?.canonicalRoot ?? null;
+      const projectLabel = (projectPath ? basenameOf(projectPath) : null) ?? workspaceLabel;
+      return {
+        workspaceLabel,
+        projectLabel,
+        workspaceHash: (0, salt_1.hashWithMachineSalt)(workspaceLabel, saltFilePath),
+        projectHash: (0, salt_1.hashWithMachineSalt)(projectLabel, saltFilePath),
+        workspacePath,
+        projectPath
+      };
+    }
+    function resolveRepositoryRoots(startDir) {
+      if (!fs.existsSync(startDir))
+        return null;
+      let dir = startDir;
+      for (let depth = 0; depth < MAX_WALK_DEPTH; depth++) {
+        const dotGit = path2.join(dir, ".git");
+        let stat = null;
+        try {
+          stat = fs.statSync(dotGit);
+        } catch {
+          stat = null;
+        }
+        if (stat?.isDirectory())
+          return { checkoutRoot: dir, canonicalRoot: dir, gitDir: dotGit };
+        if (stat?.isFile()) {
+          const gitDir = readGitdirPointer(dotGit, dir);
+          const canonicalRoot = (gitDir ? worktreeParentRoot(gitDir) : null) ?? dir;
+          return { checkoutRoot: dir, canonicalRoot, gitDir };
+        }
+        const parent = path2.dirname(dir);
+        if (parent === dir)
+          return null;
+        dir = parent;
+      }
+      return null;
+    }
+    function readGitdirPointer(dotGitFile, containingDir) {
+      try {
+        const match = /^gitdir:\s*(.+)\s*$/m.exec(fs.readFileSync(dotGitFile, "utf8"));
+        if (!match)
+          return null;
+        return path2.resolve(containingDir, match[1].trim());
+      } catch {
+        return null;
+      }
+    }
+    function worktreeParentRoot(resolvedGitDir) {
+      const marker = `${path2.sep}.git${path2.sep}worktrees${path2.sep}`;
+      const idx = resolvedGitDir.indexOf(marker);
+      if (idx === -1)
+        return null;
+      return resolvedGitDir.slice(0, idx);
+    }
+    function inferRootsFromPath(startPath) {
+      const sep = startPath.includes("\\") && !startPath.includes("/") ? "\\" : "/";
+      const leading = /^[\\/]/.test(startPath) ? sep : "";
+      const segments = startPath.split(/[\\/]/).filter(Boolean);
+      const join2 = (count) => leading + segments.slice(0, count).join(sep);
+      for (let i = 0; i + 2 < segments.length; i++) {
+        if (segments[i] === ".claude" && segments[i + 1] === "worktrees") {
+          if (i === 0)
+            return null;
+          return { checkoutRoot: join2(i + 3), canonicalRoot: join2(i), gitDir: null };
+        }
+      }
+      for (let i = 0; i + 1 < segments.length; i++) {
+        const folder = segments[i];
+        const suffix = ["-worktrees", "-wt"].find((s) => folder.endsWith(s) && folder.length > s.length);
+        if (!suffix)
+          continue;
+        const repoName = folder.slice(0, -suffix.length);
+        const canonicalRoot = leading + [...segments.slice(0, i), repoName].join(sep);
+        return { checkoutRoot: join2(i + 2), canonicalRoot, gitDir: null };
+      }
+      return null;
+    }
+    function stripTrailingSeparators(value) {
+      let end = value.length;
+      while (end > 1 && (value[end - 1] === "/" || value[end - 1] === "\\"))
+        end--;
+      return value.slice(0, end);
+    }
+    function basenameOf(value) {
+      const segment = value.split(/[\\/]/).filter(Boolean).pop() ?? null;
+      return segment && segment.length > 0 ? segment : null;
+    }
+    var REFS_HEADS_PREFIX = "refs/heads/";
+    function normalizeBranchName(branch) {
+      if (!branch)
+        return null;
+      let name = branch.trim();
+      if (name.startsWith(REFS_HEADS_PREFIX))
+        name = name.slice(REFS_HEADS_PREFIX.length).trim();
+      if (!name || name === "HEAD")
+        return null;
+      return name;
+    }
+    function deriveBranchHash(branch, saltFilePath) {
+      const name = normalizeBranchName(branch);
+      if (!name)
+        return null;
+      try {
+        return (0, salt_1.hashWithMachineSalt)(name, saltFilePath);
+      } catch {
+        return null;
+      }
+    }
+    function readBranchName(cwd) {
+      if (!cwd || !cwd.trim())
+        return null;
+      let gitDir = null;
+      try {
+        gitDir = resolveRepositoryRoots(stripTrailingSeparators(cwd.trim()))?.gitDir ?? null;
+      } catch {
+        gitDir = null;
+      }
+      if (!gitDir)
+        return null;
+      let head;
+      try {
+        head = fs.readFileSync(path2.join(gitDir, "HEAD"), "utf8").trim();
+      } catch {
+        return null;
+      }
+      const match = /^ref:\s*(.+)$/.exec(head);
+      if (!match)
+        return null;
+      const ref = match[1].trim();
+      if (!ref.startsWith(REFS_HEADS_PREFIX))
+        return null;
+      return normalizeBranchName(ref);
+    }
+    function deriveBranchHashForCwd(cwd, saltFilePath) {
+      return deriveBranchHash(readBranchName(cwd), saltFilePath);
+    }
+  }
+});
+
+// ../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.MissingInstallationIdError = exports.DEFAULT_API_BASE_URL = void 0;
+    exports.resolveCliAgentInstallationId = resolveCliAgentInstallationId;
+    exports.resolveContextHashes = resolveContextHashes;
+    exports.loadCliAgentConfig = loadCliAgentConfig;
+    exports.deliverHookEvents = deliverHookEvents2;
+    var contextRegistry_1 = require_contextRegistry();
+    var credentials_1 = require_credentials();
+    var forgeProject_1 = require_forgeProject();
+    var eventLog_1 = require_eventLog();
+    var eventSender_1 = require_eventSender();
+    var stateStore_1 = require_stateStore();
+    var tokenStore_1 = require_tokenStore();
+    var workContext_1 = require_workContext();
+    exports.DEFAULT_API_BASE_URL = "https://api.ascenda.one";
+    var MissingInstallationIdError = class extends Error {
+      /** The token files that were considered — none, or too many to pick from. */
+      candidates;
+      toolType;
+      constructor(toolType, candidates, setupCommand) {
+        super(candidates.length === 0 ? `Not configured: no ASCENDA_TOOL_INSTALLATION_ID, no pairing in ~/.ascenda/credentials.json, and no ${toolType} token in ~/.ascenda/tokens/. Run: ${setupCommand}` : `Not configured: no ASCENDA_TOOL_INSTALLATION_ID, no pairing in ~/.ascenda/credentials.json, and ${candidates.length} ${toolType} tokens in ~/.ascenda/tokens/ (${candidates.join(", ")}) \u2014 refusing to guess. Export ASCENDA_TOOL_INSTALLATION_ID to choose one, or run: ${setupCommand}`);
+        this.name = "MissingInstallationIdError";
+        this.toolType = toolType;
+        this.candidates = candidates;
+      }
+    };
+    exports.MissingInstallationIdError = MissingInstallationIdError;
+    function resolveCliAgentInstallationId(toolType, identity = {}) {
+      const fromEnv = process.env.ASCENDA_TOOL_INSTALLATION_ID?.trim();
+      if (fromEnv)
+        return { toolInstallationId: qualify(toolType, fromEnv), source: "env" };
+      const fromCredentials = identity.host ? (0, credentials_1.readHostCredentials)(identity.host)?.toolInstallationId?.trim() : void 0;
+      if (fromCredentials)
+        return { toolInstallationId: qualify(toolType, fromCredentials), source: "credentials" };
+      const candidates = (0, tokenStore_1.listPersistedToolInstallationIds)(toolType);
+      if (candidates.length === 1)
+        return { toolInstallationId: candidates[0], source: "disk" };
+      throw new MissingInstallationIdError(toolType, candidates, identity.setupCommand ?? defaultSetupCommand(identity.host));
+    }
+    function defaultSetupCommand(host) {
+      return host ? `npx @ascenda-one/${host.replace(/_cli$/, "")}-hooks setup` : "the agent's setup command";
+    }
+    function qualify(toolType, value) {
+      return value.includes(":") ? value : `${toolType}:${value}`;
+    }
+    function resolveContextHashes(cwd) {
+      const workspaceOverride = process.env.ASCENDA_WORKSPACE_HASH?.trim() || null;
+      const projectOverride = process.env.ASCENDA_PROJECT_HASH?.trim() || null;
+      if (workspaceOverride && projectOverride)
+        return { workspaceHash: workspaceOverride, projectHash: projectOverride };
+      const context = (0, workContext_1.deriveWorkContext)(cwd ?? process.cwd());
+      if (context) {
+        (0, contextRegistry_1.recordWorkContext)(context);
+        (0, forgeProject_1.recordForgeProjectAlias)(context);
+      }
+      return {
+        workspaceHash: workspaceOverride ?? context?.workspaceHash ?? null,
+        projectHash: projectOverride ?? context?.projectHash ?? null
+      };
+    }
+    function loadCliAgentConfig(toolType, sessionIdFromHook, cwd, identity = {}) {
+      const credentials = identity.host ? (0, credentials_1.readHostCredentials)(identity.host) : void 0;
+      const apiBaseUrl = (process.env.ASCENDA_API_BASE_URL ?? credentials?.apiBaseUrl ?? exports.DEFAULT_API_BASE_URL).replace(/\/$/, "");
+      const { toolInstallationId } = resolveCliAgentInstallationId(toolType, identity);
+      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);
+      const contextHashes = resolveContextHashes(cwd);
+      return {
+        apiBaseUrl,
+        toolInstallationId,
+        eventWriteToken,
+        tokenFilePath,
+        sessionId: process.env.ASCENDA_SESSION_ID ?? sessionIdFromHook ?? null,
+        workspaceHash: contextHashes.workspaceHash,
+        projectHash: contextHashes.projectHash,
+        // Agents await command hooks; fail fast rather than stall the user's turn.
+        timeoutMs: parsePositiveInt(process.env.ASCENDA_HTTP_TIMEOUT_MS) ?? 3e3
+      };
+    }
+    async function deliverHookEvents2(events, options) {
+      if (events.length === 0)
+        return;
+      const notice = options.onNotice ?? ((message) => console.error(message));
+      let config;
+      try {
+        config = loadCliAgentConfig(options.toolType, options.sessionId, options.cwd, options);
+      } catch (error) {
+        if (error instanceof MissingInstallationIdError)
+          journalSkippedSend(options.host, error);
+        const logFile = (0, eventLog_1.resolveEventLogPath)();
+        if (!logFile)
+          throw error;
+        const contextHashes = resolveContextHashes(options.cwd);
+        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: contextHashes.workspaceHash,
+              projectHash: contextHashes.projectHash
+            }, 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,
+        projectHash: config.projectHash,
+        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; the event is kept in the outbox. Your work is unaffected.");
+        } else {
+          notice(`Ascenda telemetry rejected: ${result}`);
+        }
+        return;
+      }
+    }
+    function journalSkippedSend(host, error) {
+      const who = host ? `${host}: ` : "";
+      (0, stateStore_1.recordSendOutcome)((0, stateStore_1.unresolvedStateFilePath)(error.toolType), (0, stateStore_1.unresolvedToolInstallationId)(error.toolType), "skipped_no_installation_id", {
+        detail: error.candidates.length === 0 ? `${who}no ASCENDA_TOOL_INSTALLATION_ID, no credentials.json pairing, no ${error.toolType} token file` : `${who}no ASCENDA_TOOL_INSTALLATION_ID, no credentials.json pairing, ${error.candidates.length} ${error.toolType} token files (${error.candidates.join(", ")})`
+      });
+    }
+    function parsePositiveInt(value) {
+      const n = Number(value);
+      return Number.isInteger(n) && n > 0 ? n : void 0;
+    }
+  }
+});
+
+// ../packages/tool-kit/out/cliAgentSetup.js
+var require_cliAgentSetup = __commonJS({
+  "../packages/tool-kit/out/cliAgentSetup.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.isCliAgentManagementCommand = isCliAgentManagementCommand2;
+    exports.cliAgentHookBinPath = cliAgentHookBinPath;
+    exports.runCliAgentSetup = runCliAgentSetup2;
+    exports.writeHookSettings = writeHookSettings;
+    exports.findStaleHookCommands = findStaleHookCommands;
+    var crypto = __importStar(__require("crypto"));
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    var credentials_1 = require_credentials();
+    var hookAdapter_1 = require_hookAdapter();
+    var http_1 = require_http();
+    var tokenStore_1 = require_tokenStore();
+    var MANAGEMENT_COMMANDS = /* @__PURE__ */ new Set(["setup", "install", "status", "uninstall", "-h", "--help"]);
+    function isCliAgentManagementCommand2(argument) {
+      return argument !== void 0 && MANAGEMENT_COMMANDS.has(argument);
+    }
+    function cliAgentHookBinPath(binaryName) {
+      return path2.join((0, tokenStore_1.ascendaHome)(), "bin", binaryName);
+    }
+    function usage(spec) {
+      return `${spec.binaryName} setup \u2014 wire ${spec.displayName} to Ascenda telemetry
+
+  npx ${spec.packageName} setup [options]
+  npx ${spec.packageName} status
+  npx ${spec.packageName} uninstall
+
+Options
+  --api-base-url <url>          ingest host (default ${hookAdapter_1.DEFAULT_API_BASE_URL})
+  --local [port]                shorthand for the local dev server (default port 4477)
+  --tool-installation-id <id>   reuse an existing pairing instead of creating one
+  --token <eventWriteToken>     reuse an existing token (stored 0600, never printed)
+  --scope project|user          where hooks are registered (default project)
+  --project-dir <path>          project root for --scope project (default cwd)
+  --dry-run                     print what would change, write nothing
+  -h, --help
+`;
+    }
+    async function runCliAgentSetup2(argv, spec) {
+      let options;
+      try {
+        options = parseArgs(argv, spec);
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+      if (options.action === "help") {
+        console.log(usage(spec));
+        return 0;
+      }
+      if (options.action === "status")
+        return printStatus(options, spec);
+      if (options.action === "uninstall")
+        return uninstall(options, spec);
+      const apiBaseUrl = (options.apiBaseUrl ?? (0, credentials_1.readHostCredentials)(spec.host)?.apiBaseUrl ?? hookAdapter_1.DEFAULT_API_BASE_URL).replace(/\/$/, "");
+      console.log(`Ascenda setup for ${spec.displayName} \u2014 ${apiBaseUrl}`);
+      const identity = await resolveIdentity(apiBaseUrl, options, spec);
+      if (!identity)
+        return 1;
+      console.log(`  pairing      ${identity.toolInstallationId}${identity.paired ? " (new)" : " (existing)"}`);
+      const binary = installBinary(spec, options.dryRun);
+      console.log(`  hook binary  ${binary}`);
+      if (!options.dryRun) {
+        (0, credentials_1.writeHostCredentials)(spec.host, { apiBaseUrl, toolInstallationId: identity.toolInstallationId, pairedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      console.log(`  credentials  ${(0, credentials_1.credentialsFilePath)()} (tools.${spec.host})`);
+      const settingsFile = spec.settings.settingsPath(options.scope, options.projectDir);
+      const written = writeHookSettings(settingsFile, binary, spec, options.dryRun);
+      if (written === null)
+        return 1;
+      console.log(`  hooks        ${settingsFile} (${spec.hookEvents.length} events${written ? "" : ", already current"})`);
+      if (options.dryRun) {
+        console.log("\nDry run \u2014 nothing was written.");
+        return 0;
+      }
+      console.log(`
+Done. ${spec.restartHint}`);
+      console.log(`Check anytime:  npx ${spec.packageName} status`);
+      return 0;
+    }
+    function parseArgs(argv, spec) {
+      const options = {
+        scope: "project",
+        projectDir: process.cwd(),
+        dryRun: false,
+        action: "install"
+      };
+      for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const next = () => {
+          const value = argv[++i];
+          if (value === void 0)
+            throw new Error(`${arg} needs a value`);
+          return value;
+        };
+        switch (arg) {
+          case "setup":
+          case "install":
+            options.action = "install";
+            break;
+          case "status":
+            options.action = "status";
+            break;
+          case "uninstall":
+            options.action = "uninstall";
+            break;
+          case "--api-base-url":
+            options.apiBaseUrl = next();
+            break;
+          case "--local": {
+            const peek = argv[i + 1];
+            const port = peek && /^\d+$/.test(peek) ? argv[++i] : "4477";
+            options.apiBaseUrl = `http://localhost:${port}`;
+            break;
+          }
+          case "--tool-installation-id":
+            options.toolInstallationId = next();
+            break;
+          case "--token":
+            options.token = next();
+            break;
+          case "--scope": {
+            const value = next();
+            if (value !== "project" && value !== "user")
+              throw new Error(`--scope must be project or user, got ${value}`);
+            options.scope = value;
+            break;
+          }
+          case "--project-dir":
+            options.projectDir = path2.resolve(next());
+            break;
+          case "--dry-run":
+            options.dryRun = true;
+            break;
+          case "-h":
+          case "--help":
+            options.action = "help";
+            break;
+          default:
+            throw new Error(`unknown argument: ${arg}
+
+${usage(spec)}`);
+        }
+      }
+      return options;
+    }
+    async function resolveIdentity(apiBaseUrl, options, spec) {
+      const existingId = options.toolInstallationId ?? (0, credentials_1.readHostCredentials)(spec.host)?.toolInstallationId;
+      if (existingId && options.token) {
+        if (!options.dryRun)
+          (0, tokenStore_1.persistEventWriteToken)((0, tokenStore_1.defaultTokenFilePath)(existingId), options.token);
+        return { toolInstallationId: existingId, paired: false };
+      }
+      if (existingId && (0, tokenStore_1.readTokenFile)((0, tokenStore_1.defaultTokenFilePath)(existingId))) {
+        return { toolInstallationId: existingId, paired: false };
+      }
+      if (options.dryRun) {
+        return { toolInstallationId: existingId ?? `${spec.toolType}:<paired at run time>`, paired: false };
+      }
+      const toolInstallationId = existingId ?? `${spec.toolType}:${crypto.randomUUID()}`;
+      let session;
+      try {
+        session = await (0, http_1.createPairingSession)(apiBaseUrl, toolInstallationId, spec.toolType, `${spec.displayName} on ${os2.hostname()}`);
+      } catch (error) {
+        console.error(`
+Could not reach ${apiBaseUrl} to pair: ${error instanceof Error ? error.message : String(error)}`);
+        console.error("Start the local dev server and use --local, or pass --api-base-url for your backend.");
+        return void 0;
+      }
+      const token = await pollForToken(apiBaseUrl, session.pairingSessionId, session.code, session.expiresAt);
+      if (!token)
+        return void 0;
+      (0, tokenStore_1.persistEventWriteToken)((0, tokenStore_1.defaultTokenFilePath)(toolInstallationId), token);
+      return { toolInstallationId, paired: true };
+    }
+    async function pollForToken(apiBaseUrl, pairingSessionId, code, expiresAt) {
+      const deadline = Math.min(Date.parse(expiresAt) || Date.now() + 3e5, Date.now() + 3e5);
+      let announced = false;
+      while (Date.now() < deadline) {
+        const status = await (0, http_1.getPairingStatus)(apiBaseUrl, pairingSessionId);
+        if (status.status === "paired" && status.eventWriteToken)
+          return status.eventWriteToken;
+        if (status.status === "expired" || status.status === "cancelled") {
+          console.error(`
+Pairing ${status.status}. Run setup again.`);
+          return void 0;
+        }
+        if (!announced) {
+          console.log(`
+  Confirm in the Ascenda app \u2014 code ${code}`);
+          console.log("  Waiting...");
+          announced = true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      console.error("\nPairing timed out. Run setup again.");
+      return void 0;
+    }
+    function installBinary(spec, dryRun) {
+      const target = cliAgentHookBinPath(spec.binaryName);
+      if (dryRun)
+        return target;
+      const source = process.argv[1];
+      fs.mkdirSync(path2.dirname(target), { recursive: true });
+      if (path2.resolve(source) !== path2.resolve(target)) {
+        fs.copyFileSync(source, target);
+      }
+      if (process.platform !== "win32")
+        fs.chmodSync(target, 493);
+      return target;
+    }
+    function writeHookSettings(settingsFile, binary, spec, dryRun) {
+      let settings = { ...spec.settings.scaffold ?? {} };
+      const exists = fs.existsSync(settingsFile);
+      if (exists) {
+        const raw = fs.readFileSync(settingsFile, "utf8").trim();
+        if (raw) {
+          try {
+            settings = JSON.parse(raw);
+          } catch {
+            console.error(`
+${settingsFile} is not valid JSON. Fix or move it, then run setup again.`);
+            return null;
+          }
+        }
+      }
+      const command = hookCommand(binary);
+      const hooks = { ...settings.hooks ?? {} };
+      for (const event of spec.hookEvents) {
+        const kept = (hooks[event] ?? []).filter((entry) => !isOurs(entry, spec));
+        hooks[event] = [...kept, spec.settings.entry(command, event)];
+      }
+      const updated = { ...settings, hooks };
+      const serialised = `${JSON.stringify(updated, null, 2)}
+`;
+      if (exists && fs.readFileSync(settingsFile, "utf8") === serialised)
+        return false;
+      if (dryRun) {
+        console.log(`
+--- ${settingsFile} (dry run) ---
+${serialised}`);
+        return true;
+      }
+      if (exists)
+        fs.copyFileSync(settingsFile, `${settingsFile}.ascenda-backup`);
+      fs.mkdirSync(path2.dirname(settingsFile), { recursive: true });
+      fs.writeFileSync(settingsFile, serialised, "utf8");
+      return true;
+    }
+    function hookCommand(binary) {
+      return `"${process.execPath}" "${binary}"`;
+    }
+    function isOurs(entry, spec) {
+      const command = spec.settings.commandOf(entry);
+      return typeof command === "string" && command.includes(spec.binaryName);
+    }
+    function findStaleHookCommands(settings, binary, spec) {
+      const stale = /* @__PURE__ */ new Set();
+      for (const entries of Object.values(settings.hooks ?? {})) {
+        for (const entry of entries ?? []) {
+          const command = spec.settings.commandOf(entry);
+          if (typeof command !== "string")
+            continue;
+          if (!/ascenda/i.test(command) || command.includes(binary))
+            continue;
+          stale.add(command);
+        }
+      }
+      return [...stale];
+    }
+    function readSettings(settingsFile) {
+      try {
+        return JSON.parse(fs.readFileSync(settingsFile, "utf8"));
+      } catch {
+        return {};
+      }
+    }
+    function printStatus(options, spec) {
+      const credentials = (0, credentials_1.readHostCredentials)(spec.host);
+      const settingsFile = spec.settings.settingsPath(options.scope, options.projectDir);
+      const binary = cliAgentHookBinPath(spec.binaryName);
+      const tokenFile = credentials?.toolInstallationId ? (0, tokenStore_1.defaultTokenFilePath)(credentials.toolInstallationId) : void 0;
+      const settings = readSettings(settingsFile);
+      const registered = spec.hookEvents.filter((event) => (settings.hooks?.[event] ?? []).some((entry) => isOurs(entry, spec))).length;
+      const stale = findStaleHookCommands(settings, binary, spec);
+      console.log(`api base url   ${credentials?.apiBaseUrl ?? "\u2014 not configured"}`);
+      console.log(`pairing        ${credentials?.toolInstallationId ?? "\u2014 not paired"}`);
+      console.log(`token          ${tokenFile && (0, tokenStore_1.readTokenFile)(tokenFile) ? "present" : "\u2014 missing"}`);
+      console.log(`hook binary    ${fs.existsSync(binary) ? binary : "\u2014 not installed"}`);
+      console.log(`hooks          ${registered}/${spec.hookEvents.length} registered in ${settingsFile}`);
+      if (stale.length) {
+        console.log(`stale hooks    ${stale.length} not pointing at the installed binary \u2014 each one fails silently per event:`);
+        for (const command of stale)
+          console.log(`               ${command}`);
+        console.log(`               Remove them from ${settingsFile} by hand; setup cannot tell them from a hook you wrote.`);
+      }
+      const healthy = credentials?.toolInstallationId && registered === spec.hookEvents.length && fs.existsSync(binary) && !stale.length;
+      return healthy ? 0 : 1;
+    }
+    function uninstall(options, spec) {
+      const settingsFile = spec.settings.settingsPath(options.scope, options.projectDir);
+      if (fs.existsSync(settingsFile)) {
+        try {
+          const settings = JSON.parse(fs.readFileSync(settingsFile, "utf8"));
+          const hooks = { ...settings.hooks ?? {} };
+          for (const event of Object.keys(hooks)) {
+            const kept = hooks[event].filter((entry) => !isOurs(entry, spec));
+            if (kept.length)
+              hooks[event] = kept;
+            else
+              delete hooks[event];
+          }
+          const updated = { ...settings, hooks };
+          if (!Object.keys(hooks).length)
+            delete updated.hooks;
+          fs.copyFileSync(settingsFile, `${settingsFile}.ascenda-backup`);
+          fs.writeFileSync(settingsFile, `${JSON.stringify(updated, null, 2)}
+`, "utf8");
+          console.log(`hooks removed from ${settingsFile}`);
+        } catch {
+          console.error(`could not parse ${settingsFile} \u2014 remove the ascenda hook entries by hand`);
+          return 1;
+        }
+      }
+      const binary = cliAgentHookBinPath(spec.binaryName);
+      if (fs.existsSync(binary)) {
+        fs.rmSync(binary);
+        console.log(`removed ${binary}`);
+      }
+      if ((0, credentials_1.readHostCredentials)(spec.host)) {
+        (0, credentials_1.removeHostCredentials)(spec.host);
+        console.log(`removed tools.${spec.host} from ${(0, credentials_1.credentialsFilePath)()}`);
+      }
+      console.log(`tokens left in ${path2.join((0, tokenStore_1.ascendaHome)(), "tokens")} \u2014 revoke in the Ascenda app to invalidate them`);
+      return 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 = recordTurnStart2;
+    exports.consumeTurnDurationMs = consumeTurnDurationMs2;
+    var fs = __importStar(__require("fs"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    var stateDir = () => process.env.ASCENDA_STATE_DIR ?? path2.join(os2.homedir(), ".ascenda", "state");
+    function turnFile(agent, sessionId) {
+      return path2.join(stateDir(), `${sanitize(agent)}-turn-${sanitize(sessionId)}`);
+    }
+    function sanitize(value) {
+      return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+    }
+    function recordTurnStart2(agent, sessionId, now = Date.now()) {
+      if (!sessionId)
+        return;
+      try {
+        fs.mkdirSync(stateDir(), { recursive: true });
+        fs.writeFileSync(turnFile(agent, sessionId), String(now), { encoding: "utf8", mode: 384 });
+      } catch {
+      }
+    }
+    function consumeTurnDurationMs2(agent, sessionId, now = Date.now()) {
+      if (!sessionId)
+        return void 0;
+      const file = turnFile(agent, sessionId);
+      try {
+        const started = Number(fs.readFileSync(file, "utf8").trim());
+        fs.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/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 fs = __importStar(__require("fs"));
+    var net = __importStar(__require("net"));
+    var os2 = __importStar(__require("os"));
+    var path2 = __importStar(__require("path"));
+    var WRITE_TIMEOUT_MS = 50;
+    var APP_BUNDLE_ID = "one.ascenda.ascendaMissionControl";
+    var SAVER_HOST_BUNDLE_ID = "com.apple.ScreenSaver.Engine.legacyScreenSaver";
+    function liveBusSocketCandidates() {
+      const override = process.env.ASCENDA_LIVE_BUS_SOCKET;
+      if (override)
+        return [override];
+      const home = os2.homedir();
+      return [
+        path2.join(home, ".ascenda", "live.sock"),
+        path2.join(home, "Library", "Containers", APP_BUNDLE_ID, "Data", ".ascenda", "live.sock"),
+        path2.join(home, "Library", "Containers", SAVER_HOST_BUNDLE_ID, "Data", "l.sock")
+      ];
+    }
+    function liveBusSocketPath() {
+      const candidates = liveBusSocketCandidates();
+      for (const candidate of candidates) {
+        try {
+          if (fs.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.consumeTurnDurationMs = exports.writeTopLevelCredentials = exports.writeMachineCredentials = exports.writeHostCredentials = exports.removeHostCredentials = exports.readMachineCredentials = exports.readHostCredentials = exports.credentialsFilePath = exports.writeHookSettings = exports.runCliAgentSetup = exports.isCliAgentManagementCommand = exports.findStaleHookCommands = exports.cliAgentHookBinPath = exports.resolveContextHashes = exports.resolveCliAgentInstallationId = exports.loadCliAgentConfig = exports.deliverHookEvents = exports.MissingInstallationIdError = exports.DEFAULT_API_BASE_URL = exports.resolveEventLogPath = exports.expandUserPath = exports.appendEventLog = exports.EVENT_LOG_ENV_VAR = exports.buildEventPayload = exports.AscendaSemanticEventError = exports.AscendaEventSender = exports.mintIdempotencyKey = exports.looksLikeCorrection = exports.outcomeForHook = exports.inferOutcome = exports.getNestedNumber = exports.getNestedString = exports.getNested = exports.getNumber = exports.getString = exports.localHourAt = exports.utcOffsetMinutesAt = exports.BUSINESS_DAY = exports.isOutsideBusinessHours = exports.isAfterHours = exports.bucketDurationMs = exports.bucketLinesChanged = exports.classifyModelClass = exports.autonomyBand = exports.invitesDebrief = exports.classifyWorkMilestone = exports.isReworkGitAction = exports.classifyGitAction = exports.isVerificationCommand = exports.classifyCommand = void 0;
+    exports.postToolEvent = exports.renewToolToken = exports.getPairingStatus = exports.createPairingSession = exports.AscendaApiError = exports.liveBusSocketCandidates = exports.liveBusSocketPath = exports.bucketPromptSize = exports.emitLiveSignal = exports.recordForgeProjectAlias = exports.forgeFullNameFromConfig = exports.readForgeFullName = exports.parseForgeFullName = exports.forgeProjectHash = exports.workContextRegistryFilePath = exports.readWorkContextRegistry = exports.recordWorkContextAlias = exports.recordWorkContext = exports.readBranchName = exports.normalizeBranchName = exports.deriveBranchHashForCwd = exports.deriveBranchHash = exports.deriveWorkContext = exports.hashWithMachineSalt = exports.readOrCreateMachineSalt = exports.machineSaltFilePath = exports.enforceOutboxBounds = exports.claimOutbox = exports.readOutboxSummary = exports.appendToOutbox = exports.defaultOutboxFilePath = exports.outboxDrainEnabled = exports.DEFAULT_OUTBOX_DRAIN_BATCH_SIZE = exports.DEFAULT_OUTBOX_MAX_AGE_MS = exports.DEFAULT_OUTBOX_MAX_ENTRIES = exports.OUTBOX_DRAIN_ENV_VAR = exports.recordOutboxDiscard = exports.unresolvedToolInstallationId = exports.unresolvedStateFilePath = exports.markFailureNotified = exports.shouldAnnounceFailure = exports.recordSendOutcome = exports.readCollectorState = exports.defaultStateFilePath = exports.readTokenFile = exports.persistEventWriteToken = exports.listPersistedToolInstallationIds = exports.defaultTokenFilePath = exports.ascendaHome = exports.recordTurnStart = void 0;
+    exports.isRetryableStatus = exports.parseIngestResponse = exports.postToolEventsBatch = 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 autonomyBand_1 = require_autonomyBand();
+    Object.defineProperty(exports, "autonomyBand", { enumerable: true, get: function() {
+      return autonomyBand_1.autonomyBand;
+    } });
+    var modelClassifier_1 = require_modelClassifier();
+    Object.defineProperty(exports, "classifyModelClass", { enumerable: true, get: function() {
+      return modelClassifier_1.classifyModelClass;
+    } });
+    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, "isOutsideBusinessHours", { enumerable: true, get: function() {
+      return afterHours_1.isOutsideBusinessHours;
+    } });
+    Object.defineProperty(exports, "BUSINESS_DAY", { enumerable: true, get: function() {
+      return afterHours_1.BUSINESS_DAY;
+    } });
+    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;
+    } });
+    Object.defineProperty(exports, "mintIdempotencyKey", { enumerable: true, get: function() {
+      return payload_1.mintIdempotencyKey;
+    } });
+    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, "MissingInstallationIdError", { enumerable: true, get: function() {
+      return hookAdapter_1.MissingInstallationIdError;
+    } });
+    Object.defineProperty(exports, "deliverHookEvents", { enumerable: true, get: function() {
+      return hookAdapter_1.deliverHookEvents;
+    } });
+    Object.defineProperty(exports, "loadCliAgentConfig", { enumerable: true, get: function() {
+      return hookAdapter_1.loadCliAgentConfig;
+    } });
+    Object.defineProperty(exports, "resolveCliAgentInstallationId", { enumerable: true, get: function() {
+      return hookAdapter_1.resolveCliAgentInstallationId;
+    } });
+    Object.defineProperty(exports, "resolveContextHashes", { enumerable: true, get: function() {
+      return hookAdapter_1.resolveContextHashes;
+    } });
+    var cliAgentSetup_1 = require_cliAgentSetup();
+    Object.defineProperty(exports, "cliAgentHookBinPath", { enumerable: true, get: function() {
+      return cliAgentSetup_1.cliAgentHookBinPath;
+    } });
+    Object.defineProperty(exports, "findStaleHookCommands", { enumerable: true, get: function() {
+      return cliAgentSetup_1.findStaleHookCommands;
+    } });
+    Object.defineProperty(exports, "isCliAgentManagementCommand", { enumerable: true, get: function() {
+      return cliAgentSetup_1.isCliAgentManagementCommand;
+    } });
+    Object.defineProperty(exports, "runCliAgentSetup", { enumerable: true, get: function() {
+      return cliAgentSetup_1.runCliAgentSetup;
+    } });
+    Object.defineProperty(exports, "writeHookSettings", { enumerable: true, get: function() {
+      return cliAgentSetup_1.writeHookSettings;
+    } });
+    var credentials_1 = require_credentials();
+    Object.defineProperty(exports, "credentialsFilePath", { enumerable: true, get: function() {
+      return credentials_1.credentialsFilePath;
+    } });
+    Object.defineProperty(exports, "readHostCredentials", { enumerable: true, get: function() {
+      return credentials_1.readHostCredentials;
+    } });
+    Object.defineProperty(exports, "readMachineCredentials", { enumerable: true, get: function() {
+      return credentials_1.readMachineCredentials;
+    } });
+    Object.defineProperty(exports, "removeHostCredentials", { enumerable: true, get: function() {
+      return credentials_1.removeHostCredentials;
+    } });
+    Object.defineProperty(exports, "writeHostCredentials", { enumerable: true, get: function() {
+      return credentials_1.writeHostCredentials;
+    } });
+    Object.defineProperty(exports, "writeMachineCredentials", { enumerable: true, get: function() {
+      return credentials_1.writeMachineCredentials;
+    } });
+    Object.defineProperty(exports, "writeTopLevelCredentials", { enumerable: true, get: function() {
+      return credentials_1.writeTopLevelCredentials;
+    } });
+    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, "ascendaHome", { enumerable: true, get: function() {
+      return tokenStore_1.ascendaHome;
+    } });
+    Object.defineProperty(exports, "defaultTokenFilePath", { enumerable: true, get: function() {
+      return tokenStore_1.defaultTokenFilePath;
+    } });
+    Object.defineProperty(exports, "listPersistedToolInstallationIds", { enumerable: true, get: function() {
+      return tokenStore_1.listPersistedToolInstallationIds;
+    } });
+    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;
+    } });
+    Object.defineProperty(exports, "unresolvedStateFilePath", { enumerable: true, get: function() {
+      return stateStore_1.unresolvedStateFilePath;
+    } });
+    Object.defineProperty(exports, "unresolvedToolInstallationId", { enumerable: true, get: function() {
+      return stateStore_1.unresolvedToolInstallationId;
+    } });
+    Object.defineProperty(exports, "recordOutboxDiscard", { enumerable: true, get: function() {
+      return stateStore_1.recordOutboxDiscard;
+    } });
+    var outbox_1 = require_outbox();
+    Object.defineProperty(exports, "OUTBOX_DRAIN_ENV_VAR", { enumerable: true, get: function() {
+      return outbox_1.OUTBOX_DRAIN_ENV_VAR;
+    } });
+    Object.defineProperty(exports, "DEFAULT_OUTBOX_MAX_ENTRIES", { enumerable: true, get: function() {
+      return outbox_1.DEFAULT_OUTBOX_MAX_ENTRIES;
+    } });
+    Object.defineProperty(exports, "DEFAULT_OUTBOX_MAX_AGE_MS", { enumerable: true, get: function() {
+      return outbox_1.DEFAULT_OUTBOX_MAX_AGE_MS;
+    } });
+    Object.defineProperty(exports, "DEFAULT_OUTBOX_DRAIN_BATCH_SIZE", { enumerable: true, get: function() {
+      return outbox_1.DEFAULT_OUTBOX_DRAIN_BATCH_SIZE;
+    } });
+    Object.defineProperty(exports, "outboxDrainEnabled", { enumerable: true, get: function() {
+      return outbox_1.outboxDrainEnabled;
+    } });
+    Object.defineProperty(exports, "defaultOutboxFilePath", { enumerable: true, get: function() {
+      return outbox_1.defaultOutboxFilePath;
+    } });
+    Object.defineProperty(exports, "appendToOutbox", { enumerable: true, get: function() {
+      return outbox_1.appendToOutbox;
+    } });
+    Object.defineProperty(exports, "readOutboxSummary", { enumerable: true, get: function() {
+      return outbox_1.readOutboxSummary;
+    } });
+    Object.defineProperty(exports, "claimOutbox", { enumerable: true, get: function() {
+      return outbox_1.claimOutbox;
+    } });
+    Object.defineProperty(exports, "enforceOutboxBounds", { enumerable: true, get: function() {
+      return outbox_1.enforceOutboxBounds;
+    } });
+    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 workContext_1 = require_workContext();
+    Object.defineProperty(exports, "deriveWorkContext", { enumerable: true, get: function() {
+      return workContext_1.deriveWorkContext;
+    } });
+    Object.defineProperty(exports, "deriveBranchHash", { enumerable: true, get: function() {
+      return workContext_1.deriveBranchHash;
+    } });
+    Object.defineProperty(exports, "deriveBranchHashForCwd", { enumerable: true, get: function() {
+      return workContext_1.deriveBranchHashForCwd;
+    } });
+    Object.defineProperty(exports, "normalizeBranchName", { enumerable: true, get: function() {
+      return workContext_1.normalizeBranchName;
+    } });
+    Object.defineProperty(exports, "readBranchName", { enumerable: true, get: function() {
+      return workContext_1.readBranchName;
+    } });
+    var contextRegistry_1 = require_contextRegistry();
+    Object.defineProperty(exports, "recordWorkContext", { enumerable: true, get: function() {
+      return contextRegistry_1.recordWorkContext;
+    } });
+    Object.defineProperty(exports, "recordWorkContextAlias", { enumerable: true, get: function() {
+      return contextRegistry_1.recordWorkContextAlias;
+    } });
+    Object.defineProperty(exports, "readWorkContextRegistry", { enumerable: true, get: function() {
+      return contextRegistry_1.readWorkContextRegistry;
+    } });
+    Object.defineProperty(exports, "workContextRegistryFilePath", { enumerable: true, get: function() {
+      return contextRegistry_1.workContextRegistryFilePath;
+    } });
+    var forgeProject_1 = require_forgeProject();
+    Object.defineProperty(exports, "forgeProjectHash", { enumerable: true, get: function() {
+      return forgeProject_1.forgeProjectHash;
+    } });
+    Object.defineProperty(exports, "parseForgeFullName", { enumerable: true, get: function() {
+      return forgeProject_1.parseForgeFullName;
+    } });
+    Object.defineProperty(exports, "readForgeFullName", { enumerable: true, get: function() {
+      return forgeProject_1.readForgeFullName;
+    } });
+    Object.defineProperty(exports, "forgeFullNameFromConfig", { enumerable: true, get: function() {
+      return forgeProject_1.forgeFullNameFromConfig;
+    } });
+    Object.defineProperty(exports, "recordForgeProjectAlias", { enumerable: true, get: function() {
+      return forgeProject_1.recordForgeProjectAlias;
+    } });
+    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
+var import_tool_kit2 = __toESM(require_out2(), 1);
+
+// src/mapCursorEvent.ts
+var import_tool_kit = __toESM(require_out2(), 1);
+
+// src/types.ts
+var ASCENDA_TOOL_TYPE = "cli_agent";
+var CURSOR_HOST = "cursor";
+
+// src/mapCursorEvent.ts
+function mapCursorEvent(hookName, input, turnDurationMs) {
+  switch (hookName) {
+    case "sessionStart":
+      return [{ eventType: "create_focus_session", severity: "low", metadata: withHost({ activity: "session_started" }) }];
+    case "sessionEnd":
+      return [{ eventType: "recovery_offline_period", severity: "low", metadata: withHost({ activity: "session_ended" }) }];
+    case "beforeSubmitPrompt":
+      return mapPrompt(input);
+    case "preToolUse":
+      return [{ eventType: "ai_tool_call_started", severity: "low", metadata: withHost({ toolName: sanitiseToolName(getToolName(input)) }) }];
+    case "postToolUse":
+      return mapPostToolUse(input);
+    case "postToolUseFailure":
+      return mapPostToolUseFailure(input);
+    case "preCompact":
+      return mapPreCompact(input);
+    case "stop":
+      return mapStop(turnDurationMs);
+    // Deliberately unmapped. The shell / MCP / file-edit hooks are specialised
+    // views of tool calls that preToolUse and postToolUse already report, so
+    // registering them would double-count every command and edit. The rest
+    // (subagent lifecycle, agent thoughts, Tab completions, workspaceOpen)
+    // have no catalog counterpart.
+    default:
+      return [];
+  }
+}
+function mapPrompt(input) {
+  const prompt = (0, import_tool_kit.getString)(input, ["prompt"]);
+  const events = [{ eventType: "ai_prompt_submitted", severity: "low", metadata: withHost({ promptClass: "unknown" }) }];
+  if ((0, import_tool_kit.looksLikeCorrection)(prompt)) {
+    events.push({ eventType: "ai_correction_prompt", severity: "medium", metadata: withHost({ reason: "repeated_reprompting", trigger: "inferred" }) });
+  }
+  return events;
+}
+function mapPostToolUse(input) {
+  const toolName = getToolName(input);
+  const safeToolName = sanitiseToolName(toolName);
+  const commandClass = (0, import_tool_kit.classifyCommand)(getCommand(input));
+  const durationBucket = (0, import_tool_kit.bucketDurationMs)((0, import_tool_kit.getNumber)(input, ["duration"]));
+  const outcome = (0, import_tool_kit.inferOutcome)(withParsedToolOutput(input));
+  if (outcome === "failure") {
+    if (isShell(toolName) && (0, import_tool_kit.isVerificationCommand)(commandClass)) {
+      return [{ eventType: "compile_error", severity: "medium", metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket, reason: "test_failure" }) }];
+    }
+    return [{ eventType: "ai_tool_call_failed", severity: "medium", metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket, reason: "tool_failure" }) }];
+  }
+  if (isWriteTool(toolName)) {
+    return [{ eventType: toolName?.toLowerCase() === "write" ? "ai_file_write" : "ai_file_edit", severity: "low", metadata: withHost({ toolName: safeToolName, outcome, durationBucket }) }];
+  }
+  if (isShell(toolName) && (0, import_tool_kit.isVerificationCommand)(commandClass)) {
+    return [{ eventType: "editor_verification_activity", severity: "low", metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket, activity: "ai_test_or_build_run" }) }];
+  }
+  return [{ eventType: "ai_tool_call_completed", severity: "low", metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket }) }];
+}
+function mapPostToolUseFailure(input) {
+  const toolName = getToolName(input);
+  const safeToolName = sanitiseToolName(toolName);
+  const commandClass = (0, import_tool_kit.classifyCommand)(getCommand(input));
+  const durationBucket = (0, import_tool_kit.bucketDurationMs)((0, import_tool_kit.getNumber)(input, ["duration"]));
+  const interrupted = input.is_interrupt === true;
+  const outcome = interrupted ? "cancelled" : "failure";
+  if (!interrupted && isShell(toolName) && (0, import_tool_kit.isVerificationCommand)(commandClass)) {
+    return [{ eventType: "compile_error", severity: "medium", metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket, reason: "test_failure" }) }];
+  }
+  return [{
+    eventType: "ai_tool_call_failed",
+    severity: interrupted ? "low" : "medium",
+    metadata: withHost({ toolName: safeToolName, commandClass, outcome, durationBucket, reason: interrupted ? "manual_interrupt" : "tool_failure" })
+  }];
+}
+function mapPreCompact(input) {
+  const isManual = (0, import_tool_kit.getString)(input, ["trigger"])?.toLowerCase().includes("manual") ?? false;
+  return [{
+    eventType: isManual ? "context_compression_manual" : "context_compression_auto",
+    severity: isManual ? "medium" : "high",
+    metadata: withHost({ trigger: isManual ? "manual" : "auto", reason: "context_limit", ...contextOccupancy(input) })
+  }];
+}
+function contextOccupancy(input) {
+  const percent = (0, import_tool_kit.getNumber)(input, ["context_usage_percent", "contextUsagePercent"]);
+  if (percent === void 0 || percent < 0) return {};
+  return { contextWindowPeakPct: percent / 100 };
+}
+function mapStop(turnDurationMs) {
+  const durationBucket = (0, import_tool_kit.bucketDurationMs)(turnDurationMs);
+  if (durationBucket === "30-60m" || durationBucket === "60m+") {
+    return [{ eventType: "agent_loop_long", severity: durationBucket === "60m+" ? "high" : "medium", metadata: withHost({ durationBucket, reason: "long_session", trigger: "inferred" }) }];
+  }
+  return [];
+}
+function withParsedToolOutput(input) {
+  const raw = input.tool_output;
+  if (typeof raw !== "string") return input;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return input;
+    return { ...input, result: parsed };
+  } catch {
+    return input;
+  }
+}
+function getCommand(input) {
+  return (0, import_tool_kit.getString)(input, ["command"]) ?? (0, import_tool_kit.getNestedString)(input, [["tool_input", "command"]]);
+}
+function getToolName(input) {
+  return (0, import_tool_kit.getString)(input, ["tool_name", "toolName"]);
+}
+function isShell(toolName) {
+  const value = toolName?.toLowerCase();
+  return value === "shell" || value === "bash" || value === "terminal";
+}
+function isWriteTool(toolName) {
+  const value = toolName?.toLowerCase();
+  return value === "write" || value === "edit" || value === "multiedit" || value === "search_replace" || value === "apply_patch";
+}
+function sanitiseToolName(toolName) {
+  if (!toolName) return "unknown";
+  return toolName.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 40) || "unknown";
+}
+function withHost(metadata) {
+  return { host: CURSOR_HOST, ...metadata };
+}
+
+// src/setup.ts
+import * as os from "os";
+import * as path from "path";
+var HOOK_EVENTS = ["sessionStart", "sessionEnd", "beforeSubmitPrompt", "preToolUse", "postToolUse", "postToolUseFailure", "preCompact", "stop"];
+var SETUP = {
+  host: CURSOR_HOST,
+  displayName: "Cursor",
+  toolType: ASCENDA_TOOL_TYPE,
+  packageName: "@ascenda-one/cursor-hooks",
+  binaryName: "ascenda-cursor-hook",
+  hookEvents: HOOK_EVENTS,
+  restartHint: "Restart Cursor to load the hooks.",
+  settings: {
+    settingsPath: (scope, projectDir) => scope === "user" ? path.join(os.homedir(), ".cursor", "hooks.json") : path.join(projectDir, ".cursor", "hooks.json"),
+    // Cursor's hooks.json is versioned; a file we create must say which.
+    scaffold: { version: 1 },
+    // Cursor passes the event on stdin too, but this adapter reads argv, so
+    // each entry names its event.
+    entry: (command, event) => ({ command: `${command} ${event}` }),
+    commandOf: (entry) => entry && typeof entry === "object" ? entry.command : void 0
+  }
+};
+
+// src/cli.ts
+async function main() {
+  const command = process.argv[2];
+  if ((0, import_tool_kit2.isCliAgentManagementCommand)(command)) {
+    managementExitCode = await (0, import_tool_kit2.runCliAgentSetup)(process.argv.slice(2), SETUP);
+    return;
+  }
+  const hookName = command;
+  if (!hookName) {
+    console.error("Usage: ascenda-cursor-hook <cursorHookEventName> | setup | status | uninstall");
+    return;
+  }
+  const input = await readJsonFromStdin();
+  const sessionId = typeof input.conversation_id === "string" ? input.conversation_id : typeof input.session_id === "string" ? input.session_id : void 0;
+  let turnDurationMs;
+  if (hookName === "beforeSubmitPrompt") (0, import_tool_kit2.recordTurnStart)(CURSOR_HOST, sessionId);
+  if (hookName === "stop") turnDurationMs = (0, import_tool_kit2.consumeTurnDurationMs)(CURSOR_HOST, sessionId);
+  await (0, import_tool_kit2.deliverHookEvents)(mapCursorEvent(hookName, input, turnDurationMs), {
+    toolType: ASCENDA_TOOL_TYPE,
+    host: CURSOR_HOST,
+    setupCommand: `npx ${SETUP.packageName} setup`,
+    source: "cli_agent",
+    sessionId
+  });
+}
+var managementExitCode;
+async function readJsonFromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+}).finally(() => process.exit(managementExitCode ?? 0));