switchroom 0.15.44 → 0.16.4

package/dist/cli/self-improve-apply-guard-pretool.mjs

@@ -0,0 +1,626 @@
+// src/cli/self-improve-apply-guard-pretool.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { join as join6 } from "node:path";
+import { homedir } from "node:os";
+
+// src/self-improve/config.ts
+function intEnv(name, def) {
+  const raw = process.env[name];
+  if (raw === undefined)
+    return def;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : def;
+}
+function resolveSelfImproveConfig() {
+  return {
+    repetitionThreshold: Math.max(2, intEnv("SWITCHROOM_SELF_IMPROVE_THRESHOLD", 2)),
+    t1MaxChangedLines: intEnv("SWITCHROOM_SELF_IMPROVE_T1_MAX_LINES", 30),
+    maxAutoAppliesPerDay: intEnv("SWITCHROOM_SELF_IMPROVE_MAX_AUTO_PER_DAY", 3),
+    maxOutstandingPending: intEnv("SWITCHROOM_SELF_IMPROVE_MAX_PENDING", 5)
+  };
+}
+function selfImproveEnabled() {
+  return process.env.SWITCHROOM_SELF_IMPROVE !== "0";
+}
+
+// src/self-improve/review-context.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { join } from "node:path";
+var REVIEW_CONTEXT_FILE = "self-improve-review-context.json";
+function contextPath(stateDir) {
+  return join(stateDir, REVIEW_CONTEXT_FILE);
+}
+function readReviewContext(stateDir) {
+  const p = contextPath(stateDir);
+  if (!existsSync(p))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(p, "utf-8"));
+    if (parsed && typeof parsed.created_at === "string") {
+      if (!Array.isArray(parsed.signals))
+        parsed.signals = [];
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+
+// src/self-improve/apply-guard.ts
+import { existsSync as existsSync4, lstatSync, readFileSync as readFileSync4, statSync } from "node:fs";
+import { join as join4, resolve, sep } from "node:path";
+
+// src/self-improve/tier-router.ts
+function classifyTier(candidate, cfg = resolveSelfImproveConfig()) {
+  if (!candidate.proposedChange || candidate.proposedChange.trim() === "") {
+    return { tier: "T0", reason: "no actionable change proposed" };
+  }
+  if (candidate.irreversible) {
+    return { tier: "T3", reason: "irreversible change \u2014 operator must decide" };
+  }
+  if (candidate.crossAgent) {
+    return {
+      tier: "T3",
+      reason: "cross-agent change \u2014 operator must decide (no self-escalation)"
+    };
+  }
+  if (candidate.touchesCron) {
+    return {
+      tier: "T3",
+      reason: "creates/edits a cron \u2014 never self-served (on-leash)"
+    };
+  }
+  if (candidate.createsNewSkill) {
+    return {
+      tier: "T3",
+      reason: "creates a new skill \u2014 proposed, never auto-created"
+    };
+  }
+  if (!candidate.skillSlug || candidate.ownsSkill !== true) {
+    return {
+      tier: "T2",
+      reason: candidate.skillSlug ? `targets skill "${candidate.skillSlug}" the agent does not own \u2014 propose, don't auto-apply` : "no own-skill target \u2014 surface as a one-tap suggestion"
+    };
+  }
+  if (candidate.multiFile === true) {
+    return {
+      tier: "T2",
+      reason: "touches more than one skill file \u2014 over the T1 single-file bound"
+    };
+  }
+  const lines = candidate.changedLines ?? 0;
+  if (lines > cfg.t1MaxChangedLines) {
+    return {
+      tier: "T2",
+      reason: `${lines} changed lines exceeds the T1 cap of ${cfg.t1MaxChangedLines}`
+    };
+  }
+  return {
+    tier: "T1",
+    reason: `small (${lines} line${lines === 1 ? "" : "s"}) reversible edit to owned skill "${candidate.skillSlug}"`
+  };
+}
+
+// src/self-improve/eval-gate.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+function evalsJsonPath(skillDir) {
+  return join2(skillDir, "evals", "evals.json");
+}
+function skillHasEvals(skillDir) {
+  const p = evalsJsonPath(skillDir);
+  if (!existsSync2(p))
+    return false;
+  try {
+    const parsed = JSON.parse(readFileSync2(p, "utf-8"));
+    return Array.isArray(parsed.evals) && parsed.evals.length > 0;
+  } catch {
+    return false;
+  }
+}
+var CANDIDATE_CONFIGS = ["with_skill", "candidate", "new_skill", "after"];
+var BASELINE_CONFIGS = ["without_skill", "baseline", "old_skill", "before"];
+function pickPassRate(summary, names) {
+  for (const n of names) {
+    const c = summary[n];
+    if (c && c.pass_rate && typeof c.pass_rate.mean === "number") {
+      return c.pass_rate.mean;
+    }
+  }
+  return;
+}
+function evalVerdict(benchmarkJson, _cfg = resolveSelfImproveConfig()) {
+  let bench;
+  try {
+    bench = JSON.parse(readFileSync2(benchmarkJson, "utf-8"));
+  } catch (err) {
+    return { pass: false, reason: `unreadable benchmark.json: ${err.message}` };
+  }
+  const summary = bench.run_summary ?? {};
+  const candidate = pickPassRate(summary, CANDIDATE_CONFIGS);
+  if (candidate === undefined) {
+    return { pass: false, reason: "no candidate pass-rate in benchmark.json" };
+  }
+  const baseline = pickPassRate(summary, BASELINE_CONFIGS);
+  const floor = floatEnv("SWITCHROOM_SELF_IMPROVE_EVAL_FLOOR", 1);
+  const regressBand = floatEnv("SWITCHROOM_SELF_IMPROVE_EVAL_REGRESS_BAND", 0);
+  if (candidate < floor) {
+    return {
+      pass: false,
+      reason: `candidate pass-rate ${candidate.toFixed(2)} below floor ${floor.toFixed(2)}`,
+      candidatePassRate: candidate,
+      baselinePassRate: baseline
+    };
+  }
+  if (baseline !== undefined && candidate < baseline - regressBand) {
+    return {
+      pass: false,
+      reason: `regression: candidate ${candidate.toFixed(2)} < baseline ${baseline.toFixed(2)} (band ${regressBand.toFixed(2)})`,
+      candidatePassRate: candidate,
+      baselinePassRate: baseline
+    };
+  }
+  return {
+    pass: true,
+    candidatePassRate: candidate,
+    baselinePassRate: baseline ?? candidate
+  };
+}
+function floatEnv(name, def) {
+  const raw = process.env[name];
+  if (raw === undefined)
+    return def;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : def;
+}
+
+// src/self-improve/rate-limit.ts
+import {
+  closeSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync3,
+  writeSync
+} from "node:fs";
+import { join as join3 } from "node:path";
+var APPLIES_FILE = "self-improve-applies.jsonl";
+function appliesPath(stateDir) {
+  return join3(stateDir, APPLIES_FILE);
+}
+function utcDay(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+function appliesToday(stateDir, now = Date.now) {
+  const p = appliesPath(stateDir);
+  if (!existsSync3(p))
+    return 0;
+  let raw;
+  try {
+    raw = readFileSync3(p, "utf-8");
+  } catch {
+    return 0;
+  }
+  const today = utcDay(now());
+  let count = 0;
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const rec = JSON.parse(line);
+      if (rec.day === today)
+        count += 1;
+    } catch {}
+  }
+  return count;
+}
+function recordAutoApply(stateDir, now = Date.now) {
+  if (!existsSync3(stateDir)) {
+    mkdirSync2(stateDir, { recursive: true, mode: 493 });
+  }
+  const ms = now();
+  const fd = openSync(appliesPath(stateDir), "a");
+  try {
+    writeSync(fd, JSON.stringify({ ts: ms, day: utcDay(ms) }) + `
+`);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// src/self-improve/apply-guard.ts
+var SKILLS_SEGMENT = "/.claude/skills/";
+var BENCHMARK_SUBDIR = "self-improve-benchmarks";
+function benchmarkJsonForSkill(stateDir, slug) {
+  return join4(stateDir, BENCHMARK_SUBDIR, slug, "benchmark.json");
+}
+function parseSkillTarget(filePath) {
+  if (typeof filePath !== "string" || filePath.length === 0)
+    return null;
+  const segIdx = filePath.indexOf(SKILLS_SEGMENT);
+  if (segIdx < 0)
+    return null;
+  const after = filePath.slice(segIdx + SKILLS_SEGMENT.length);
+  const segs = after.split("/").filter((s) => s.length > 0);
+  if (segs.length < 2)
+    return null;
+  const slug = segs[0];
+  const relPath = segs.slice(1).join("/");
+  const skillDir = filePath.slice(0, segIdx + SKILLS_SEGMENT.length) + slug;
+  return { skillDir, slug, relPath };
+}
+var SAFE_SLUG = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+function skillTargetEscapes(target) {
+  if (!SAFE_SLUG.test(target.slug))
+    return true;
+  for (const s of target.relPath.split("/")) {
+    if (s === "" || s === "." || s === ".." || s.includes("\x00"))
+      return true;
+  }
+  const base = resolve(target.skillDir);
+  const resolved = resolve(target.skillDir, target.relPath);
+  return resolved !== base && !resolved.startsWith(base + sep);
+}
+function ownsSkill(skillDir) {
+  try {
+    const st = lstatSync(skillDir);
+    if (st.isSymbolicLink())
+      return false;
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function estimateChangedLines(toolName, input, filePath) {
+  const splitLines = (s) => s.length === 0 ? [] : s.replace(/\r\n/g, `
+`).split(`
+`);
+  const multisetDiff = (before, after) => {
+    const counts = new Map;
+    for (const l of before)
+      counts.set(l, (counts.get(l) ?? 0) + 1);
+    let added = 0;
+    for (const l of after) {
+      const c = counts.get(l) ?? 0;
+      if (c > 0)
+        counts.set(l, c - 1);
+      else
+        added += 1;
+    }
+    let removed = 0;
+    for (const c of counts.values())
+      removed += c;
+    return added + removed;
+  };
+  const readCurrent = () => {
+    try {
+      return readFileSync4(filePath, "utf-8");
+    } catch {
+      return "";
+    }
+  };
+  if (toolName === "Write") {
+    const content = typeof input.content === "string" ? input.content : "";
+    return multisetDiff(splitLines(readCurrent()), splitLines(content));
+  }
+  if (toolName === "Edit") {
+    const oldS = typeof input.old_string === "string" ? input.old_string : "";
+    const newS = typeof input.new_string === "string" ? input.new_string : "";
+    return multisetDiff(splitLines(oldS), splitLines(newS));
+  }
+  if (toolName === "MultiEdit") {
+    const edits = Array.isArray(input.edits) ? input.edits : [];
+    let total = 0;
+    for (const e of edits) {
+      if (!e || typeof e !== "object")
+        continue;
+      const ed = e;
+      const oldS = typeof ed.old_string === "string" ? ed.old_string : "";
+      const newS = typeof ed.new_string === "string" ? ed.new_string : "";
+      total += multisetDiff(splitLines(oldS), splitLines(newS));
+    }
+    return total;
+  }
+  return 0;
+}
+function downgradeCandidate(target, owns, changedLines, lesson) {
+  return {
+    lesson,
+    proposedChange: `Edit ${target.relPath} in skill "${target.slug}" (auto-apply refused \u2014 see reason)`,
+    skillSlug: target.slug,
+    ownsSkill: owns,
+    changedLines,
+    multiFile: false
+  };
+}
+function decideApply(p) {
+  const cfg = p.cfg ?? resolveSelfImproveConfig();
+  const now = p.now ?? Date.now;
+  const target = parseSkillTarget(p.filePath);
+  if (!target) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: "write target is not an own-skill bundle file",
+      candidate: {
+        lesson: "self-improve review attempted a non-skill write",
+        proposedChange: p.filePath,
+        multiFile: false
+      }
+    };
+  }
+  if (skillTargetEscapes(target)) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: `skill write path escapes the bundle (slug="${target.slug}", rel="${target.relPath}") \u2014 refused`,
+      candidate: {
+        lesson: `Bind the recurring lesson into skill "${target.slug}"`,
+        proposedChange: `Edit ${target.relPath} in skill "${target.slug}" (path escapes bundle \u2014 refused)`,
+        skillSlug: target.slug,
+        ownsSkill: false,
+        changedLines: 0,
+        multiFile: false
+      }
+    };
+  }
+  const owns = (p.ownsSkillFn ?? ownsSkill)(target.skillDir);
+  const changedLines = estimateChangedLines(p.toolName, p.input, p.filePath);
+  const lesson = `Bind the recurring lesson into skill "${target.slug}"`;
+  const routed = classifyTier({
+    lesson,
+    proposedChange: "skill edit",
+    skillSlug: target.slug,
+    ownsSkill: owns,
+    changedLines,
+    multiFile: false
+  }, cfg);
+  if (routed.tier !== "T1") {
+    return {
+      action: "block",
+      downgradeTier: routed.tier === "T3" ? "T3" : "T2",
+      reason: `not a T1 auto-apply: ${routed.reason}`,
+      candidate: downgradeCandidate(target, owns, changedLines, lesson)
+    };
+  }
+  if (!skillHasEvals(target.skillDir)) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: `skill "${target.slug}" has no evals/evals.json \u2014 can't measure the edit; downgraded to a proposal`,
+      candidate: downgradeCandidate(target, owns, changedLines, lesson)
+    };
+  }
+  const benchPath = benchmarkJsonForSkill(p.stateDir, target.slug);
+  if (!existsSync4(benchPath)) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: `no eval result for skill "${target.slug}" \u2014 the per-skill eval did not run/pass; downgraded to a proposal`,
+      candidate: downgradeCandidate(target, owns, changedLines, lesson)
+    };
+  }
+  if (typeof p.freshAfterMs === "number") {
+    let mtime = 0;
+    try {
+      mtime = statSync(benchPath).mtimeMs;
+    } catch {
+      mtime = 0;
+    }
+    if (mtime < p.freshAfterMs) {
+      return {
+        action: "block",
+        downgradeTier: "T2",
+        reason: `eval result for "${target.slug}" is stale (predates this review) \u2014 re-run evals; downgraded to a proposal`,
+        candidate: downgradeCandidate(target, owns, changedLines, lesson)
+      };
+    }
+  }
+  const verdict = evalVerdict(benchPath, cfg);
+  if (!verdict.pass) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: `eval gate blocked the edit to "${target.slug}": ${verdict.reason}`,
+      candidate: downgradeCandidate(target, owns, changedLines, lesson)
+    };
+  }
+  const used = appliesToday(p.stateDir, now);
+  if (used >= cfg.maxAutoAppliesPerDay) {
+    return {
+      action: "block",
+      downgradeTier: "T2",
+      reason: `daily auto-apply cap reached (${used}/${cfg.maxAutoAppliesPerDay}) \u2014 downgraded to a proposal`,
+      candidate: downgradeCandidate(target, owns, changedLines, lesson)
+    };
+  }
+  return {
+    action: "allow",
+    tier: "T1",
+    changedLines,
+    candidatePassRate: verdict.candidatePassRate,
+    baselinePassRate: verdict.baselinePassRate,
+    reason: `verified T1: ${changedLines} changed line${changedLines === 1 ? "" : "s"} to owned skill "${target.slug}", evals ${verdict.candidatePassRate.toFixed(2)} \u2265 baseline ${verdict.baselinePassRate.toFixed(2)}, ${used + 1}/${cfg.maxAutoAppliesPerDay} today`
+  };
+}
+
+// src/self-improve/pending-queue.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  readFileSync as readFileSync5,
+  writeSync as writeSync2
+} from "node:fs";
+import { join as join5 } from "node:path";
+import { randomUUID } from "node:crypto";
+var PENDING_FILE = "self-improve-pending.jsonl";
+function pendingPath(stateDir) {
+  return join5(stateDir, PENDING_FILE);
+}
+function readPending(stateDir) {
+  const p = pendingPath(stateDir);
+  if (!existsSync5(p))
+    return [];
+  let raw;
+  try {
+    raw = readFileSync5(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 = openSync2(pendingPath(stateDir), "a");
+  try {
+    writeSync2(fd, JSON.stringify(suggestion) + `
+`);
+  } finally {
+    closeSync2(fd);
+  }
+  return { ok: true, suggestion };
+}
+function ensureDir(stateDir) {
+  if (!existsSync5(stateDir)) {
+    mkdirSync3(stateDir, { recursive: true, mode: 493 });
+  }
+}
+
+// src/cli/self-improve-apply-guard-pretool.ts
+var EDIT_TOOLS = new Set(["Write", "Edit", "MultiEdit"]);
+function readStdin() {
+  try {
+    return readFileSync6(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function allow() {
+  process.exit(0);
+}
+function block(reason) {
+  const safe = String(reason).replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 300);
+  process.stdout.write(JSON.stringify({ decision: "block", reason: safe }));
+  process.exit(0);
+}
+function resolveStateDir() {
+  return process.env.TELEGRAM_STATE_DIR ?? join6(homedir(), ".claude", "channels", "telegram");
+}
+function main() {
+  if (!selfImproveEnabled())
+    allow();
+  const raw = readStdin().trim();
+  if (!raw)
+    allow();
+  let event;
+  try {
+    event = JSON.parse(raw);
+  } catch {
+    allow();
+  }
+  const toolName = typeof event.tool_name === "string" ? event.tool_name : "";
+  if (!EDIT_TOOLS.has(toolName))
+    allow();
+  const input = event.tool_input && typeof event.tool_input === "object" ? event.tool_input : {};
+  const filePath = typeof input.file_path === "string" ? input.file_path : "";
+  if (!filePath)
+    allow();
+  if (!parseSkillTarget(filePath))
+    allow();
+  const stateDir = resolveStateDir();
+  let ctx = null;
+  try {
+    ctx = readReviewContext(stateDir);
+  } catch {
+    ctx = null;
+  }
+  if (!ctx)
+    allow();
+  let freshAfterMs;
+  const t = Date.parse(ctx.created_at);
+  if (Number.isFinite(t))
+    freshAfterMs = t;
+  let decision;
+  try {
+    decision = decideApply({
+      toolName,
+      input,
+      filePath,
+      stateDir,
+      freshAfterMs
+    });
+  } catch {
+    safeDowngrade(stateDir, ctx, filePath, "apply-guard internal error");
+    block("self-improve apply-guard: internal error evaluating the edit \u2014 " + "downgraded to a pending proposal, write blocked (fail-closed).");
+  }
+  if (decision.action === "allow") {
+    try {
+      recordAutoApply(stateDir);
+    } catch {}
+    allow();
+  }
+  let capNote = "";
+  try {
+    const q = enqueuePending(stateDir, {
+      tier: decision.downgradeTier,
+      lesson: decision.candidate.lesson,
+      proposed_change: decision.candidate.proposedChange,
+      tier_reason: decision.reason,
+      skill_slug: decision.candidate.skillSlug,
+      triggered_by: (ctx.signals ?? []).map((s) => s.kind)
+    });
+    if (!q.ok) {
+      capNote = ` (pending queue full ${q.outstanding}/${q.cap} \u2014 proposal not recorded)`;
+    }
+  } catch {}
+  block(`self-improve apply-guard: ${decision.reason}${capNote}`);
+}
+function safeDowngrade(stateDir, ctx, filePath, reason) {
+  try {
+    const target = parseSkillTarget(filePath);
+    enqueuePending(stateDir, {
+      tier: "T2",
+      lesson: target ? `Bind the recurring lesson into skill "${target.slug}"` : "self-improve review edit (guard error)",
+      proposed_change: filePath,
+      tier_reason: reason,
+      skill_slug: target?.slug,
+      triggered_by: (ctx.signals ?? []).map((s) => s.kind)
+    });
+  } catch {}
+}
+main();