switchroom 0.19.34 → 0.19.36

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.34", COMMIT_SHA = "73a1b218";
+var VERSION = "0.19.36", COMMIT_SHA = "ba505b15";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -15552,16 +15552,56 @@ var init_users = __esm(() => {
   init_merge();
 });
 
+// src/config/thinking-effort-risk.ts
+function isRiskyThinkingEffort(effort) {
+  if (!effort)
+    return false;
+  return RISKY_EFFORTS.has(effort.trim().toLowerCase());
+}
+function emitsAdaptiveThinking(model) {
+  if (!model)
+    return false;
+  const m = model.trim().toLowerCase();
+  return m === "opus" || m.startsWith("claude-opus-");
+}
+function isAdaptiveThinkingOpus(model) {
+  if (!model)
+    return false;
+  const m = model.trim().toLowerCase();
+  return m.startsWith("claude-opus-4");
+}
+function assessThinkingEffortRisk(model, effort) {
+  if (!isRiskyThinkingEffort(effort))
+    return { risky: false };
+  if (!isAdaptiveThinkingOpus(model))
+    return { risky: false };
+  return {
+    risky: true,
+    reason: `thinking_effort '${effort}' on pinned Opus 4.x model '${model}' could trigger ` + `'400 thinking/redacted_thinking blocks cannot be modified' errors when work runs ` + `through concurrent sub-agents (issue #1978). The upstream claude-CLI fix shipped in ` + `${CLAUDE_CLI_THINKING_MERGE_FIX_VERSION}, but the Opus 4.x reproduction has not been ` + `re-tested since, so pin 'thinking_effort: low' or move the agent to a current Opus model.`
+  };
+}
+var CLAUDE_CLI_THINKING_MERGE_FIX_VERSION = "2.1.156", RISKY_EFFORTS;
+var init_thinking_effort_risk = __esm(() => {
+  RISKY_EFFORTS = new Set(["medium", "high", "xhigh", "max"]);
+});
+
 // telegram-plugin/gateway/model-command.ts
 function isClaudeModel(name) {
   const lower = name.toLowerCase();
   if (MODEL_ALIASES.includes(lower))
     return true;
+  if (lower in CLAUDE_MODEL_ALIASES)
+    return true;
   return lower.startsWith("claude-");
 }
-var MODEL_ALIASES;
+var MODEL_ALIASES, CLAUDE_MODEL_ALIASES;
 var init_model_command = __esm(() => {
+  init_thinking_effort_risk();
   MODEL_ALIASES = ["opus", "sonnet", "haiku", "fable", "default"];
+  CLAUDE_MODEL_ALIASES = {
+    opus48: "claude-opus-4-8",
+    "opus-4-8": "claude-opus-4-8"
+  };
 });
 
 // src/litellm/timeout-budget.ts
@@ -15790,7 +15830,7 @@ function hindsightPgEnv(overrides = new Map) {
   }
   return out;
 }
-var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION, HINDSIGHT_PG_APP_ANON_MIB = 2560, HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048, HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB, HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072, HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168, HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE_ENV = "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE", HINDSIGHT_PG_SHARED_BUFFERS_ENV = "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS", HINDSIGHT_PG_DEFAULTS, HINDSIGHT_PG_ENV_KEYS;
+var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION, HINDSIGHT_PG_APP_ANON_MIB = 2560, HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048, HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB, HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072, HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168, HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE_ENV = "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE", HINDSIGHT_PG_SHARED_BUFFERS_ENV = "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS", HINDSIGHT_PG_FSYNC_ENV = "SWITCHROOM_HINDSIGHT_PG_FSYNC", HINDSIGHT_PG_DEFAULT_FSYNC = "on", HINDSIGHT_PG_DEFAULTS, HINDSIGHT_PG_ENV_KEYS;
 var init_hindsight_pg_defaults = __esm(() => {
   HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 16 * 1024;
   HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
@@ -15799,7 +15839,8 @@ var init_hindsight_pg_defaults = __esm(() => {
       HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE_ENV,
       pgMib(HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB)
     ],
-    [HINDSIGHT_PG_SHARED_BUFFERS_ENV, pgMib(HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB)]
+    [HINDSIGHT_PG_SHARED_BUFFERS_ENV, pgMib(HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB)],
+    [HINDSIGHT_PG_FSYNC_ENV, HINDSIGHT_PG_DEFAULT_FSYNC]
   ];
   HINDSIGHT_PG_ENV_KEYS = new Set(HINDSIGHT_PG_DEFAULTS.map(([k]) => k));
 });
