haansi 0.1.34 → 0.1.36

package/README.md

@@ -23,7 +23,7 @@ Requires Node.js >= 18.0.0.
 
 ## Authentication
 
-The CLI uses `hsk_` tokens for authentication. Generate a token at https://app.haansi.co/settings/tokens.
+The CLI uses `hsk_` tokens for authentication. Generate a token at https://app.haansi.co/settings/developer/tokens.
 
 ```bash
 haansi init

package/dist/haansi.js

@@ -95,7 +95,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "haansi",
-      version: "0.1.34",
+      version: "0.1.36",
       description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
       bin: {
         haansi: "./dist/haansi.js"
@@ -285,7 +285,7 @@ async function init() {
     "Tip: For interactive login, run `haansi auth login` to authenticate via browser.\n"
   );
   console.log(
-    `You can generate an API token at https://app.haansi.co/settings/tokens
+    `You can generate an API token at https://app.haansi.co/settings/developer/tokens
 `
   );
   const token = await prompt("Paste your Haansi API token: ");
@@ -1730,7 +1730,7 @@ var init_scaling_metrics = __esm({
       EMBEDDING_BACKLOG_ROWS: spec({
         name: "haansi/embeddings/backlog_rows",
         unit: "Count",
-        description: "Rows with a NULL embedding across the intelligence tables that carry one.",
+        description: "Rows needing TEI inference across the shared intelligence registry and platform docs search index.",
         dimensions: ["environment", "workload"],
         treatMissingData: "breaching",
         missingDataRationale: "This is the metric that must be able to wake a fleet from zero, so it is published by the reconciler and never by an embedding worker. A worker-published version of it would read as zero precisely when the fleet is asleep with work pending \u2014 the failure this whole phase exists to remove."
@@ -1751,6 +1751,70 @@ var init_scaling_metrics = __esm({
         treatMissingData: "breaching",
         missingDataRationale: "Reconciler-published, so absence means the queue is unobserved rather than empty. This is the signal that sizes the worker fleet; reading silence as zero would scale it away with work queued."
       }),
+      EMBEDDING_CLAIMS_FAILED: spec({
+        name: "haansi/embeddings/claims_failed",
+        unit: "Count",
+        description: "Embedding claims parked after exhausting attempts \u2014 poison, not inference demand.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Failed claims cannot drain without repair and must remain separate from ready work; folding them into backlog would scale inference against poison."
+      }),
+      EMBEDDING_CLAIM_TICK_LIVENESS: spec({
+        name: "haansi/embeddings/claim_tick_liveness",
+        unit: "Count",
+        description: "Emitted by every embedding-claim timer callback, including healthy idle and skipped passes.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "This is the consumer heartbeat. Queue and lease state cannot prove the claim loop itself is alive, and missing telemetry must not authorize scale-in or be diagnosed as an inference shortage."
+      }),
+      EMBEDDING_CLAIM_TICK_SKIPPED: spec({
+        name: "haansi/embeddings/claim_tick_skipped_already_running",
+        unit: "Count",
+        description: "Emitted when the embedding-claim interval fires while its prior pass is unresolved.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "This is event-shaped: no datapoint normally means no pass was skipped. The independent heartbeat detects a dead publisher."
+      }),
+      EMBEDDING_CLAIM_TICK_USEFUL_COMPLETIONS: spec({
+        name: "haansi/embeddings/claim_tick_useful_completions",
+        unit: "Count",
+        description: "Embedding claims durably completed by a settled pass; explicit zero means no progress.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "Useful means a vector was accepted and its claim completed, not a scan, claim, retry, or TEI request. A settled pass publishes zero, so absence means progress is unobserved."
+      }),
+      EMBEDDING_CLAIM_TICK_USEFUL_TOKENS: spec({
+        name: "haansi/embeddings/claim_tick_useful_tokens",
+        unit: "Count",
+        description: "Conservatively estimated input tokens whose vectors and claims were durably committed by a settled pass.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "Published as zero on every settled pass. This is useful throughput, not request activity; absence means progress is unobserved."
+      }),
+      EMBEDDING_CLAIM_TICK_INFERENCE_BATCHES: spec({
+        name: "haansi/embeddings/claim_tick_inference_batches",
+        unit: "Count",
+        description: "Packed TEI requests attempted by a settled embedding-claim pass, including failed requests.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the claim-tick heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero work."
+      }),
+      EMBEDDING_CLAIM_TICK_INFERENCE_MILLISECONDS: spec({
+        name: "haansi/embeddings/claim_tick_inference_milliseconds",
+        unit: "Milliseconds",
+        description: "Wall time spent awaiting packed TEI requests in a settled embedding-claim pass.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the claim-tick heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero service time."
+      }),
+      EMBEDDING_CLAIM_TICK_FAILURES: spec({
+        name: "haansi/embeddings/claim_tick_failures",
+        unit: "Count",
+        description: "Whole embedding-claim passes that failed before settling.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Event-shaped diagnostic metric. No datapoint normally means no pass failed; the claim-tick heartbeat covers publisher loss."
+      }),
       REDACTION_CLAIMS_OLDEST_READY_SECONDS: spec({
         name: "haansi/redaction/claims_oldest_ready_seconds",
         unit: "Seconds",
@@ -1786,6 +1850,78 @@ var init_scaling_metrics = __esm({
         treatMissingData: "notBreaching",
         missingDataRationale: "CHANGED with the backlog scaling policy, and the original rationale is recorded here because it stopped being true. It read 'worker-published, so absence means the queue is unobserved rather than empty' \u2014 correct when redaction-tick emitted this, and false since backlog-reconciler took it over: the reconciler runs independently of both the worker and the Presidio pool, so the metric no longer disappears with the tier it sizes. The consumer also changed. This drives a SCALE-OUT policy, and 'breaching' there means growing the fleet whenever the publisher hiccups \u2014 scaling on the absence of information rather than on work. Publisher failure is covered by RECONCILER_LIVENESS, which is the alarm that should fire for it; this one should not double as a detector for its own input being missing."
       }),
+      REDACTION_TICK_LIVENESS: spec({
+        name: "haansi/redaction/tick_liveness",
+        unit: "Count",
+        description: "Emitted by every redaction timer callback, including healthy idle and skipped passes.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "This is the consumer heartbeat, separate from queue and lease state. A ready queue with no leases cannot distinguish an idle-but-live timer from a dead task without it, and absence must never authorize inference scale-out or worker scale-in."
+      }),
+      REDACTION_TICK_SKIPPED: spec({
+        name: "haansi/redaction/tick_skipped_already_running",
+        unit: "Count",
+        description: "Emitted when the interval fires while the previous whole redaction pass is unresolved.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "This is event-shaped: no datapoint normally means no interval was skipped. The independent tick heartbeat detects a dead publisher."
+      }),
+      REDACTION_TICK_PASS_AGE_SECONDS: spec({
+        name: "haansi/redaction/tick_pass_age_seconds",
+        unit: "Seconds",
+        description: "Age of the currently unresolved redaction pass, or zero between passes.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Only a reported age above the threshold proves a pass is stalled. Silence is normal while service-pipeline is intentionally at zero; when the service is desired, its separately gated heartbeat alarm detects a missing publisher."
+      }),
+      REDACTION_TICK_USEFUL_COMPLETIONS: spec({
+        name: "haansi/redaction/tick_useful_completions",
+        unit: "Count",
+        description: "Claims durably completed by a redaction pass. Explicit zero distinguishes no progress from no publisher.",
+        dimensions: ["environment"],
+        treatMissingData: "breaching",
+        missingDataRationale: "The consumer publishes zero on every settled pass. Absence therefore means progress is unobserved and cannot authorize a control decision."
+      }),
+      REDACTION_TICK_USEFUL_BYTES: spec({
+        name: "haansi/redaction/tick_useful_bytes",
+        unit: "Bytes",
+        description: "Source bytes whose redacted output and owner-guarded claim completion were durably committed by a settled pass.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the redaction heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero completed bytes."
+      }),
+      REDACTION_TICK_ANALYZED_UNITS: spec({
+        name: "haansi/redaction/tick_analyzed_units",
+        unit: "Count",
+        description: "Non-reused redaction windows submitted to Presidio by a settled pass.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the redaction heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero analyzed work."
+      }),
+      REDACTION_TICK_ANALYZED_BYTES: spec({
+        name: "haansi/redaction/tick_analyzed_bytes",
+        unit: "Bytes",
+        description: "Bytes in non-reused redaction windows submitted to Presidio by a settled pass.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the redaction heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero analyzed bytes."
+      }),
+      REDACTION_TICK_PRESIDIO_MILLISECONDS: spec({
+        name: "haansi/redaction/tick_presidio_milliseconds",
+        unit: "Milliseconds",
+        description: "Wall time spent awaiting Presidio for non-reused windows in a settled redaction pass.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Calibration-only measurement; the redaction heartbeat owns publisher loss. A future controller must treat absence as unknown rather than filling it to zero service time."
+      }),
+      REDACTION_TICK_FAILURES: spec({
+        name: "haansi/redaction/tick_failures",
+        unit: "Count",
+        description: "Whole redaction passes that failed before settling normally.",
+        dimensions: ["environment"],
+        treatMissingData: "notBreaching",
+        missingDataRationale: "Event-shaped diagnostic metric. No datapoint normally means no pass failed; heartbeat covers publisher loss."
+      }),
       REDACTION_CLAIMS_ACTIVE_LEASES: spec({
         name: "haansi/redaction/claims_active_leases",
         unit: "Count",
@@ -1896,18 +2032,75 @@ var init_jsonl_scalars = __esm({
   }
 });
 
+// ../../packages/@company/pii/src/interval-index.ts
+function buildIntervalIndex(ranges) {
+  if (!ranges || ranges.length === 0) return EMPTY_INTERVAL_INDEX;
+  const sorted = ranges.filter((range) => range.end > range.start).sort((a, b) => a.start - b.start || a.end - b.end);
+  if (sorted.length === 0) return EMPTY_INTERVAL_INDEX;
+  const starts = [];
+  const ends = [];
+  let currentStart = sorted[0].start;
+  let currentEnd = sorted[0].end;
+  for (let i = 1; i < sorted.length; i += 1) {
+    const range = sorted[i];
+    if (range.start < currentEnd) {
+      if (range.end > currentEnd) currentEnd = range.end;
+    } else {
+      starts.push(currentStart);
+      ends.push(currentEnd);
+      currentStart = range.start;
+      currentEnd = range.end;
+    }
+  }
+  starts.push(currentStart);
+  ends.push(currentEnd);
+  return { starts, ends };
+}
+function intervalIndexOverlaps(index, start, end) {
+  if (end <= start) return false;
+  const { starts, ends } = index;
+  let low = 0;
+  let high = starts.length - 1;
+  let candidate = -1;
+  while (low <= high) {
+    const middle = low + high >>> 1;
+    if (starts[middle] < end) {
+      candidate = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return candidate >= 0 && ends[candidate] > start;
+}
+var EMPTY_INTERVAL_INDEX;
+var init_interval_index = __esm({
+  "../../packages/@company/pii/src/interval-index.ts"() {
+    "use strict";
+    EMPTY_INTERVAL_INDEX = { starts: [], ends: [] };
+  }
+});
+
 // ../../packages/@company/pii/src/spans.ts
 function applyPiiSpans(text, spans, replacement = (span) => span.replacement ?? `<${span.entityType}>`) {
-  let result = text;
-  for (const span of [...spans].sort((a, b) => b.start - a.start)) {
-    result = result.slice(0, span.start) + replacement(span, text.slice(span.start, span.end)) + result.slice(span.end);
-  }
-  return result;
+  if (spans.length === 0) return text;
+  const ordered = [...spans].sort((a, b) => a.start - b.start || b.end - a.end);
+  const pieces = [];
+  let cursor = 0;
+  for (const span of ordered) {
+    if (span.end <= cursor) continue;
+    if (span.start > cursor) pieces.push(text.slice(cursor, span.start));
+    pieces.push(replacement(span, text.slice(span.start, span.end)));
+    cursor = span.end;
+  }
+  pieces.push(text.slice(cursor));
+  return pieces.join("");
 }
 var init_spans = __esm({
   "../../packages/@company/pii/src/spans.ts"() {
     "use strict";
     init_jsonl_scalars();
+    init_interval_index();
   }
 });
 
@@ -21133,13 +21326,14 @@ var init_client = __esm({
 });
 
 // ../../packages/@company/db/src/org-context.ts
-var observability3;
+var observability3, DECRYPTING_CLIENT;
 var init_org_context = __esm({
   "../../packages/@company/db/src/org-context.ts"() {
     "use strict";
     init_src4();
     init_src2();
     observability3 = createObservabilityService("db-org-context");
+    DECRYPTING_CLIENT = Symbol.for("haansi.db.decryptingClient");
   }
 });
 
@@ -22747,23 +22941,20 @@ function planLocalPathRedaction(text, options = {}) {
     }
   }
   if (options.protectUrlLike !== false) {
+    const plannedIndex = buildIntervalIndex(protectedRanges);
     for (const match of text.matchAll(URL_LIKE_RE)) {
       if (match.index === void 0) continue;
       const start = match.index;
       const end = start + match[0].length;
-      const alreadyPlanned = protectedRanges.some(
-        (range) => start < range.end && end > range.start
-      );
-      if (!alreadyPlanned)
+      if (!intervalIndexOverlaps(plannedIndex, start, end))
         protectedRanges.push({ start, end, kind: "url_like" });
     }
   }
   if (options.protectCodeShaped !== false) {
+    const plannedIndex = buildIntervalIndex(protectedRanges);
     for (const range of codeShapedProtectedRanges(text)) {
-      const clash = protectedRanges.some(
-        (existing) => range.start < existing.end && range.end > existing.start
-      );
-      if (!clash) protectedRanges.push(range);
+      if (!intervalIndexOverlaps(plannedIndex, range.start, range.end))
+        protectedRanges.push(range);
     }
   }
   return { spans, protectedRanges };
@@ -22779,6 +22970,7 @@ var POSIX_LOCAL_PATH_RE, DIFF_PREFIX_RE, URL_LIKE_RE, WINDOWS_LOCAL_PATH_RE, COD
 var init_path_policy = __esm({
   "../../packages/@company/pii/src/path-policy.ts"() {
     "use strict";
+    init_interval_index();
     POSIX_LOCAL_PATH_RE = /\/(?:Users|home|private|tmp|var|etc|opt|workspace|root|mnt|Volumes)\/(?:[\p{L}\p{N}._@%+~=-]+\/)*[\p{L}\p{N}._@%+~=-]+\/?/gu;
     DIFF_PREFIX_RE = /(?:^|\s)(?:---|\+\+\+)\s+([ab])(?=\/)/gmu;
     URL_LIKE_RE = /(?<![\p{L}\p{N}@._-])(?:[a-z][a-z0-9+.-]{0,31}:\/\/|(?:site|url|repo|link|source|host):\s*|git@)?(?:[\p{L}\p{N}-]{1,63}\.)+(?:com|org|net|io|dev|co|ai|gov|edu|sh|app|cloud|local)(?::\d{2,5})?(?:[/:][^\s"'<>\\]*)?/giu;
@@ -22830,6 +23022,7 @@ var init_engine = __esm({
   "../../packages/@company/pii/src/engine.ts"() {
     "use strict";
     init_deterministic();
+    init_interval_index();
     init_dictionary();
     init_spans();
     init_path_policy();
@@ -23337,6 +23530,9 @@ async function uploadSession(sessionId, content, apiUrl2, token, agentSource, gi
     if (response.status === 429) {
       err.rateLimited = true;
     }
+    if (response.status === 409 && text.includes("mining_disabled")) {
+      err.miningDisabled = true;
+    }
     throw err;
   }
 }
@@ -23510,6 +23706,12 @@ async function collectLocked(options) {
         }
       );
     } catch (err) {
+      if (err?.miningDisabled) {
+        void logger3.info(
+          "Mining is disabled for this organization \u2014 nothing is being collected. An owner or admin can enable it in Settings \u2192 Connections \u2192 Coding Sessions."
+        );
+        break;
+      }
       if (err?.rateLimited) {
         deferred++;
         void logger3.info(`Rate limited, will retry next run: ${shortId}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haansi",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
   "bin": {
     "haansi": "./dist/haansi.js"