switchroom 0.20.9 → 0.20.11

package/dist/cli/self-improve-stop.mjs

@@ -1,7 +1,7 @@
 // src/cli/self-improve-stop.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { createConnection } from "node:net";
-import { join as join2 } from "node:path";
+import { join as join6 } from "node:path";
 import { homedir } from "node:os";
 
 // src/self-improve/config.ts
@@ -16,6 +16,7 @@ function resolveSelfImproveConfig() {
   return {
     repetitionThreshold: Math.max(2, intEnv("SWITCHROOM_SELF_IMPROVE_THRESHOLD", 2)),
     t1MaxChangedLines: intEnv("SWITCHROOM_SELF_IMPROVE_T1_MAX_LINES", 30),
+    t1MaxGrowthBytes: intEnv("SWITCHROOM_SELF_IMPROVE_T1_MAX_GROWTH_BYTES", 4096),
     maxAutoAppliesPerDay: intEnv("SWITCHROOM_SELF_IMPROVE_MAX_AUTO_PER_DAY", 3),
     maxOutstandingPending: intEnv("SWITCHROOM_SELF_IMPROVE_MAX_PENDING", 5)
   };
@@ -206,6 +207,7 @@ function buildReviewPrompt(signals) {
   lines.push(`  2. Classify the change's blast radius. T1 = a small (<= ${cfg.t1MaxChangedLines} ` + "changed lines, single file) reversible edit to a skill you ALREADY " + "own. Anything medium / shared / new-cron / new-skill / cross-agent " + "/ irreversible is T2 or T3.");
   lines.push("  3. For a T1: BEFORE editing, confirm the skill has evals/evals.json " + "and that your edit passes them without regressing baseline (the " + "skill-creator grader + aggregate_benchmark.py). Land the edit via " + "the native skill-write path (Write/Edit) only if the evals pass. " + "If the skill has no evals.json, do NOT auto-apply \u2014 treat it as T2.");
   lines.push("  4. For T2/T3: do NOT apply anything. Record a one-line pending " + "suggestion (the operator actions it later). Never auto-create a " + "cron or a new skill, never edit a shared/other-agent skill.");
+  lines.push("  5. If this was an operator CORRECTION tied to a skill you own, turn " + "it into a regression test: run `switchroom self-improve add-eval-case " + "--skill <slug> --chat <operator chat id> " + '--prompt "<the correction framed as a test prompt>"`. The `--chat` ' + "flag is REQUIRED \u2014 pass the real operator chat id from this session's " + "context (the chat the correction arrived in), NOT the review turn's " + "own placeholder chat id, or the command is rejected. This proposes " + "the case as a one-tap card; the operator's tap runs a deterministic " + "applier that writes it (PII/secret-scanned). Do NOT Write or Edit " + "evals/evals.json yourself \u2014 a direct write is blocked, bypasses the " + "scan, and skips the operator's approval.");
   lines.push("");
   lines.push(`Rate limits in effect: <= ${cfg.maxAutoAppliesPerDay} auto-applies/day, ` + `<= ${cfg.maxOutstandingPending} outstanding pending suggestions. If a ` + "limit is reached, stop and leave a note rather than forcing the change.");
   return lines.join(`
@@ -237,11 +239,878 @@ function clearReviewContext(stateDir) {
   } catch {}
 }
 
+// src/self-improve/eval-cases.ts
+import {
+  closeSync as closeSync2,
+  copyFileSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
+  readdirSync,
+  renameSync,
+  writeFileSync as writeFileSync2,
+  writeSync as writeSync2
+} from "node:fs";
+import { dirname, join as join4 } from "node:path";
+import { createHash } from "node:crypto";
+
+// src/self-improve/eval-gate.ts
+import { join as join2 } from "node:path";
+function evalsJsonPath(skillDir) {
+  return join2(skillDir, "evals", "evals.json");
+}
+
+// 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"
+]);
+
+// 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;
+}
+
+// src/self-improve/pii-scan.ts
+function maskEmail(s) {
+  const at = s.indexOf("@");
+  if (at <= 0)
+    return "[email]";
+  const local = s.slice(0, at);
+  const domain = s.slice(at + 1);
+  const head = local.slice(0, 1);
+  const dot = domain.lastIndexOf(".");
+  const tld = dot >= 0 ? domain.slice(dot) : "";
+  return `${head}***@***${tld}`;
+}
+function maskDigits(s) {
+  const digits = s.replace(/\D/g, "");
+  if (digits.length <= 4)
+    return "***";
+  return `***${digits.slice(-4)}`;
+}
+var EMAIL_RE = /[A-Za-z0-9._%+-]+@[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)*\.[A-Za-z]{2,}/g;
+var PHONE_E164_RE = /\+[1-9]\d{9,14}(?!\d)/g;
+var PHONE_SEP_RE = /(?<!\d)(?:\(\d{3}\)[\s.-]?|\d{3}[\s.-])\d{3}[\s.-]\d{4}(?!\d)/g;
+var SSN_RE = /(?<!\d)\d{3}-\d{2}-\d{4}(?!\d)/g;
+var CARD_CANDIDATE_RE = /(?<![\d-])(?:\d[ -]?){13,19}(?![\d-])/g;
+function luhnValid(digits) {
+  if (digits.length < 13 || digits.length > 19)
+    return false;
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1;i >= 0; i--) {
+    let d = digits.charCodeAt(i) - 48;
+    if (d < 0 || d > 9)
+      return false;
+    if (alt) {
+      d *= 2;
+      if (d > 9)
+        d -= 9;
+    }
+    sum += d;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+function scanForPII(text) {
+  const findings = [];
+  if (typeof text !== "string" || text.length === 0) {
+    return { ok: true, findings };
+  }
+  try {
+    for (const d of detectSecrets(text)) {
+      findings.push({
+        kind: "secret",
+        rule: d.rule_id,
+        excerpt: `[secret:${d.rule_id}]`
+      });
+    }
+  } catch (err) {
+    findings.push({
+      kind: "scan-error",
+      excerpt: `secret scan failed: ${err.message}`.slice(0, 120)
+    });
+  }
+  try {
+    for (const m of text.matchAll(EMAIL_RE)) {
+      findings.push({ kind: "email", excerpt: maskEmail(m[0]) });
+    }
+    for (const m of text.matchAll(PHONE_E164_RE)) {
+      findings.push({ kind: "phone", excerpt: maskDigits(m[0]) });
+    }
+    for (const m of text.matchAll(PHONE_SEP_RE)) {
+      findings.push({ kind: "phone", excerpt: maskDigits(m[0]) });
+    }
+    for (const m of text.matchAll(SSN_RE)) {
+      findings.push({ kind: "ssn", excerpt: maskDigits(m[0]) });
+    }
+    for (const m of text.matchAll(CARD_CANDIDATE_RE)) {
+      const digits = m[0].replace(/\D/g, "");
+      if (luhnValid(digits)) {
+        findings.push({ kind: "card", excerpt: maskDigits(m[0]) });
+      }
+    }
+  } catch (err) {
+    findings.push({
+      kind: "scan-error",
+      excerpt: `pii scan failed: ${err.message}`.slice(0, 120)
+    });
+  }
+  return { ok: findings.length === 0, findings };
+}
+
+// src/self-improve/pending-queue.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  writeSync
+} from "node:fs";
+import { join as join3 } from "node:path";
+import { randomUUID } from "node:crypto";
+var PENDING_FILE = "self-improve-pending.jsonl";
+function pendingPath(stateDir) {
+  return join3(stateDir, PENDING_FILE);
+}
+function readPending(stateDir) {
+  const p = pendingPath(stateDir);
+  if (!existsSync2(p))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync2(p, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed.id === "string" && parsed.tier) {
+        out.push(parsed);
+      }
+    } catch {}
+  }
+  return out;
+}
+function outstandingCount(stateDir) {
+  return readPending(stateDir).filter((s) => s.actioned !== true).length;
+}
+function enqueuePending(stateDir, input, opts = {}) {
+  const cfg = resolveSelfImproveConfig();
+  const cap = opts.cap ?? cfg.maxOutstandingPending;
+  const now = opts.now ?? Date.now;
+  ensureDir(stateDir);
+  const outstanding = outstandingCount(stateDir);
+  if (outstanding >= cap) {
+    return { ok: false, reason: "cap-reached", outstanding, cap };
+  }
+  const suggestion = {
+    id: randomUUID(),
+    created_at: new Date(now()).toISOString(),
+    ...input
+  };
+  const fd = openSync(pendingPath(stateDir), "a");
+  try {
+    writeSync(fd, JSON.stringify(suggestion) + `
+`);
+  } finally {
+    closeSync(fd);
+  }
+  return { ok: true, suggestion };
+}
+function ensureDir(stateDir) {
+  if (!existsSync2(stateDir)) {
+    mkdirSync2(stateDir, { recursive: true, mode: 493 });
+  }
+}
+
+// src/self-improve/eval-cases.ts
+function writeAtomic(path, content) {
+  mkdirSync3(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync2(tmp, content, { encoding: "utf-8", mode: 420 });
+  renameSync(tmp, path);
+}
+var EVAL_MANIFEST_FILE = "self-improve-eval-manifest.json";
+var EVAL_BASELINE_SUBDIR = "self-improve-eval-baselines";
+function manifestPath(stateDir) {
+  return join4(stateDir, EVAL_MANIFEST_FILE);
+}
+function baselineEvalsPath(stateDir, slug) {
+  return join4(stateDir, EVAL_BASELINE_SUBDIR, slug, "evals.json");
+}
+function evalsSha256(skillDir) {
+  const p = evalsJsonPath(skillDir);
+  if (!existsSync3(p))
+    return null;
+  try {
+    return createHash("sha256").update(readFileSync3(p)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function readManifest(stateDir) {
+  const p = manifestPath(stateDir);
+  if (!existsSync3(p))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync3(p, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeManifest(stateDir, m) {
+  writeAtomic(manifestPath(stateDir), JSON.stringify(m, null, 2) + `
+`);
+}
+function recordEvalBaseline(stateDir, slug, skillDir, opts = {}) {
+  const sha = evalsSha256(skillDir);
+  if (sha === null)
+    return;
+  const now = opts.now ?? Date.now;
+  const m = readManifest(stateDir);
+  m[slug] = { sha256: sha, updated_at: new Date(now()).toISOString(), skill_dir: skillDir };
+  writeManifest(stateDir, m);
+  const snap = baselineEvalsPath(stateDir, slug);
+  mkdirSync3(dirname(snap), { recursive: true });
+  copyFileSync(evalsJsonPath(skillDir), snap);
+}
+function evalsBaselineTrusted(skillDir) {
+  const p = evalsJsonPath(skillDir);
+  let text;
+  try {
+    text = readFileSync3(p, "utf-8");
+  } catch {
+    return false;
+  }
+  return scanForPII(text).ok;
+}
+function verifyEvalIntegrity(stateDir, slug, skillDir) {
+  const sha = evalsSha256(skillDir);
+  if (sha === null)
+    return "no-evals";
+  const m = readManifest(stateDir);
+  const entry = m[slug];
+  if (!entry)
+    return "missing";
+  return sha === entry.sha256 ? "ok" : "drift";
+}
+function listSkillsWithEvals(skillsRoot) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync(skillsRoot);
+  } catch {
+    return out;
+  }
+  for (const slug of entries) {
+    const skillDir = join4(skillsRoot, slug);
+    if (existsSync3(evalsJsonPath(skillDir)))
+      out.push({ slug, skillDir });
+  }
+  return out;
+}
+function sweepEvalIntegrity(skillsRoot, stateDir, opts = {}) {
+  const report = {
+    recorded: [],
+    healed: [],
+    ok: [],
+    quarantined: []
+  };
+  const adoptIfTrusted = (slug, skillDir) => {
+    if (evalsBaselineTrusted(skillDir)) {
+      recordEvalBaseline(stateDir, slug, skillDir, opts);
+      report.recorded.push(slug);
+    } else {
+      report.quarantined.push(slug);
+    }
+  };
+  for (const { slug, skillDir } of listSkillsWithEvals(skillsRoot)) {
+    try {
+      const status = verifyEvalIntegrity(stateDir, slug, skillDir);
+      if (status === "missing") {
+        adoptIfTrusted(slug, skillDir);
+      } else if (status === "drift") {
+        const snap = baselineEvalsPath(stateDir, slug);
+        if (existsSync3(snap)) {
+          copyFileSync(snap, evalsJsonPath(skillDir));
+          recordEvalBaseline(stateDir, slug, skillDir, opts);
+          report.healed.push(slug);
+        } else {
+          adoptIfTrusted(slug, skillDir);
+        }
+      } else {
+        report.ok.push(slug);
+      }
+    } catch {}
+  }
+  return report;
+}
+var SWEEP_TAMPER_SIGNAL = "eval-integrity-sweep";
+var SWEEP_HEALED_SIGNAL = "drift-reverted";
+var SWEEP_QUARANTINED_SIGNAL = "quarantined";
+function hasOutstandingSweepNote(pending, slug, kindSignal) {
+  return pending.some((p) => p.actioned !== true && p.skill_slug === slug && Array.isArray(p.triggered_by) && p.triggered_by.includes(SWEEP_TAMPER_SIGNAL) && p.triggered_by.includes(kindSignal));
+}
+function surfaceSweepTamper(stateDir, report, opts = {}) {
+  const enqueued = { healed: [], quarantined: [] };
+  if (report.healed.length === 0 && report.quarantined.length === 0) {
+    return enqueued;
+  }
+  let pending;
+  try {
+    pending = readPending(stateDir);
+  } catch {
+    pending = [];
+  }
+  const tryEnqueue = (slug, kindSignal, lesson, proposed_change, tier_reason, bucket) => {
+    if (hasOutstandingSweepNote(pending, slug, kindSignal))
+      return;
+    try {
+      const q = enqueuePending(stateDir, {
+        tier: "T2",
+        lesson,
+        proposed_change,
+        tier_reason,
+        skill_slug: slug,
+        triggered_by: [SWEEP_TAMPER_SIGNAL, kindSignal]
+      }, { now: opts.now });
+      if (q.ok) {
+        pending.push(q.suggestion);
+        bucket.push(slug);
+      }
+    } catch {}
+  };
+  for (const slug of report.healed) {
+    tryEnqueue(slug, SWEEP_HEALED_SIGNAL, `Eval-integrity sweep reverted out-of-band drift in skill "${slug}" (evals/evals.json) to the sanctioned baseline.`, `Confirm the change to ${slug}/evals/evals.json was intended. A Bash/Write edit that bypasses the applier is auto-reverted every turn; re-add the case via \`switchroom self-improve add-eval-case\` so it becomes a sanctioned baseline.`, `eval-integrity sweep detected + healed out-of-band tamper (RFC invariant 3(b))`, enqueued.healed);
+  }
+  for (const slug of report.quarantined) {
+    tryEnqueue(slug, SWEEP_QUARANTINED_SIGNAL, `Eval-integrity sweep QUARANTINED skill "${slug}": an un-sanctioned evals.json failed the PII/secret scan and was NOT adopted as a baseline.`, `Review ${slug}/evals/evals.json for PII/secrets or corruption \u2014 the sweep refuses to trust it. Re-add clean cases via \`switchroom self-improve add-eval-case\`.`, `eval-integrity sweep quarantined un-sanctioned evals.json (RFC invariant 3(b), MAJOR 2)`, enqueued.quarantined);
+  }
+  return enqueued;
+}
+
+// src/memory/hindsight-retain-provenance.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+var RETAIN_PROVENANCE_TAG = "source:transcript";
+var RETAIN_TAGS_DEFAULT = Object.freeze([
+  "{session_id}",
+  RETAIN_PROVENANCE_TAG
+]);
+var SELF_IMPROVE_CORRECTION_PENDING_FILE = "self-improve-correction-pending";
+function correctionPendingPath(stateDir) {
+  return join5(stateDir, SELF_IMPROVE_CORRECTION_PENDING_FILE);
+}
+function writeCorrectionPending(stateDir) {
+  if (!existsSync4(stateDir)) {
+    mkdirSync4(stateDir, { recursive: true, mode: 493 });
+  }
+  writeFileSync3(correctionPendingPath(stateDir), new Date().toISOString(), "utf-8");
+}
+
 // src/cli/self-improve-stop.ts
 var SCAN_WINDOW = 40;
 function readStdin() {
   try {
-    return readFileSync2(0, "utf8");
+    return readFileSync4(0, "utf8");
   } catch {
     return "";
   }
@@ -309,7 +1178,7 @@ function readTranscript(path) {
     return [];
   let raw;
   try {
-    raw = readFileSync2(path, "utf8");
+    raw = readFileSync4(path, "utf8");
   } catch {
     return [];
   }
@@ -328,14 +1197,14 @@ function readTranscript(path) {
   return out.length > SCAN_WINDOW ? out.slice(-SCAN_WINDOW) : out;
 }
 function resolveStateDir() {
-  return process.env.TELEGRAM_STATE_DIR ?? join2(homedir(), ".claude", "channels", "telegram");
+  return process.env.TELEGRAM_STATE_DIR ?? join6(homedir(), ".claude", "channels", "telegram");
 }
 function resolveSocketPath() {
   if (process.env.SWITCHROOM_GATEWAY_SOCKET) {
     return process.env.SWITCHROOM_GATEWAY_SOCKET;
   }
-  const stateDir = process.env.TELEGRAM_STATE_DIR ?? join2(homedir(), ".claude", "channels", "telegram");
-  return join2(stateDir, "gateway.sock");
+  const stateDir = process.env.TELEGRAM_STATE_DIR ?? join6(homedir(), ".claude", "channels", "telegram");
+  return join6(stateDir, "gateway.sock");
 }
 function resolveChatId() {
   return process.env.SWITCHROOM_SELF_IMPROVE_CHAT_ID ?? process.env.SWITCHROOM_DEFAULT_CHAT_ID ?? "self-improve";
@@ -387,9 +1256,17 @@ function injectReview(agentName, text, sessionId) {
   });
   sock.on("error", () => done());
 }
+function resolveSkillsRoot() {
+  return join6(homedir(), ".claude", "skills");
+}
 function main() {
   if (!selfImproveEnabled())
     process.exit(0);
+  try {
+    const stateDir = resolveStateDir();
+    const report = sweepEvalIntegrity(resolveSkillsRoot(), stateDir);
+    surfaceSweepTamper(stateDir, report);
+  } catch {}
   const raw = readStdin().trim();
   if (!raw)
     process.exit(0);
@@ -411,6 +1288,11 @@ function main() {
   const gate = runGate(scanMessages);
   if (!gate.tripped)
     process.exit(0);
+  if (gate.signals.some((s) => s.kind === "operator-correction")) {
+    try {
+      writeCorrectionPending(resolveStateDir());
+    } catch {}
+  }
   const agentName = process.env.SWITCHROOM_AGENT_NAME ?? "";
   if (!agentName)
     process.exit(0);