@@ -35491,7 +35532,7 @@ class AuthBrokerClient {
       sock.once("error", onError);
       sock.once("connect", () => {
         sock.removeListener("error", onError);
-        sock.on("data", (chunk) => this.onData(chunk));
+        sock.on("data", (chunk2) => this.onData(chunk2));
         sock.on("error", (err) => this.onSocketError(err));
         sock.on("close", () => this.onSocketClose());
         this.socket = sock;
@@ -35505,8 +35546,8 @@ class AuthBrokerClient {
       this.connecting = null;
     }
   }
-  onData(chunk) {
-    this.buffer += chunk.toString("utf8");
+  onData(chunk2) {
+    this.buffer += chunk2.toString("utf8");
     let idx;
     while ((idx = this.buffer.indexOf(`
 `)) !== -1) {
@@ -39484,11 +39525,11 @@ function readAuditRaw(logPath, opts = {}) {
     const gen = `${logPath}.${n}`;
     if (!existsSync51(gen))
       break;
-    const chunk = tailBytes(gen, budget, strict);
-    if (chunk.length === 0)
+    const chunk2 = tailBytes(gen, budget, strict);
+    if (chunk2.length === 0)
       continue;
-    chunks.push(chunk);
-    budget -= Buffer.byteLength(chunk, "utf-8");
+    chunks.push(chunk2);
+    budget -= Buffer.byteLength(chunk2, "utf-8");
   }
   return chunks.reverse().filter((c) => c.length > 0).map((c) => c.endsWith(`
 `) ? c : c + `
@@ -44410,8 +44451,8 @@ async function hostdRequest(opts, req) {
         reject(err);
       }
     });
-    socket.on("data", (chunk) => {
-      buf += chunk.toString("utf8");
+    socket.on("data", (chunk2) => {
+      buf += chunk2.toString("utf8");
       if (Buffer.byteLength(buf, "utf8") > MAX_FRAME_BYTES3 * 2) {
         if (settled)
           return;
@@ -44826,39 +44867,6 @@ var init_doctor_status = __esm(() => {
   init_source();
 });
 
-// src/config/thinking-effort-risk.ts
-function isRiskyThinkingEffort(effort) {
-  if (!effort)
-    return false;
-  return RISKY_EFFORTS.has(effort.trim().toLowerCase());
-}
-function emitsAdaptiveThinking(model) {
-  if (!model)
-    return false;
-  const m = model.trim().toLowerCase();
-  return m === "opus" || m.startsWith("claude-opus-");
-}
-function isAdaptiveThinkingOpus(model) {
-  if (!model)
-    return false;
-  const m = model.trim().toLowerCase();
-  return m.startsWith("claude-opus-4");
-}
-function assessThinkingEffortRisk(model, effort) {
-  if (!isRiskyThinkingEffort(effort))
-    return { risky: false };
-  if (!isAdaptiveThinkingOpus(model))
-    return { risky: false };
-  return {
-    risky: true,
-    reason: `thinking_effort '${effort}' on pinned Opus 4.x model '${model}' could trigger ` + `'400 thinking/redacted_thinking blocks cannot be modified' errors when work runs ` + `through concurrent sub-agents (issue #1978). The upstream claude-CLI fix shipped in ` + `${CLAUDE_CLI_THINKING_MERGE_FIX_VERSION}, but the Opus 4.x reproduction has not been ` + `re-tested since, so pin 'thinking_effort: low' or move the agent to a current Opus model.`
-  };
-}
-var CLAUDE_CLI_THINKING_MERGE_FIX_VERSION = "2.1.156", RISKY_EFFORTS;
-var init_thinking_effort_risk = __esm(() => {
-  RISKY_EFFORTS = new Set(["medium", "high", "xhigh", "max"]);
-});
-
 // src/manifest.ts
 import {
   existsSync as existsSync61,
@@ -45983,7 +45991,7 @@ var init_install_cron = () => {};
 function inParts(memories) {
   return Math.round(memories * PARTS_PER_MEMORY);
 }
-var RING_MAX = 8, MAX_SAMPLE_AGE_MS, MIN_RETAIN_SAMPLES = 20, RETAIN_FAILURE_RATE = 0.1, PARTS_PER_MEMORY = 6, QUEUE_FLOOR_MEMORIES = 100, QUEUE_FLOOR, QUEUE_GROWTH_FRACTION = 0.1, QUEUE_GROWTH_MIN_ABS_MEMORIES = 20, QUEUE_GROWTH_MIN_ABS, BREACHES_TO_FIRE_LEVEL = 2, BREACHES_TO_FIRE_EDGE = 1, CLEARS_TO_RESOLVE = 2, RENOTIFY_MS, DEFAULT_METRICS_URL = "http://127.0.0.1:18888/metrics", DEFAULT_CONTAINER = "switchroom-hindsight", METRICS_MAX_BYTES, METRICS_TIMEOUT_MS = 1e4, RECALL_OWN_BANK_TIMEOUT_WARN = 0.05, RECALL_OWN_BANK_TIMEOUT_PAGE = 0.15, RECALL_ZERO_MEMORY_WARN = 0.25, RECALL_ZERO_MEMORY_PAGE = 0.4, RECALL_POOL_MEDIAN_WARN = 8, RECALL_POOL_MEDIAN_PAGE = 3, RECALL_SCORE_P50_WARN = 0.02, RECALL_SCORE_P50_PAGE = 0.01, CONSOLIDATION_AGE_WARN_S, CONSOLIDATION_AGE_PAGE_S, RECALL_MIN_SAMPLES = 30, LLM_FAILURE_RATE_WARN = 0.02, LLM_FAILURE_RATE_PAGE = 0.1, LLM_MIN_SAMPLES = 20;
+var RING_MAX = 8, MAX_SAMPLE_AGE_MS, MIN_RETAIN_SAMPLES = 20, RETAIN_FAILURE_RATE = 0.1, PARTS_PER_MEMORY = 6, QUEUE_FLOOR_MEMORIES = 100, QUEUE_FLOOR, QUEUE_GROWTH_FRACTION = 0.1, QUEUE_GROWTH_MIN_ABS_MEMORIES = 20, QUEUE_GROWTH_MIN_ABS, BREACHES_TO_FIRE_LEVEL = 2, BREACHES_TO_FIRE_EDGE = 1, CLEARS_TO_RESOLVE = 2, RENOTIFY_MS, DEFAULT_METRICS_URL = "http://127.0.0.1:18888/metrics", DEFAULT_CONTAINER = "switchroom-hindsight", METRICS_MAX_BYTES, METRICS_TIMEOUT_MS = 1e4, RECALL_OWN_BANK_TIMEOUT_WARN = 0.05, RECALL_OWN_BANK_TIMEOUT_PAGE = 0.15, RECALL_ZERO_MEMORY_WARN = 0.25, RECALL_ZERO_MEMORY_PAGE = 0.4, RECALL_POOL_MEDIAN_WARN = 8, RECALL_POOL_MEDIAN_PAGE = 3, RECALL_SCORE_P50_WARN = 0.02, RECALL_SCORE_P50_PAGE = 0.01, CONSOLIDATION_AGE_WARN_S, CONSOLIDATION_AGE_PAGE_S, CONSOLIDATION_FAILURE_STREAK_WARN = 3, CONSOLIDATION_FAILURE_STREAK_PAGE = 10, CONSOLIDATION_STREAK_RECENCY_S, PENDING_CONSOLIDATION_FLOOR = 500, PENDING_CONSOLIDATION_GROWTH_FRACTION = 0.5, PENDING_CONSOLIDATION_GROWTH_WARN_ABS = 500, PENDING_CONSOLIDATION_GROWTH_PAGE_ABS = 5000, VECTOR_INDEX_SAMPLE_ROWS = 3, RECALL_MIN_SAMPLES = 30, LLM_FAILURE_RATE_WARN = 0.02, LLM_FAILURE_RATE_PAGE = 0.1, LLM_MIN_SAMPLES = 20;
 var init_thresholds = __esm(() => {
   MAX_SAMPLE_AGE_MS = 3 * 60 * 60000;
   QUEUE_FLOOR = inParts(QUEUE_FLOOR_MEMORIES);
@@ -45992,6 +46000,7 @@ var init_thresholds = __esm(() => {
   METRICS_MAX_BYTES = 16 * 1024 * 1024;
   CONSOLIDATION_AGE_WARN_S = 2 * 60 * 60;
   CONSOLIDATION_AGE_PAGE_S = 12 * 60 * 60;
+  CONSOLIDATION_STREAK_RECENCY_S = 2 * 60 * 60;
 });
 
 // src/hindsight-watch/types.ts
@@ -46022,7 +46031,9 @@ function loadState(path6) {
   const ring = s.ring.filter(isSample).map((sample) => ({
     ...sample,
     recall: normalizeRecallSample(sample.recall),
-    consolidation: normalizeConsolidationSample(sample.consolidation)
+    consolidation: normalizeConsolidationSample(sample.consolidation),
+    banks: normalizeBankSample(sample.banks),
+    vectorIndex: normalizeVectorIndexSample(sample.vectorIndex)
   })).slice(-RING_MAX);
   const signals = typeof s.signals === "object" && s.signals !== null ? s.signals : {};
   return { v: 1, ring, signals };
@@ -46066,6 +46077,36 @@ function normalizeConsolidationSample(x) {
     return null;
   return x;
 }
+function normalizeBankSample(x) {
+  if (x === null || typeof x !== "object")
+    return null;
+  const b = x;
+  if (!Array.isArray(b.streaks) || !Array.isArray(b.pending))
+    return null;
+  const streaks = b.streaks.filter((r) => {
+    if (typeof r !== "object" || r === null)
+      return false;
+    const s = r;
+    return typeof s.bank === "string" && typeof s.operationType === "string" && isCount(s.streak) && isCount(s.newestFailureAgeS);
+  });
+  const pending = b.pending.filter((r) => {
+    if (typeof r !== "object" || r === null)
+      return false;
+    const p = r;
+    return typeof p.bank === "string" && isCount(p.pending);
+  });
+  return { streaks, pending };
+}
+function normalizeVectorIndexSample(x) {
+  if (x === null || typeof x !== "object")
+    return null;
+  const v = x;
+  if (!isCount(v.probed))
+    return null;
+  if (!Array.isArray(v.corrupt) || !v.corrupt.every((s) => typeof s === "string"))
+    return null;
+  return { probed: v.probed, corrupt: v.corrupt };
+}
 function isSample(x) {
   if (typeof x !== "object" || x === null)
     return false;
@@ -71102,9 +71143,600 @@ import { execFileSync as execFileSync11 } from "node:child_process";
 
 // src/agents/handoff-summarizer.ts
 init_atomic();
-init_observation_scopes();
 import { readFileSync as readFileSync19, writeFileSync as writeFileSync9, renameSync as renameSync7, mkdirSync as mkdirSync16, existsSync as existsSync23, statSync as statSync11, readdirSync as readdirSync10 } from "node:fs";
 import { join as join18 } from "node:path";
+
+// telegram-plugin/secret-detect/patterns.ts
+var ANCHORED_PATTERNS = [
+  { rule_id: "anthropic_api_key", regex: /\b(sk-ant-[A-Za-z0-9_-]{8,})\b/g, captureIndex: 1, slugHint: "anthropic_api_key" },
+  { rule_id: "anthropic_oauth_code", regex: /(?:^|\s)([A-Za-z0-9_-]{20,}#[A-Za-z0-9_-]{20,})(?=\s|$)/gm, captureIndex: 1, slugHint: "anthropic_oauth_code" },
+  { rule_id: "openai_api_key", regex: /\b(sk-[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "openai_api_key" },
+  { rule_id: "github_pat_classic", regex: /\b(ghp_[A-Za-z0-9]{20,})\b/g, captureIndex: 1, slugHint: "github_pat" },
+  { rule_id: "github_pat_fine_grained", regex: /\b(github_pat_[A-Za-z0-9_]{20,})\b/g, captureIndex: 1, slugHint: "github_pat" },
+  { rule_id: "slack_token", regex: /\b(xox[baprs]-[A-Za-z0-9-]{10,})\b/g, captureIndex: 1, slugHint: "slack_token" },
+  { rule_id: "slack_app_token", regex: /\b(xapp-[A-Za-z0-9-]{10,})\b/g, captureIndex: 1, slugHint: "slack_app_token" },
+  { rule_id: "groq_api_key", regex: /\b(gsk_[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "groq_api_key" },
+  { rule_id: "google_api_key", regex: /\b(AIza[0-9A-Za-z\-_]{20,})\b/g, captureIndex: 1, slugHint: "google_api_key" },
+  { rule_id: "perplexity_api_key", regex: /\b(pplx-[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "perplexity_api_key" },
+  { rule_id: "npm_token", regex: /\b(npm_[A-Za-z0-9]{10,})\b/g, captureIndex: 1, slugHint: "npm_token" },
+  { rule_id: "telegram_bot_token_prefixed", regex: /\bbot(\d{6,}:[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "telegram_bot_token" },
+  { rule_id: "telegram_bot_token", regex: /\b(\d{6,}:[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "telegram_bot_token" },
+  { rule_id: "laravel_sanctum_token", regex: /\b(\d+\|[A-Za-z0-9]{40,})\b/g, captureIndex: 1, slugHint: "api_token" },
+  { rule_id: "aws_access_key", regex: /\b(AKIA[0-9A-Z]{16})\b/g, captureIndex: 1, slugHint: "aws_access_key" },
+  { rule_id: "jwt", regex: /\b(eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "jwt" }
+];
+var STRUCTURED_PATTERNS = [
+  {
+    rule_id: "env_key_value",
+    regex: /\b([A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD))\b\s*[=:]\s*(["']?)([^\s"'\\]+)\2/g,
+    captureIndex: 3,
+    slugHint: "env"
+  },
+  {
+    rule_id: "json_secret_field",
+    regex: /"(?:apiKey|token|secret|password|passwd|accessToken|refreshToken)"\s*:\s*"([^"]+)"/g,
+    captureIndex: 1,
+    slugHint: "json_secret"
+  },
+  {
+    rule_id: "cli_flag",
+    regex: /--(?:api[-_]?key|hook[-_]?token|token|secret|password|passwd)\s+(["']?)([^\s"']+)\1/g,
+    captureIndex: 2,
+    slugHint: "cli_flag"
+  },
+  {
+    rule_id: "bearer_auth_header",
+    regex: /Authorization\s*[:=]\s*Bearer\s+([A-Za-z0-9._\-+=]+)/gi,
+    captureIndex: 1,
+    slugHint: "bearer_token"
+  },
+  {
+    rule_id: "bearer_loose",
+    regex: /\bBearer\s+([A-Za-z0-9._\-+=]{18,})\b/gi,
+    captureIndex: 1,
+    slugHint: "bearer_token"
+  },
+  {
+    rule_id: "basic_auth_header",
+    regex: /Authorization\s*[:=]\s*Basic\s+([A-Za-z0-9+/=]{8,})/gi,
+    captureIndex: 1,
+    slugHint: "basic_auth"
+  },
+  {
+    rule_id: "pem_private_key",
+    regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----/g,
+    captureIndex: 0,
+    slugHint: "pem_private_key"
+  }
+];
+var PROVIDER_PATTERNS = [
+  { rule_id: "slack_webhook", regex: /(https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9_/]+)/g, captureIndex: 1, slugHint: "slack_webhook" },
+  { rule_id: "stripe_live_secret", regex: /\b(sk_live_[A-Za-z0-9]{24,})\b/g, captureIndex: 1, slugHint: "stripe_key" },
+  { rule_id: "stripe_restricted", regex: /\b(rk_live_[A-Za-z0-9]{24,})\b/g, captureIndex: 1, slugHint: "stripe_key" },
+  { rule_id: "sendgrid_api_key", regex: /\b(SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43})\b/g, captureIndex: 1, slugHint: "sendgrid_key" },
+  { rule_id: "gitlab_pat", regex: /\b(glpat-[A-Za-z0-9_-]{20})\b/g, captureIndex: 1, slugHint: "gitlab_pat" },
+  { rule_id: "huggingface_token", regex: /\b(hf_[A-Za-z0-9]{34,})\b/g, captureIndex: 1, slugHint: "huggingface_token" },
+  { rule_id: "twilio_api_key", regex: /\b(SK[0-9a-f]{32})\b/g, captureIndex: 1, slugHint: "twilio_api_key" },
+  { rule_id: "mailgun_key", regex: /\b(key-[0-9a-f]{32})\b/g, captureIndex: 1, slugHint: "mailgun_key" },
+  { rule_id: "digitalocean_pat", regex: /\b(dop_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
+  { rule_id: "digitalocean_oauth", regex: /\b(doo_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
+  { rule_id: "digitalocean_refresh", regex: /\b(dor_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
+  { rule_id: "doppler_token", regex: /\b(dp\.(?:pt|st|ct|sa|scim|audit)\.[A-Za-z0-9]{40,44})\b/g, captureIndex: 1, slugHint: "doppler_token" },
+  { rule_id: "linear_api_key", regex: /\b(lin_api_[A-Za-z0-9]{40})\b/g, captureIndex: 1, slugHint: "linear_api_key" },
+  { rule_id: "shopify_access_token", regex: /\b(shpat_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
+  { rule_id: "shopify_shared_secret", regex: /\b(shpss_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
+  { rule_id: "shopify_private_app", regex: /\b(shppa_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
+  { rule_id: "square_access_token", regex: /\b(sq0atp-[A-Za-z0-9_-]{22})\b/g, captureIndex: 1, slugHint: "square_token" },
+  { rule_id: "square_oauth_secret", regex: /\b(sq0csp-[A-Za-z0-9_-]{43})\b/g, captureIndex: 1, slugHint: "square_token" },
+  { rule_id: "newrelic_key", regex: /\b(NRAK-[A-Z0-9]{27})\b/g, captureIndex: 1, slugHint: "newrelic_key" },
+  { rule_id: "notion_token", regex: /\b(ntn_[A-Za-z0-9]{46})\b/g, captureIndex: 1, slugHint: "notion_token" },
+  { rule_id: "planetscale_password", regex: /\b(pscale_pw_[A-Za-z0-9_.-]{43})\b/g, captureIndex: 1, slugHint: "planetscale_token" },
+  { rule_id: "planetscale_token", regex: /\b(pscale_tkn_[A-Za-z0-9_.-]{43})\b/g, captureIndex: 1, slugHint: "planetscale_token" },
+  { rule_id: "supabase_service_key", regex: /\b(sbp_[a-f0-9]{40})\b/g, captureIndex: 1, slugHint: "supabase_key" },
+  { rule_id: "atlassian_token", regex: /\b(ATATT[A-Za-z0-9_\-=]{20,})\b/g, captureIndex: 1, slugHint: "atlassian_token" },
+  { rule_id: "dropbox_token", regex: /\b(sl\.[A-Za-z0-9_-]{130,})/g, captureIndex: 1, slugHint: "dropbox_token" },
+  { rule_id: "databricks_token", regex: /\b(dapi[a-f0-9]{32})\b/g, captureIndex: 1, slugHint: "databricks_token" },
+  { rule_id: "grafana_service_account", regex: /\b(glsa_[A-Za-z0-9]{32}_[a-fA-F0-9]{8})\b/g, captureIndex: 1, slugHint: "grafana_token" },
+  { rule_id: "pypi_token", regex: /\b(pypi-AgEIcHlwaS[A-Za-z0-9_-]{50,})/g, captureIndex: 1, slugHint: "pypi_token" },
+  { rule_id: "aws_temp_access_key", regex: /\b(ASIA[0-9A-Z]{16})\b/g, captureIndex: 1, slugHint: "aws_access_key" },
+  { rule_id: "gcp_oauth_token", regex: /\b(ya29\.[A-Za-z0-9_-]{30,})/g, captureIndex: 1, slugHint: "gcp_oauth_token" }
+];
+var ALL_PATTERNS = [...ANCHORED_PATTERNS, ...PROVIDER_PATTERNS, ...STRUCTURED_PATTERNS];
+
+// telegram-plugin/secret-detect/entropy.ts
+function shannonEntropy(s) {
+  if (s.length === 0)
+    return 0;
+  const counts = new Map;
+  for (const ch of s) {
+    counts.set(ch, (counts.get(ch) ?? 0) + 1);
+  }
+  let h = 0;
+  const len = s.length;
+  for (const c of counts.values()) {
+    const p = c / len;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+
+// telegram-plugin/secret-detect/inert-values.ts
+var INERT_VALUE_RE = [
+  /^\[REDACTED(?::[A-Za-z0-9_]+)?\]$/i,
+  /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/,
+  /^\{\{[^\n\r\u2028\u2029]*\}\}$/,
+  /^<[^<>\n\r\u2028\u2029]*>$/,
+  /^%[A-Za-z_][A-Za-z0-9_]*%$/,
+  /^vault:[A-Za-z0-9_./-]*$/i,
+  /^[*x\u2022.]+$/i,
+  /^(?:process\.env|import\.meta\.env|os\.environ)(?:\.[A-Za-z_$][A-Za-z0-9_$]*|\[["']?[A-Za-z_$][A-Za-z0-9_$]*["']?\])*$/,
+  /^(?:changeme|change-me|replaceme|replace-me|placeholder|todo|tbd|yourkey|your-key|yourpassword|your-password|yoursecret|your-secret|yourtoken|your-token)(?:[-_][A-Za-z0-9-]+)?$/i,
+  /^[a-z]+(?: [a-z]+){2,}$/
+];
+var CREDENTIAL_RUN_RE = /[A-Za-z0-9]{12,}/g;
+var MIXED_CLASS_RUN_MIN = 12;
+var SINGLE_CLASS_RUN_MIN = 16;
+function runIsCredentialShaped(run) {
+  let classes = 0;
+  if (/[a-z]/.test(run))
+    classes++;
+  if (/[A-Z]/.test(run))
+    classes++;
+  if (/[0-9]/.test(run))
+    classes++;
+  return run.length >= (classes >= 2 ? MIXED_CLASS_RUN_MIN : SINGLE_CLASS_RUN_MIN);
+}
+function hasCredentialShapedRun(value) {
+  for (const run of value.match(CREDENTIAL_RUN_RE) ?? []) {
+    if (runIsCredentialShaped(run))
+      return true;
+  }
+  return false;
+}
+function isInertValue(value) {
+  if (!INERT_VALUE_RE.some((re) => re.test(value)))
+    return false;
+  return !hasCredentialShapedRun(value);
+}
+var INERT_GATED_RULES = new Set([
+  "env_key_value",
+  "json_secret_field",
+  "cli_flag"
+]);
+var TRAILING_PUNCT_RE = /[.,;:!?)\]}]+$/;
+function stripTrailingPunctuation(value) {
+  return value.replace(TRAILING_PUNCT_RE, "");
+}
+
+// telegram-plugin/secret-detect/kv-scanner.ts
+var KV_RE = /\b([A-Za-z_][A-Za-z0-9_-]*(?:password|passwd|token|secret|key|api[_-]?key))\s*[:=]\s*["']?([^\s"'\\]{8,})["']?/gi;
+var KV_ENTROPY_THRESHOLD = 4;
+var MEMORABLE_PW_RE = /\b([A-Za-z0-9_-]*(?:password|passwd|passphrase|pwd))\b\s*(?:[:=]\s*|\s+is\s+)(["']?)([^\s"']{8,64})\2/gi;
+var MEMORABLE_PW_RULE_ID = "memorable_password";
+var MEMORABLE_PW_MIN_CLASSES = 2;
+function charClassCount(value) {
+  let n = 0;
+  if (/[a-z]/.test(value))
+    n++;
+  if (/[A-Z]/.test(value))
+    n++;
+  if (/[0-9]/.test(value))
+    n++;
+  if (/[^A-Za-z0-9]/.test(value))
+    n++;
+  return n;
+}
+function looksLikeMemorablePassword(value) {
+  if (isInertValue(value))
+    return false;
+  const core = stripTrailingPunctuation(value);
+  if (core.length < 8 || core.length > 64)
+    return false;
+  if (isInertValue(core))
+    return false;
+  if (new Set(core).size < 4)
+    return false;
+  return charClassCount(core) >= MEMORABLE_PW_MIN_CLASSES;
+}
+function scanMemorablePasswords(text) {
+  const hits = [];
+  MEMORABLE_PW_RE.lastIndex = 0;
+  let m;
+  while ((m = MEMORABLE_PW_RE.exec(text)) !== null) {
+    const keyName = m[1];
+    const value = m[3];
+    if (!value || !looksLikeMemorablePassword(value))
+      continue;
+    const valueOffsetInMatch = m[0].indexOf(value, keyName.length);
+    if (valueOffsetInMatch < 0)
+      continue;
+    const start = m.index + valueOffsetInMatch;
+    hits.push({
+      rule_id: MEMORABLE_PW_RULE_ID,
+      start,
+      end: start + value.length,
+      matched_text: value,
+      key_name: keyName,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
+function scanKeyValue(text) {
+  const hits = [];
+  KV_RE.lastIndex = 0;
+  let m;
+  while ((m = KV_RE.exec(text)) !== null) {
+    const [, keyName, value] = m;
+    if (!value)
+      continue;
+    if (isInertValue(value))
+      continue;
+    const h = shannonEntropy(value);
+    if (h < KV_ENTROPY_THRESHOLD)
+      continue;
+    const valueOffsetInMatch = m[0].indexOf(value, keyName.length);
+    if (valueOffsetInMatch < 0)
+      continue;
+    const start = m.index + valueOffsetInMatch;
+    const end = start + value.length;
+    hits.push({
+      rule_id: "kv_entropy",
+      start,
+      end,
+      matched_text: value,
+      key_name: keyName,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
+
+// telegram-plugin/secret-detect/db-uri.ts
+var DB_URI_RE = /\b([a-zA-Z][a-zA-Z0-9+.-]+):\/\/([^\s:/@]+):([^\s/?#]+)@([^\s/@?#]+)/g;
+var DB_URI_RULE_ID = "db_uri_password";
+function isInertPassword(value) {
+  if (value.startsWith("[REDACTED"))
+    return true;
+  return /^[*x]+$/i.test(value);
+}
+function scanDbUris(text) {
+  const hits = [];
+  DB_URI_RE.lastIndex = 0;
+  let m;
+  while ((m = DB_URI_RE.exec(text)) !== null) {
+    const scheme = m[1];
+    const user = m[2];
+    const password = m[3];
+    if (isInertPassword(password))
+      continue;
+    const start = m.index + scheme.length + 3 + user.length + 1;
+    hits.push({
+      rule_id: DB_URI_RULE_ID,
+      start,
+      end: start + password.length,
+      matched_text: password,
+      key_name: `${scheme}_password`,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
+
+// telegram-plugin/secret-detect/generic-entropy.ts
+var CANDIDATE_RE = /[A-Za-z0-9]{28,}/g;
+var GENERIC_MIN_DISTINCT = 18;
+var MAX_GENERIC_HITS = 20;
+function hasDistinctChars(tok, n) {
+  const seen = new Uint8Array(128);
+  let distinct = 0;
+  for (let i = 0;i < tok.length; i++) {
+    const c = tok.charCodeAt(i);
+    if (seen[c] === 0) {
+      seen[c] = 1;
+      if (++distinct >= n)
+        return true;
+    }
+  }
+  return false;
+}
+function hasDigit(tok) {
+  for (let i = 0;i < tok.length; i++) {
+    const c = tok.charCodeAt(i);
+    if (c >= 48 && c <= 57)
+      return true;
+  }
+  return false;
+}
+function scanGenericSecrets(text) {
+  const hits = [];
+  CANDIDATE_RE.lastIndex = 0;
+  let m;
+  while ((m = CANDIDATE_RE.exec(text)) !== null) {
+    if (hits.length >= MAX_GENERIC_HITS)
+      break;
+    const tok = m[0];
+    if (!hasDigit(tok))
+      continue;
+    if (!hasDistinctChars(tok, GENERIC_MIN_DISTINCT))
+      continue;
+    hits.push({
+      rule_id: "generic_high_entropy",
+      start: m.index,
+      end: m.index + tok.length,
+      matched_text: tok,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
+
+// telegram-plugin/secret-detect/chunker.ts
+var CHUNK_THRESHOLD = 32 * 1024;
+var WINDOW_SIZE = 16 * 1024;
+var OVERLAP = 8 * 1024;
+function chunk(text) {
+  if (text.length <= CHUNK_THRESHOLD) {
+    return [{ offset: 0, text }];
+  }
+  const out = [];
+  let offset = 0;
+  while (offset < text.length) {
+    const end = Math.min(offset + WINDOW_SIZE, text.length);
+    out.push({ offset, text: text.slice(offset, end) });
+    if (end >= text.length)
+      break;
+    offset = end - OVERLAP;
+  }
+  return out;
+}
+
+// telegram-plugin/secret-detect/suppressor.ts
+var MARKERS = ["test", "mock", "example", "fixture", "dummy"];
+var WINDOW = 40;
+var MARKER_RE = new RegExp(`\\b(?:${MARKERS.join("|")})\\b`, "i");
+function isSuppressed(text, start, end) {
+  const left = Math.max(0, start - WINDOW);
+  const right = Math.min(text.length, end + WINDOW);
+  const context = text.slice(left, start) + text.slice(end, right);
+  return MARKER_RE.test(context);
+}
+
+// telegram-plugin/secret-detect/slug.ts
+function sanitizeKeyName(raw) {
+  const up = raw.toUpperCase();
+  const cleaned = up.replace(/[^A-Z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  return cleaned.length > 0 ? cleaned : "SECRET";
+}
+function datePart(now = new Date) {
+  const y = now.getUTCFullYear();
+  const m = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(now.getUTCDate()).padStart(2, "0");
+  return `${y}${m}${d}`;
+}
+function deriveSlug(inputs, existing) {
+  let base;
+  if (inputs.key_name && inputs.key_name.trim().length > 0) {
+    base = sanitizeKeyName(inputs.key_name);
+  } else {
+    base = `${inputs.rule_id}_${datePart(inputs.now)}`;
+  }
+  if (!existing.has(base))
+    return base;
+  let n = 2;
+  while (existing.has(`${base}_${n}`))
+    n++;
+  return `${base}_${n}`;
+}
+// telegram-plugin/secret-detect/url-redact.ts
+var SENSITIVE_PARAMS = new Set([
+  "token",
+  "key",
+  "api_key",
+  "apikey",
+  "secret",
+  "access_token",
+  "password",
+  "pass",
+  "auth",
+  "client_secret",
+  "refresh_token",
+  "signature"
+]);
+var URL_RE = /\b(?:https?|wss?|ftp):\/\/[^\s<>"']+/gi;
+function redactUrls(text) {
+  return text.replace(URL_RE, (m) => {
+    const redacted = redactOne(m);
+    return redacted ?? m;
+  });
+}
+function redactOne(raw) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    return null;
+  }
+  let changed = false;
+  if (u.username || u.password) {
+    u.username = "***";
+    u.password = "";
+    changed = true;
+  }
+  for (const [key] of u.searchParams) {
+    if (SENSITIVE_PARAMS.has(key.toLowerCase())) {
+      u.searchParams.set(key, "***");
+      changed = true;
+    }
+  }
+  return changed ? u.toString() : null;
+}
+
+// telegram-plugin/secret-detect/index.ts
+function detectSecrets(text) {
+  if (!text || text.length === 0)
+    return [];
+  const windows = chunk(text);
+  const raw = [];
+  for (const win of windows) {
+    for (const p of ALL_PATTERNS) {
+      const re = new RegExp(p.regex.source, p.regex.flags.includes("g") ? p.regex.flags : p.regex.flags + "g");
+      let m;
+      while ((m = re.exec(win.text)) !== null) {
+        if (m[0].length === 0) {
+          re.lastIndex++;
+          continue;
+        }
+        const cap = p.captureIndex === 0 ? m[0] : m[p.captureIndex];
+        if (!cap)
+          continue;
+        const matchStart = p.captureIndex === 0 ? m.index : m.index + m[0].indexOf(cap);
+        if (matchStart < 0)
+          continue;
+        const globalStart = win.offset + matchStart;
+        const globalEnd = globalStart + cap.length;
+        const keyName = p.rule_id === "env_key_value" ? m[1] : undefined;
+        if (INERT_GATED_RULES.has(p.rule_id) && isInertValue(cap))
+          continue;
+        if (p.rule_id === "env_key_value") {
+          const ENV_KV_MIN_LEN = 12;
+          const ENV_KV_MIN_ENTROPY = 3.5;
+          if (cap.length < ENV_KV_MIN_LEN)
+            continue;
+          if (shannonEntropy(cap) < ENV_KV_MIN_ENTROPY)
+            continue;
+        }
+        raw.push({
+          rule_id: p.rule_id,
+          start: globalStart,
+          end: globalEnd,
+          matched_text: cap,
+          key_name: keyName,
+          confidence: "high"
+        });
+      }
+    }
+    const kvHits = scanKeyValue(win.text);
+    for (const h of kvHits) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
+    for (const h of scanDbUris(win.text)) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
+    for (const h of scanMemorablePasswords(win.text)) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
+    const genHits = scanGenericSecrets(win.text);
+    for (const h of genHits) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
+  }
+  const deduped = dedupeRaw(raw);
+  const final = dropOverlaps(deduped);
+  const existing = new Set;
+  const out = [];
+  for (const h of final) {
+    const suggested_slug = deriveSlug({ key_name: h.key_name, rule_id: h.rule_id }, existing);
+    existing.add(suggested_slug);
+    out.push({
+      rule_id: h.rule_id,
+      matched_text: h.matched_text,
+      start: h.start,
+      end: h.end,
+      confidence: h.confidence,
+      suppressed: isSuppressed(text, h.start, h.end),
+      suggested_slug,
+      key_name: h.key_name
+    });
+  }
+  out.sort((a, b) => a.start - b.start);
+  return out;
+}
+function dedupeRaw(raw) {
+  const seen = new Map;
+  for (const h of raw) {
+    const key = `${h.start}:${h.end}`;
+    const existing = seen.get(key);
+    if (!existing) {
+      seen.set(key, h);
+      continue;
+    }
+    if (existing.confidence === "ambiguous" && h.confidence === "high") {
+      seen.set(key, h);
+    }
+  }
+  return Array.from(seen.values());
+}
+function dropOverlaps(hits) {
+  const out = hits.filter((h) => !(h.confidence === "ambiguous" && hits.some((o) => o !== h && o.start <= h.start && o.end >= h.end && !(o.start === h.start && o.end === h.end))));
+  out.sort((a, b) => a.start - b.start || a.end - b.end);
+  return out;
+}
+
+// telegram-plugin/secret-detect/redact.ts
+var REDACTED_MARKER = "[REDACTED]";
+function redact(text) {
+  if (!text || text.length === 0)
+    return text;
+  const urlScrubbed = redactUrls(text);
+  const hits = detectSecrets(urlScrubbed).filter((h) => h.rule_id !== "generic_high_entropy");
+  if (hits.length === 0)
+    return urlScrubbed;
+  const sorted = [...hits].sort((a, b) => b.start - a.start);
+  let out = urlScrubbed;
+  for (const h of sorted) {
+    out = out.slice(0, h.start) + redactedMarker(h.rule_id) + out.slice(h.end);
+  }
+  return out;
+}
+function redactedMarker(ruleId) {
+  const trimmed = ruleId.replace(/^(kv|env)_/, "");
+  if (!trimmed || trimmed === "key_value" || trimmed === "kv_entropy") {
+    return REDACTED_MARKER;
+  }
+  return `[REDACTED:${trimmed}]`;
+}
+// src/memory/hindsight-write-redaction.ts
+function redactJsonStrings(value) {
+  if (typeof value === "string")
+    return redact(value);
+  if (Array.isArray(value))
+    return value.map(redactJsonStrings);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redactJsonStrings(v);
+    }
+    return out;
+  }
+  return value;
+}
+var REDACTED_ITEM_FIELDS = ["content", "context"];
+function redactMemoryWriteBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body))
+    return body;
+  const src = body;
+  if (!Array.isArray(src.items))
+    return body;
+  const items = src.items.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      return item;
+    const row = { ...item };
+    for (const field of REDACTED_ITEM_FIELDS) {
+      if (typeof row[field] === "string") {
+        row[field] = redact(row[field]);
+      }
+    }
+    if (row.metadata && typeof row.metadata === "object") {
+      row.metadata = redactJsonStrings(row.metadata);
+    }
+    return row;
+  });
+  return { ...src, items };
+}
+
+// src/agents/handoff-summarizer.ts
+init_observation_scopes();
 var HANDOFF_STATUS_MIRROR_SKIPPED = "mirror-skipped-invalid-scope";
 var DEFAULT_MAX_TURNS = 50;
 var TOPIC_MAX_CHARS = 117;
@@ -71291,7 +71923,7 @@ async function mirrorToHindsight(briefing, opts) {
 `);
     return false;
   }
-  const body = {
+  const body = redactMemoryWriteBody({
     items: [
       {
         content: briefing,
@@ -71301,7 +71933,7 @@ async function mirrorToHindsight(briefing, opts) {
       }
     ],
     async: true
-  };
+  });
   try {
     await fetchFn(endpoint, {
       method: "POST",
@@ -74307,8 +74939,8 @@ Bootstrapping agent: ${name}
     const code = await new Promise((resolve24) => {
       process.stdin.setEncoding("utf-8");
       let buf = "";
-      process.stdin.on("data", (chunk) => {
-        buf += chunk.toString();
+      process.stdin.on("data", (chunk2) => {
+        buf += chunk2.toString();
         const newlineIdx = buf.indexOf(`
 `);
         if (newlineIdx !== -1) {
@@ -74390,8 +75022,8 @@ switchroom agent add: ${name}
       return new Promise((resolveLine) => {
         process.stdin.setEncoding("utf-8");
         let buf = "";
-        const onData = (chunk) => {
-          buf += chunk.toString();
+        const onData = (chunk2) => {
+          buf += chunk2.toString();
           const newlineIdx = buf.indexOf(`
 `);
           if (newlineIdx !== -1) {
@@ -76422,8 +77054,8 @@ async function readHiddenLine2(prompt) {
       stdin.setRawMode(true);
     }
     let line = "";
-    const onData = (chunk) => {
-      const s = chunk.toString("utf8");
+    const onData = (chunk2) => {
+      const s = chunk2.toString("utf8");
       for (const ch of s) {
         if (ch === `
 ` || ch === "\r") {
@@ -77352,7 +77984,7 @@ function getVaultPath2(configPath) {
     return resolvePath("~/.switchroom/vault.enc");
   }
 }
-function maskToken(s) {
+function maskToken2(s) {
   if (s.length >= 18)
     return `${s.slice(0, 6)}...${s.slice(-4)}`;
   return "***";
@@ -77640,7 +78272,7 @@ function registerVaultSweep(vault, program3) {
     console.log("");
     console.log(source_default.dim(`masked values for display only:`));
     for (const v of values) {
-      console.log(`  vault:${v.key} \u2192 ${maskToken(v.value)}`);
+      console.log(`  vault:${v.key} \u2192 ${maskToken2(v.value)}`);
     }
     if (opts.dryRun) {
       console.log(source_default.yellow("dry-run \u2014 no files modified. Rerun without --dry-run to apply."));
@@ -80613,8 +81245,8 @@ class VaultBroker {
       peer = this.testOpts._testIdentify ? this.testOpts._testIdentify(listenerSocketPath, socket) : identify(listenerSocketPath, socket);
     }
     let buffer = "";
-    socket.on("data", (chunk) => {
-      buffer += chunk.toString("utf8");
+    socket.on("data", (chunk2) => {
+      buffer += chunk2.toString("utf8");
       if (Buffer.byteLength(buffer, "utf8") > MAX_FRAME_BYTES) {
         const resp = encodeResponse(errorResponse("BAD_REQUEST", "Frame exceeds 64 KiB limit"));
         socket.end(resp);
@@ -81723,8 +82355,8 @@ class VaultBroker {
     const auditCaller = isOperator ? "operator" : unlockPeer !== null ? callerFromPeer(unlockPeer) : `pid:${process.pid}`;
     const auditCgroup = isOperator ? undefined : unlockPeer?.systemdUnit ?? undefined;
     let buffer = "";
-    socket.on("data", (chunk) => {
-      buffer += chunk.toString("utf8");
+    socket.on("data", (chunk2) => {
+      buffer += chunk2.toString("utf8");
       const newlineIdx = buffer.indexOf(`
 `);
       if (newlineIdx === -1) {
@@ -83291,7 +83923,7 @@ function promptLine2(prompt, hidden = false) {
 function readStdinToEnd() {
   return new Promise((resolve30, reject) => {
     const chunks = [];
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("data", (chunk2) => chunks.push(chunk2));
     process.stdin.on("end", () => {
       resolve30(Buffer.concat(chunks).toString("utf8"));
     });
@@ -85443,9 +86075,9 @@ Repairing vector index coverage for ${target}${opts.dryRun ? source_default.yell
 `));
     const child = spawn5("docker", argv, { stdio: ["ignore", "pipe", "inherit"] });
     let captured = "";
-    child.stdout?.on("data", (chunk) => {
-      captured += chunk.toString();
-      process.stdout.write(chunk);
+    child.stdout?.on("data", (chunk2) => {
+      captured += chunk2.toString();
+      process.stdout.write(chunk2);
     });
     const childExit = await new Promise((resolve30) => {
       child.on("error", () => resolve30(127));
@@ -85546,14 +86178,21 @@ Demoting memory ${source_default.cyan(memoryId)}`));
     const timeoutMs = Math.max(1000, parseInt(opts.timeout, 10) || 60000);
     const ctrl = new AbortController;
     const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    const payload = redactMemoryWriteBody({
+      items: [{ content, tags: ["operator-authored", "profile"] }],
+      async: false
+    });
+    const stored = payload.items[0].content;
+    if (stored !== content) {
+      console.error(source_default.yellow(`\u26a0 Credential-shaped text in this fact was replaced with a
+` + `  [REDACTED] marker before it was stored. Put secrets in the
+` + "  vault (`switchroom vault set <key>`) and reference them as\n" + "  `vault:<key>` instead."));
+    }
     try {
       const res = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          items: [{ content, tags: ["operator-authored", "profile"] }],
-          async: false
-        }),
+        body: JSON.stringify(payload),
         signal: ctrl.signal
       });
       if (!res.ok) {
@@ -85561,7 +86200,7 @@ Demoting memory ${source_default.cyan(memoryId)}`));
         process.exit(1);
       }
       console.log(source_default.green(`\u2713 Added to profile bank "${bank}"`));
-      console.log(source_default.gray(`  ${content}`));
+      console.log(source_default.gray(`  ${stored}`));
       console.log(source_default.gray("  (fact extraction runs in the background \u2014 `profile list` may lag a few seconds)"));
       console.log(source_default.gray(`
   Wire it into agents via memory.recall.additional_banks: ["${bank}"] in switchroom.yaml,
@@ -87854,8 +88493,8 @@ function forwardToGateway(socketPath, req, opts = {}) {
       conn.write(JSON.stringify(req) + `
 `);
     });
-    conn.on("data", (chunk) => {
-      buf += chunk;
+    conn.on("data", (chunk2) => {
+      buf += chunk2;
       const nl = buf.indexOf(`
 `);
       if (nl === -1)
@@ -94034,410 +94673,6 @@ function computeFingerprint(source, code) {
   return `${source}::${code}`;
 }
 
-// telegram-plugin/secret-detect/patterns.ts
-var ANCHORED_PATTERNS = [
-  { rule_id: "anthropic_api_key", regex: /\b(sk-ant-[A-Za-z0-9_-]{8,})\b/g, captureIndex: 1, slugHint: "anthropic_api_key" },
-  { rule_id: "anthropic_oauth_code", regex: /(?:^|\s)([A-Za-z0-9_-]{20,}#[A-Za-z0-9_-]{20,})(?=\s|$)/gm, captureIndex: 1, slugHint: "anthropic_oauth_code" },
-  { rule_id: "openai_api_key", regex: /\b(sk-[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "openai_api_key" },
-  { rule_id: "github_pat_classic", regex: /\b(ghp_[A-Za-z0-9]{20,})\b/g, captureIndex: 1, slugHint: "github_pat" },
-  { rule_id: "github_pat_fine_grained", regex: /\b(github_pat_[A-Za-z0-9_]{20,})\b/g, captureIndex: 1, slugHint: "github_pat" },
-  { rule_id: "slack_token", regex: /\b(xox[baprs]-[A-Za-z0-9-]{10,})\b/g, captureIndex: 1, slugHint: "slack_token" },
-  { rule_id: "slack_app_token", regex: /\b(xapp-[A-Za-z0-9-]{10,})\b/g, captureIndex: 1, slugHint: "slack_app_token" },
-  { rule_id: "groq_api_key", regex: /\b(gsk_[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "groq_api_key" },
-  { rule_id: "google_api_key", regex: /\b(AIza[0-9A-Za-z\-_]{20,})\b/g, captureIndex: 1, slugHint: "google_api_key" },
-  { rule_id: "perplexity_api_key", regex: /\b(pplx-[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "perplexity_api_key" },
-  { rule_id: "npm_token", regex: /\b(npm_[A-Za-z0-9]{10,})\b/g, captureIndex: 1, slugHint: "npm_token" },
-  { rule_id: "telegram_bot_token_prefixed", regex: /\bbot(\d{6,}:[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "telegram_bot_token" },
-  { rule_id: "telegram_bot_token", regex: /\b(\d{6,}:[A-Za-z0-9_-]{20,})\b/g, captureIndex: 1, slugHint: "telegram_bot_token" },
-  { rule_id: "laravel_sanctum_token", regex: /\b(\d+\|[A-Za-z0-9]{40,})\b/g, captureIndex: 1, slugHint: "api_token" },
-  { rule_id: "aws_access_key", regex: /\b(AKIA[0-9A-Z]{16})\b/g, captureIndex: 1, slugHint: "aws_access_key" },
-  { rule_id: "jwt", regex: /\b(eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,})\b/g, captureIndex: 1, slugHint: "jwt" }
-];
-var STRUCTURED_PATTERNS = [
-  {
-    rule_id: "env_key_value",
-    regex: /\b([A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD))\b\s*[=:]\s*(["']?)([^\s"'\\]+)\2/g,
-    captureIndex: 3,
-    slugHint: "env"
-  },
-  {
-    rule_id: "json_secret_field",
-    regex: /"(?:apiKey|token|secret|password|passwd|accessToken|refreshToken)"\s*:\s*"([^"]+)"/g,
-    captureIndex: 1,
-    slugHint: "json_secret"
-  },
-  {
-    rule_id: "cli_flag",
-    regex: /--(?:api[-_]?key|hook[-_]?token|token|secret|password|passwd)\s+(["']?)([^\s"']+)\1/g,
-    captureIndex: 2,
-    slugHint: "cli_flag"
-  },
-  {
-    rule_id: "bearer_auth_header",
-    regex: /Authorization\s*[:=]\s*Bearer\s+([A-Za-z0-9._\-+=]+)/g,
-    captureIndex: 1,
-    slugHint: "bearer_token"
-  },
-  {
-    rule_id: "bearer_loose",
-    regex: /\bBearer\s+([A-Za-z0-9._\-+=]{18,})\b/g,
-    captureIndex: 1,
-    slugHint: "bearer_token"
-  },
-  {
-    rule_id: "pem_private_key",
-    regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----/g,
-    captureIndex: 0,
-    slugHint: "pem_private_key"
-  }
-];
-var PROVIDER_PATTERNS = [
-  { rule_id: "slack_webhook", regex: /(https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9_/]+)/g, captureIndex: 1, slugHint: "slack_webhook" },
-  { rule_id: "stripe_live_secret", regex: /\b(sk_live_[A-Za-z0-9]{24,})\b/g, captureIndex: 1, slugHint: "stripe_key" },
-  { rule_id: "stripe_restricted", regex: /\b(rk_live_[A-Za-z0-9]{24,})\b/g, captureIndex: 1, slugHint: "stripe_key" },
-  { rule_id: "sendgrid_api_key", regex: /\b(SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43})\b/g, captureIndex: 1, slugHint: "sendgrid_key" },
-  { rule_id: "gitlab_pat", regex: /\b(glpat-[A-Za-z0-9_-]{20})\b/g, captureIndex: 1, slugHint: "gitlab_pat" },
-  { rule_id: "huggingface_token", regex: /\b(hf_[A-Za-z0-9]{34,})\b/g, captureIndex: 1, slugHint: "huggingface_token" },
-  { rule_id: "twilio_api_key", regex: /\b(SK[0-9a-f]{32})\b/g, captureIndex: 1, slugHint: "twilio_api_key" },
-  { rule_id: "mailgun_key", regex: /\b(key-[0-9a-f]{32})\b/g, captureIndex: 1, slugHint: "mailgun_key" },
-  { rule_id: "digitalocean_pat", regex: /\b(dop_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
-  { rule_id: "digitalocean_oauth", regex: /\b(doo_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
-  { rule_id: "digitalocean_refresh", regex: /\b(dor_v1_[a-f0-9]{64})\b/g, captureIndex: 1, slugHint: "digitalocean_token" },
-  { rule_id: "doppler_token", regex: /\b(dp\.(?:pt|st|ct|sa|scim|audit)\.[A-Za-z0-9]{40,44})\b/g, captureIndex: 1, slugHint: "doppler_token" },
-  { rule_id: "linear_api_key", regex: /\b(lin_api_[A-Za-z0-9]{40})\b/g, captureIndex: 1, slugHint: "linear_api_key" },
-  { rule_id: "shopify_access_token", regex: /\b(shpat_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
-  { rule_id: "shopify_shared_secret", regex: /\b(shpss_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
-  { rule_id: "shopify_private_app", regex: /\b(shppa_[a-fA-F0-9]{32})\b/g, captureIndex: 1, slugHint: "shopify_token" },
-  { rule_id: "square_access_token", regex: /\b(sq0atp-[A-Za-z0-9_-]{22})\b/g, captureIndex: 1, slugHint: "square_token" },
-  { rule_id: "square_oauth_secret", regex: /\b(sq0csp-[A-Za-z0-9_-]{43})\b/g, captureIndex: 1, slugHint: "square_token" },
-  { rule_id: "newrelic_key", regex: /\b(NRAK-[A-Z0-9]{27})\b/g, captureIndex: 1, slugHint: "newrelic_key" },
-  { rule_id: "notion_token", regex: /\b(ntn_[A-Za-z0-9]{46})\b/g, captureIndex: 1, slugHint: "notion_token" },
-  { rule_id: "planetscale_password", regex: /\b(pscale_pw_[A-Za-z0-9_.-]{43})\b/g, captureIndex: 1, slugHint: "planetscale_token" },
-  { rule_id: "planetscale_token", regex: /\b(pscale_tkn_[A-Za-z0-9_.-]{43})\b/g, captureIndex: 1, slugHint: "planetscale_token" },
-  { rule_id: "supabase_service_key", regex: /\b(sbp_[a-f0-9]{40})\b/g, captureIndex: 1, slugHint: "supabase_key" },
-  { rule_id: "atlassian_token", regex: /\b(ATATT[A-Za-z0-9_\-=]{20,})\b/g, captureIndex: 1, slugHint: "atlassian_token" },
-  { rule_id: "dropbox_token", regex: /\b(sl\.[A-Za-z0-9_-]{130,})/g, captureIndex: 1, slugHint: "dropbox_token" },
-  { rule_id: "databricks_token", regex: /\b(dapi[a-f0-9]{32})\b/g, captureIndex: 1, slugHint: "databricks_token" },
-  { rule_id: "grafana_service_account", regex: /\b(glsa_[A-Za-z0-9]{32}_[a-fA-F0-9]{8})\b/g, captureIndex: 1, slugHint: "grafana_token" },
-  { rule_id: "pypi_token", regex: /\b(pypi-AgEIcHlwaS[A-Za-z0-9_-]{50,})/g, captureIndex: 1, slugHint: "pypi_token" },
-  { rule_id: "aws_temp_access_key", regex: /\b(ASIA[0-9A-Z]{16})\b/g, captureIndex: 1, slugHint: "aws_access_key" },
-  { rule_id: "gcp_oauth_token", regex: /\b(ya29\.[A-Za-z0-9_-]{30,})/g, captureIndex: 1, slugHint: "gcp_oauth_token" }
-];
-var ALL_PATTERNS = [...ANCHORED_PATTERNS, ...PROVIDER_PATTERNS, ...STRUCTURED_PATTERNS];
-
-// telegram-plugin/secret-detect/entropy.ts
-function shannonEntropy(s) {
-  if (s.length === 0)
-    return 0;
-  const counts = new Map;
-  for (const ch of s) {
-    counts.set(ch, (counts.get(ch) ?? 0) + 1);
-  }
-  let h = 0;
-  const len = s.length;
-  for (const c of counts.values()) {
-    const p = c / len;
-    h -= p * Math.log2(p);
-  }
-  return h;
-}
-
-// telegram-plugin/secret-detect/kv-scanner.ts
-var KV_RE = /\b([A-Za-z_][A-Za-z0-9_-]*(?:password|passwd|token|secret|key|api[_-]?key))\s*[:=]\s*["']?([^\s"'\\]{8,})["']?/gi;
-var KV_ENTROPY_THRESHOLD = 4;
-function scanKeyValue(text) {
-  const hits = [];
-  KV_RE.lastIndex = 0;
-  let m;
-  while ((m = KV_RE.exec(text)) !== null) {
-    const [, keyName, value] = m;
-    if (!value)
-      continue;
-    const h = shannonEntropy(value);
-    if (h < KV_ENTROPY_THRESHOLD)
-      continue;
-    const valueOffsetInMatch = m[0].indexOf(value, keyName.length);
-    if (valueOffsetInMatch < 0)
-      continue;
-    const start = m.index + valueOffsetInMatch;
-    const end = start + value.length;
-    hits.push({
-      rule_id: "kv_entropy",
-      start,
-      end,
-      matched_text: value,
-      key_name: keyName,
-      confidence: "ambiguous"
-    });
-  }
-  return hits;
-}
-
-// telegram-plugin/secret-detect/generic-entropy.ts
-var CANDIDATE_RE = /[A-Za-z0-9]{28,}/g;
-var GENERIC_MIN_DISTINCT = 18;
-var MAX_GENERIC_HITS = 20;
-function hasDistinctChars(tok, n) {
-  const seen = new Uint8Array(128);
-  let distinct = 0;
-  for (let i = 0;i < tok.length; i++) {
-    const c = tok.charCodeAt(i);
-    if (seen[c] === 0) {
-      seen[c] = 1;
-      if (++distinct >= n)
-        return true;
-    }
-  }
-  return false;
-}
-function hasDigit(tok) {
-  for (let i = 0;i < tok.length; i++) {
-    const c = tok.charCodeAt(i);
-    if (c >= 48 && c <= 57)
-      return true;
-  }
-  return false;
-}
-function scanGenericSecrets(text) {
-  const hits = [];
-  CANDIDATE_RE.lastIndex = 0;
-  let m;
-  while ((m = CANDIDATE_RE.exec(text)) !== null) {
-    if (hits.length >= MAX_GENERIC_HITS)
-      break;
-    const tok = m[0];
-    if (!hasDigit(tok))
-      continue;
-    if (!hasDistinctChars(tok, GENERIC_MIN_DISTINCT))
-      continue;
-    hits.push({
-      rule_id: "generic_high_entropy",
-      start: m.index,
-      end: m.index + tok.length,
-      matched_text: tok,
-      confidence: "ambiguous"
-    });
-  }
-  return hits;
-}
-
-// telegram-plugin/secret-detect/chunker.ts
-var CHUNK_THRESHOLD = 32 * 1024;
-var WINDOW_SIZE = 16 * 1024;
-var OVERLAP = 8 * 1024;
-function chunk(text) {
-  if (text.length <= CHUNK_THRESHOLD) {
-    return [{ offset: 0, text }];
-  }
-  const out = [];
-  let offset = 0;
-  while (offset < text.length) {
-    const end = Math.min(offset + WINDOW_SIZE, text.length);
-    out.push({ offset, text: text.slice(offset, end) });
-    if (end >= text.length)
-      break;
-    offset = end - OVERLAP;
-  }
-  return out;
-}
-
-// telegram-plugin/secret-detect/suppressor.ts
-var MARKERS = ["test", "mock", "example", "fixture", "dummy"];
-var WINDOW = 40;
-var MARKER_RE = new RegExp(`\\b(?:${MARKERS.join("|")})\\b`, "i");
-function isSuppressed(text, start, end) {
-  const left = Math.max(0, start - WINDOW);
-  const right = Math.min(text.length, end + WINDOW);
-  const context = text.slice(left, start) + text.slice(end, right);
-  return MARKER_RE.test(context);
-}
-
-// telegram-plugin/secret-detect/slug.ts
-function sanitizeKeyName(raw) {
-  const up = raw.toUpperCase();
-  const cleaned = up.replace(/[^A-Z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-  return cleaned.length > 0 ? cleaned : "SECRET";
-}
-function datePart(now = new Date) {
-  const y = now.getUTCFullYear();
-  const m = String(now.getUTCMonth() + 1).padStart(2, "0");
-  const d = String(now.getUTCDate()).padStart(2, "0");
-  return `${y}${m}${d}`;
-}
-function deriveSlug(inputs, existing) {
-  let base;
-  if (inputs.key_name && inputs.key_name.trim().length > 0) {
-    base = sanitizeKeyName(inputs.key_name);
-  } else {
-    base = `${inputs.rule_id}_${datePart(inputs.now)}`;
-  }
-  if (!existing.has(base))
-    return base;
-  let n = 2;
-  while (existing.has(`${base}_${n}`))
-    n++;
-  return `${base}_${n}`;
-}
-// telegram-plugin/secret-detect/url-redact.ts
-var SENSITIVE_PARAMS = new Set([
-  "token",
-  "key",
-  "api_key",
-  "apikey",
-  "secret",
-  "access_token",
-  "password",
-  "pass",
-  "auth",
-  "client_secret",
-  "refresh_token",
-  "signature"
-]);
-var URL_RE = /\b(?:https?|wss?|ftp):\/\/[^\s<>"']+/gi;
-function redactUrls(text) {
-  return text.replace(URL_RE, (m) => {
-    const redacted = redactOne(m);
-    return redacted ?? m;
-  });
-}
-function redactOne(raw) {
-  let u;
-  try {
-    u = new URL(raw);
-  } catch {
-    return null;
-  }
-  let changed = false;
-  if (u.username || u.password) {
-    u.username = "***";
-    u.password = "";
-    changed = true;
-  }
-  for (const [key] of u.searchParams) {
-    if (SENSITIVE_PARAMS.has(key.toLowerCase())) {
-      u.searchParams.set(key, "***");
-      changed = true;
-    }
-  }
-  return changed ? u.toString() : null;
-}
-
-// telegram-plugin/secret-detect/index.ts
-function detectSecrets(text) {
-  if (!text || text.length === 0)
-    return [];
-  const windows = chunk(text);
-  const raw = [];
-  for (const win of windows) {
-    for (const p of ALL_PATTERNS) {
-      const re = new RegExp(p.regex.source, p.regex.flags.includes("g") ? p.regex.flags : p.regex.flags + "g");
-      let m;
-      while ((m = re.exec(win.text)) !== null) {
-        if (m[0].length === 0) {
-          re.lastIndex++;
-          continue;
-        }
-        const cap = p.captureIndex === 0 ? m[0] : m[p.captureIndex];
-        if (!cap)
-          continue;
-        const matchStart = p.captureIndex === 0 ? m.index : m.index + m[0].indexOf(cap);
-        if (matchStart < 0)
-          continue;
-        const globalStart = win.offset + matchStart;
-        const globalEnd = globalStart + cap.length;
-        const keyName = p.rule_id === "env_key_value" ? m[1] : undefined;
-        if (p.rule_id === "env_key_value") {
-          const ENV_KV_MIN_LEN = 12;
-          const ENV_KV_MIN_ENTROPY = 3.5;
-          if (cap.length < ENV_KV_MIN_LEN)
-            continue;
-          if (shannonEntropy(cap) < ENV_KV_MIN_ENTROPY)
-            continue;
-        }
-        raw.push({
-          rule_id: p.rule_id,
-          start: globalStart,
-          end: globalEnd,
-          matched_text: cap,
-          key_name: keyName,
-          confidence: "high"
-        });
-      }
-    }
-    const kvHits = scanKeyValue(win.text);
-    for (const h of kvHits) {
-      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
-    }
-    const genHits = scanGenericSecrets(win.text);
-    for (const h of genHits) {
-      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
-    }
-  }
-  const deduped = dedupeRaw(raw);
-  const final = dropOverlaps(deduped);
-  const existing = new Set;
-  const out = [];
-  for (const h of final) {
-    const suggested_slug = deriveSlug({ key_name: h.key_name, rule_id: h.rule_id }, existing);
-    existing.add(suggested_slug);
-    out.push({
-      rule_id: h.rule_id,
-      matched_text: h.matched_text,
-      start: h.start,
-      end: h.end,
-      confidence: h.confidence,
-      suppressed: isSuppressed(text, h.start, h.end),
-      suggested_slug,
-      key_name: h.key_name
-    });
-  }
-  out.sort((a, b) => a.start - b.start);
-  return out;
-}
-function dedupeRaw(raw) {
-  const seen = new Map;
-  for (const h of raw) {
-    const key = `${h.start}:${h.end}`;
-    const existing = seen.get(key);
-    if (!existing) {
-      seen.set(key, h);
-      continue;
-    }
-    if (existing.confidence === "ambiguous" && h.confidence === "high") {
-      seen.set(key, h);
-    }
-  }
-  return Array.from(seen.values());
-}
-function dropOverlaps(hits) {
-  const out = hits.filter((h) => !(h.confidence === "ambiguous" && hits.some((o) => o !== h && o.start <= h.start && o.end >= h.end && !(o.start === h.start && o.end === h.end))));
-  out.sort((a, b) => a.start - b.start || a.end - b.end);
-  return out;
-}
-
-// telegram-plugin/secret-detect/redact.ts
-var REDACTED_MARKER = "[REDACTED]";
-function redact(text) {
-  if (!text || text.length === 0)
-    return text;
-  const urlScrubbed = redactUrls(text);
-  const hits = detectSecrets(urlScrubbed).filter((h) => h.rule_id !== "generic_high_entropy");
-  if (hits.length === 0)
-    return urlScrubbed;
-  const sorted = [...hits].sort((a, b) => b.start - a.start);
-  let out = urlScrubbed;
-  for (const h of sorted) {
-    out = out.slice(0, h.start) + redactedMarker(h.rule_id) + out.slice(h.end);
-  }
-  return out;
-}
-function redactedMarker(ruleId) {
-  const trimmed = ruleId.replace(/^(kv|env)_/, "");
-  if (!trimmed || trimmed === "key_value" || trimmed === "kv_entropy") {
-    return REDACTED_MARKER;
-  }
-  return `[REDACTED:${trimmed}]`;
-}
 // src/issues/store.ts
 var ISSUES_FILE = "issues.jsonl";
 var ISSUES_LOCK = "issues.lock";
@@ -98387,6 +98622,42 @@ function withSynthesizedTools(result) {
     ]
   };
 }
+var READ_ONLY_TOOL_NAMES = new Set([
+  "recall",
+  "reflect",
+  "search",
+  "list_memories",
+  "list_directives",
+  "list_mental_models",
+  "get_mental_model",
+  "get_memory",
+  "get_bank"
+]);
+function redactToolArguments(value) {
+  if (typeof value === "string")
+    return redact(value);
+  if (Array.isArray(value))
+    return value.map(redactToolArguments);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redactToolArguments(v);
+    }
+    return out;
+  }
+  return value;
+}
+function redactToolCallParams(params) {
+  const called = params;
+  if (!called || typeof called !== "object")
+    return params;
+  if (called.arguments === undefined || called.arguments === null)
+    return params;
+  if (typeof called.name === "string" && READ_ONLY_TOOL_NAMES.has(called.name)) {
+    return params;
+  }
+  return { ...called, arguments: redactToolArguments(called.arguments) };
+}
 function buildFallbackToolsList() {
   const tools = Object.entries(FALLBACK_TOOL_TABLE).map(([name, [required, props]]) => ({
     name,
@@ -98713,8 +98984,9 @@ class HindsightShim {
     if (called?.name && SYNTHESIZED_TOOL_NAMES.includes(called.name)) {
       return this.synthesizedCall(called.name, called.arguments);
     }
+    const forwarded = redactToolCallParams(params);
     try {
-      const res = await this.upstream.request("tools/call", params, this.opts.toolsCallTimeoutMs ?? TOOLS_CALL_TIMEOUT_MS);
+      const res = await this.upstream.request("tools/call", forwarded, this.opts.toolsCallTimeoutMs ?? TOOLS_CALL_TIMEOUT_MS);
       this.notifyIfRecovered();
       if (res.error) {
         return {
@@ -104653,7 +104925,7 @@ function probeSpool(agentsDir = resolveAgentsDir2()) {
   }
   return { pending, dead, evicted, drops, agents };
 }
-var CONSOLIDATION_QUEUE_SH = `
+var PSQL_BOOTSTRAP_SH = `
 set -e
 B="$(ls -d /home/hindsight/.pg0/installation/*/bin 2>/dev/null | head -1)"
 PSQL="$(command -v psql 2>/dev/null || echo "\${B:-/nonexistent}/psql")"
@@ -104670,9 +104942,63 @@ d=json.load(open(sys.argv[1]))
 q=lambda k,dflt: shlex.quote(str(d.get(k) or dflt))
 print("U=%s DB=%s P=%s PW=%s"%(q("username","hindsight"),q("database","hindsight"),q("port",5432),q("password","")))' "$D")"
 [ -n "$PW" ] || exit 0
+`;
+var CONSOLIDATION_QUEUE_SH = `${PSQL_BOOTSTRAP_SH}
 PGPASSWORD="$PW" "$PSQL" -U "$U" -h /tmp -p "$P" -d "$DB" -tAc \\
   "SELECT count(*)||'|'||coalesce(max(extract(epoch from (now()-created_at)))::bigint,0) FROM async_operations WHERE status IN ('pending','processing')"
 `;
+var BANK_CONSOLIDATION_SH = `${PSQL_BOOTSTRAP_SH}
+PGPASSWORD="$PW" "$PSQL" -U "$U" -h /tmp -p "$P" -d "$DB" -tAc \\
+  "SELECT 'S|'||a.bank_id||'|'||a.operation_type||'|'||count(*)||'|'||extract(epoch from (now()-max(a.created_at)))::bigint
+     FROM async_operations a
+    WHERE a.status = 'failed'
+      AND a.created_at > coalesce((SELECT max(b.created_at) FROM async_operations b
+                                    WHERE b.bank_id = a.bank_id
+                                      AND b.operation_type = a.operation_type
+                                      AND b.status = 'completed'), '-infinity'::timestamptz)
+    GROUP BY a.bank_id, a.operation_type
+    UNION ALL
+   SELECT 'P|'||m.bank_id||'|'||count(*) FILTER (WHERE m.consolidated_at IS NULL AND m.fact_type IN ('experience','world'))
+     FROM memory_units m
+    GROUP BY m.bank_id"
+`;
+function vectorIndexSh(sampleRows) {
+  const limit = Math.max(1, Math.floor(Number.isFinite(sampleRows) ? sampleRows : 1));
+  return `${PSQL_BOOTSTRAP_SH}
+PGPASSWORD="$PW" PGOPTIONS='-c client_min_messages=notice' \\
+  "$PSQL" -U "$U" -h /tmp -p "$P" -d "$DB" -tAc "
+DO \\$\\$
+DECLARE r record; bad text := ''; n int := 0; probed int := 0;
+BEGIN
+  FOR r IN
+    SELECT c.relname AS idx,
+           i.indrelid::regclass::text AS tbl,
+           coalesce(pg_get_expr(i.indpred, i.indrelid), 'true') AS pred
+      FROM pg_index i
+      JOIN pg_class c ON c.oid = i.indexrelid
+      JOIN pg_am am ON am.oid = c.relam
+     WHERE am.amname = 'hnsw'
+     ORDER BY c.relname
+  LOOP
+    BEGIN
+      EXECUTE format(
+        'SELECT count(nn) FROM (SELECT (SELECT m2.ctid FROM %1\\$s m2 WHERE %2\\$s ORDER BY m2.embedding <=> s.embedding LIMIT 1) AS nn FROM (SELECT embedding FROM %1\\$s s0 WHERE %2\\$s AND embedding IS NOT NULL LIMIT %3\\$s) s) t',
+        r.tbl, r.pred, ${limit});
+      probed := probed + 1;
+    EXCEPTION WHEN others THEN
+      n := n + 1;
+      -- Both delimiters are stripped from the message BEFORE it is appended.
+      -- ';' separates entries and a newline would split the NOTICE line, so an
+      -- SQLERRM containing either would desynchronise the parsed list from n,
+      -- and probeVectorIndexes rejects a mismatched block as unreadable \u2014
+      -- turning a real corruption into a silent no-data.
+      bad := bad || r.idx || '=' || translate(SQLERRM, ';' || chr(10) || chr(13), ',  ') || ';';
+    END;
+  END LOOP;
+  RAISE NOTICE 'VECIDX|%|%|%', probed, n, bad;
+END \\$\\$;" 2>&1
+`;
+}
 function probeConsolidationQueue(container = DEFAULT_CONTAINER, run = defaultRunner4) {
   const r = run("docker", ["exec", container, "sh", "-c", CONSOLIDATION_QUEUE_SH]);
   if (r.status !== 0)
@@ -104686,6 +105012,61 @@ function probeConsolidationQueue(container = DEFAULT_CONTAINER, run = defaultRun
     return null;
   return { pending, oldestAgeS };
 }
+function probeBankConsolidation(container = DEFAULT_CONTAINER, run = defaultRunner4) {
+  const r = run("docker", ["exec", container, "sh", "-c", BANK_CONSOLIDATION_SH]);
+  if (r.status !== 0)
+    return null;
+  const streaks = [];
+  const pending = [];
+  let parsedAny = false;
+  for (const line of r.stdout.split(`
+`)) {
+    const t = line.trim();
+    if (t === "")
+      continue;
+    const f = t.split("|");
+    if (f[0] === "S" && f.length === 5) {
+      const streak = Number(f[3]);
+      const age = Number(f[4]);
+      if (!Number.isFinite(streak) || !Number.isFinite(age) || streak < 0 || age < 0)
+        continue;
+      streaks.push({ bank: f[1], operationType: f[2], streak, newestFailureAgeS: age });
+      parsedAny = true;
+    } else if (f[0] === "P" && f.length === 3) {
+      const n = Number(f[2]);
+      if (!Number.isFinite(n) || n < 0)
+        continue;
+      pending.push({ bank: f[1], pending: n });
+      parsedAny = true;
+    }
+  }
+  if (!parsedAny)
+    return null;
+  return { streaks, pending };
+}
+function probeVectorIndexes(container = DEFAULT_CONTAINER, run = defaultRunner4, sampleRows = VECTOR_INDEX_SAMPLE_ROWS) {
+  const sh = vectorIndexSh(sampleRows);
+  if (!sh.includes("count(nn)"))
+    return null;
+  const r = run("docker", ["exec", container, "sh", "-c", sh]);
+  if (r.status !== 0)
+    return null;
+  const line = r.stdout.split(`
+`).find((l) => l.includes("VECIDX|"));
+  if (line === undefined)
+    return null;
+  const f = line.slice(line.indexOf("VECIDX|")).trim().split("|");
+  if (f.length < 4)
+    return null;
+  const probed = Number(f[1]);
+  const count = Number(f[2]);
+  if (!Number.isFinite(probed) || !Number.isFinite(count) || probed < 0 || count < 0)
+    return null;
+  const corrupt = f.slice(3).join("|").split(";").map((s) => s.trim()).filter((s) => s !== "");
+  if (corrupt.length !== count)
+    return null;
+  return { probed, corrupt };
+}
 async function probeOnce(opts = {}) {
   const now = opts.now ?? Date.now;
   const ts = now();
@@ -104706,6 +105087,8 @@ async function probeOnce(opts = {}) {
     throw new ProbeError(`reading recall logs: ${e.message}`, "spool");
   }
   const consolidation = probeConsolidationQueue(opts.container, opts.run);
+  const banks = probeBankConsolidation(opts.container, opts.run);
+  const vectorIndex = probeVectorIndexes(opts.container, opts.run);
   return {
     sample: {
       ts,
@@ -104721,7 +105104,9 @@ async function probeOnce(opts = {}) {
       startedAt: container.startedAt,
       health: container.health,
       recall,
-      consolidation
+      consolidation,
+      banks,
+      vectorIndex
     },
     spool,
     recall
@@ -105051,6 +105436,136 @@ function evaluateConsolidationQueueAge(ring) {
     measured: { pending: c.pending, oldestAgeS: c.oldestAgeS }
   };
 }
+function evaluateConsolidationFailureStreak(ring) {
+  const signal = "consolidation-failure-streak";
+  if (ring.length === 0)
+    return { signal, state: "no-data", detail: "no samples" };
+  const banks = ring[ring.length - 1].banks ?? null;
+  if (banks === null) {
+    return {
+      signal,
+      state: "no-data",
+      detail: "per-bank consolidation not probed this tick (no psql client, no pg descriptor, " + "or the container is down) \u2014 the `container` signal covers the last of those"
+    };
+  }
+  const live = banks.streaks.filter((s) => s.newestFailureAgeS <= CONSOLIDATION_STREAK_RECENCY_S);
+  let worst = null;
+  for (const s of live)
+    if (worst === null || s.streak > worst.streak)
+      worst = s;
+  if (worst === null || worst.streak < CONSOLIDATION_FAILURE_STREAK_WARN) {
+    const observed = worst?.streak ?? 0;
+    return {
+      signal,
+      state: "ok",
+      detail: `longest live consolidation-failure streak ${observed} across ` + `${banks.streaks.length} bank/op pair(s) \u2014 warn \u2265${CONSOLIDATION_FAILURE_STREAK_WARN}, ` + `page \u2265${CONSOLIDATION_FAILURE_STREAK_PAGE}`,
+      measured: { streak: observed, pairs: banks.streaks.length }
+    };
+  }
+  const { state, severity } = scoreHigherIsWorse(worst.streak, CONSOLIDATION_FAILURE_STREAK_WARN, CONSOLIDATION_FAILURE_STREAK_PAGE);
+  const breaching = live.filter((s) => s.streak >= CONSOLIDATION_FAILURE_STREAK_WARN);
+  const others = breaching.filter((s) => s !== worst).map((s) => `${s.bank}/${s.operationType}\u00d7${s.streak}`);
+  return {
+    signal,
+    state,
+    severity,
+    detail: `bank "${worst.bank}": ${worst.streak} consecutive FAILED ${worst.operationType} ` + `operation(s) with no completion in between, newest ` + `${Math.round(worst.newestFailureAgeS / 60)}m ago \u2014 ` + `warn \u2265${CONSOLIDATION_FAILURE_STREAK_WARN}, page \u2265${CONSOLIDATION_FAILURE_STREAK_PAGE}. ` + "The pending/processing queue reads EMPTY while this holds, so " + "`consolidation-queue-age` cannot see it." + (others.length > 0 ? `
+  also breaching: ${others.join(", ")}` : ""),
+    measured: {
+      streak: worst.streak,
+      bank: worst.bank,
+      operationType: worst.operationType,
+      newestFailureAgeS: worst.newestFailureAgeS,
+      breachingPairs: breaching.length
+    }
+  };
+}
+function evaluatePendingConsolidationDepth(ring) {
+  const signal = "pending-consolidation-depth";
+  const withBanks = ring.filter((s) => (s.banks ?? null) !== null);
+  if (withBanks.length < 2) {
+    return {
+      signal,
+      state: "no-data",
+      detail: `only ${withBanks.length} tick(s) carried a per-bank block \u2014 need two to see a trend`,
+      measured: { samples: withBanks.length }
+    };
+  }
+  const first = new Map(withBanks[0].banks.pending.map((p) => [p.bank, p.pending]));
+  const last = withBanks[withBanks.length - 1].banks.pending;
+  const mins = windowMinutes(withBanks);
+  let worst = null;
+  for (const p of last) {
+    const from = first.get(p.bank);
+    if (from === undefined)
+      continue;
+    const growth = p.pending - from;
+    const need = Math.max(PENDING_CONSOLIDATION_GROWTH_WARN_ABS, Math.ceil(PENDING_CONSOLIDATION_GROWTH_FRACTION * from));
+    if (p.pending < PENDING_CONSOLIDATION_FLOOR || growth < need)
+      continue;
+    if (worst === null || growth > worst.growth) {
+      worst = { bank: p.bank, from, to: p.pending, growth, need };
+    }
+  }
+  if (worst === null) {
+    return {
+      signal,
+      state: "ok",
+      detail: `no bank's unconsolidated depth is both \u2265${PENDING_CONSOLIDATION_FLOOR} and rising ` + `over ${mins}m (${last.length} bank(s))`,
+      measured: { banks: last.length, windowMinutes: mins }
+    };
+  }
+  const { state, severity } = scoreHigherIsWorse(worst.growth, PENDING_CONSOLIDATION_GROWTH_WARN_ABS, PENDING_CONSOLIDATION_GROWTH_PAGE_ABS);
+  const perHour = mins > 0 ? Math.round(worst.growth * 60 / mins) : worst.growth;
+  return {
+    signal,
+    state,
+    severity,
+    detail: `bank "${worst.bank}": unconsolidated memories ${worst.from} \u2192 ${worst.to} ` + `(+${worst.growth}, \u2248${perHour}/h) over ${mins}m \u2014 fires at ` + `\u2265${PENDING_CONSOLIDATION_FLOOR} deep AND +${worst.need} growth, pages at ` + `+${PENDING_CONSOLIDATION_GROWTH_PAGE_ABS}. Rising depth with no failed operations ` + `means consolidation is not being attempted at all.`,
+    measured: {
+      bank: worst.bank,
+      pending: worst.to,
+      growth: worst.growth,
+      growthPerHour: perHour,
+      growthNeeded: worst.need,
+      windowMinutes: mins
+    }
+  };
+}
+function evaluateVectorIndexCorruption(ring) {
+  const signal = "vector-index-corruption";
+  if (ring.length === 0)
+    return { signal, state: "no-data", detail: "no samples" };
+  const v = ring[ring.length - 1].vectorIndex ?? null;
+  if (v === null) {
+    return {
+      signal,
+      state: "no-data",
+      detail: "vector-index canary did not run this tick (no psql client, no pg descriptor, " + "or the container is down) \u2014 the `container` signal covers the last of those"
+    };
+  }
+  if (v.corrupt.length === 0) {
+    return {
+      signal,
+      state: "ok",
+      detail: `${v.probed} HNSW index(es) answered a nearest-neighbour probe cleanly`,
+      measured: { probed: v.probed, corrupt: 0 }
+    };
+  }
+  const shown = v.corrupt.slice(0, 5).join(`
+  `);
+  const more = v.corrupt.length > 5 ? `
+  \u2026and ${v.corrupt.length - 5} more` : "";
+  return {
+    signal,
+    state: "breach",
+    severity: "page",
+    detail: `${v.corrupt.length} of ${v.probed + v.corrupt.length} HNSW index(es) RAISED on a ` + `nearest-neighbour probe \u2014 the index is corrupt, and every consolidation or recall ` + `that touches it fails:
+  ${shown}${more}
+` + `Fix: REINDEX the named index(es). amcheck cannot verify HNSW, so this probe is the ` + `only detector.`,
+    measured: { probed: v.probed, corrupt: v.corrupt.length, first: v.corrupt[0] }
+  };
+}
 function evaluateLlmFallback(ring) {
   const signal = "llm-fallback-ineffective";
   if (ring.length < 2) {
@@ -105099,6 +105614,9 @@ function evaluateAll(ring) {
     evaluateRecallInjectedScore(ring),
     evaluateRecallZeroMemory(ring),
     evaluateConsolidationQueueAge(ring),
+    evaluateConsolidationFailureStreak(ring),
+    evaluatePendingConsolidationDepth(ring),
+    evaluateVectorIndexCorruption(ring),
     evaluateLlmFallback(ring)
   ];
 }
@@ -105107,7 +105625,12 @@ function evaluateAll(ring) {
 init_state2();
 init_thresholds();
 init_types5();
-var EDGE_SIGNALS = new Set(["retain-loss", "container"]);
+var EDGE_SIGNALS = new Set([
+  "retain-loss",
+  "container",
+  "consolidation-failure-streak",
+  "vector-index-corruption"
+]);
 function breachesToFire(signal) {
   return EDGE_SIGNALS.has(signal) ? BREACHES_TO_FIRE_EDGE : BREACHES_TO_FIRE_LEVEL;
 }