@tech-leads-club/harness-toolkit 0.3.0 → 0.3.2

package/dist/chunks/compact-before-49j320yp.mjs

@@ -0,0 +1,1283 @@
+// src/platform/fs-jsonl.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+function appendRecord(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(value)}
+`);
+}
+function readTail(path, n) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  const records = [];
+  for (const line of readFileSync(path, "utf8").split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    try {
+      records.push(JSON.parse(trimmed));
+    } catch {}
+  }
+  return records.slice(-n);
+}
+
+// src/platform/process.ts
+import { spawn } from "node:child_process";
+var TIMEOUT_EXIT_CODE = 124;
+async function readStdinText() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function runProcess(args) {
+  const [file, ...argv] = args.command;
+  if (file === undefined) {
+    return { exitCode: 0, stdout: "", stderr: "" };
+  }
+  return await new Promise((resolve, reject) => {
+    const child = spawn(file, argv, {
+      cwd: args.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: args.env ?? process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = args.timeoutMs === undefined ? undefined : setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, args.timeoutMs);
+    child.stdout.on("data", (c) => {
+      stdout += c.toString();
+    });
+    child.stderr.on("data", (c) => {
+      stderr += c.toString();
+    });
+    child.on("error", (error) => {
+      if (timer)
+        clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (timer)
+        clearTimeout(timer);
+      if (timedOut) {
+        resolve({ exitCode: TIMEOUT_EXIT_CODE, stdout, stderr: `${stderr}
+(process timed out)` });
+        return;
+      }
+      resolve({ exitCode: code ?? 1, stdout, stderr });
+    });
+    if (args.input !== undefined) {
+      child.stdin.write(args.input);
+    }
+    child.stdin.end();
+  });
+}
+
+// src/platform/git.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+
+// src/platform/sanitize.ts
+var ALLOWED = /[A-Za-z0-9._-]/;
+var EMPTY_PLACEHOLDER = "_empty_";
+function sanitizeSegment(input) {
+  if (input.length === 0) {
+    return EMPTY_PLACEHOLDER;
+  }
+  let out = "";
+  for (const ch of input) {
+    if (ALLOWED.test(ch)) {
+      out += ch;
+      continue;
+    }
+    for (const byte of Buffer.from(ch, "utf8")) {
+      out += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+    }
+  }
+  return out;
+}
+function normalizeSeparators(input) {
+  return input.replace(/\\/g, "/");
+}
+
+// src/platform/git.ts
+async function gitLines(projectDir, args) {
+  const result = await runProcess({ command: ["git", ...args], cwd: projectDir });
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  return result.stdout.split(`
+`).map((line) => line.trim()).filter(Boolean);
+}
+async function listChangedRepoFiles(projectDir, base = "HEAD") {
+  if (!existsSync2(join(projectDir, ".git"))) {
+    return [];
+  }
+  const batches = await Promise.all([
+    gitLines(projectDir, ["diff", "--name-only", base]),
+    gitLines(projectDir, ["diff", "--name-only", "--cached"]),
+    gitLines(projectDir, ["ls-files", "--others", "--exclude-standard"])
+  ]);
+  const paths = new Set;
+  for (const batch of batches) {
+    for (const path of batch) {
+      paths.add(path);
+    }
+  }
+  return [...paths];
+}
+async function listAddedLines(projectDir, relativePaths, base = "HEAD") {
+  if (!existsSync2(join(projectDir, ".git")) || relativePaths.length === 0) {
+    return [];
+  }
+  const tracked = new Set(await gitLines(projectDir, ["ls-files", "--", ...relativePaths]));
+  const out = [];
+  for (const file of relativePaths) {
+    if (!tracked.has(file)) {
+      let raw = "";
+      try {
+        raw = readFileSync2(join(projectDir, file), "utf8");
+      } catch {
+        continue;
+      }
+      raw.split(/\r?\n/).forEach((text, index) => {
+        out.push({ file, line: index + 1, text });
+      });
+      continue;
+    }
+    const diff = await gitLines(projectDir, ["diff", "--unified=0", base, "--", file]);
+    let lineNo = 0;
+    for (const row of diff) {
+      const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(row);
+      if (hunk) {
+        lineNo = Number(hunk[1]);
+        continue;
+      }
+      if (row.startsWith("+++")) {
+        continue;
+      }
+      if (row.startsWith("+")) {
+        out.push({ file, line: lineNo, text: row.slice(1) });
+        lineNo += 1;
+      }
+    }
+  }
+  return out;
+}
+function isUnderPrefixes(relativePath, prefixes) {
+  const normalized = normalizeSeparators(relativePath);
+  return prefixes.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}/`));
+}
+function filterCodeTargets(relativePaths, codePaths) {
+  return relativePaths.filter((path) => {
+    if (!isUnderPrefixes(path, codePaths)) {
+      return false;
+    }
+    return /\.(ts|tsx|js|jsx|json|mjs|cjs|py|go|rs)$/.test(path);
+  });
+}
+function filterTestTargets(relativePaths) {
+  return relativePaths.filter((path) => /\.(spec|test)\.(ts|tsx|js|jsx)$/.test(path));
+}
+async function runCommand(projectDir, command, extraArgs = [], options = {}) {
+  if (command.length === 0) {
+    return { exitCode: 0, output: "", durationMs: 0 };
+  }
+  const started = Date.now();
+  const result = await runProcess({
+    command: [...command, ...extraArgs],
+    cwd: projectDir,
+    env: options.env ? { ...process.env, ...options.env } : process.env
+  });
+  const combined = (result.stdout + result.stderr).trim();
+  const maxChars = 8000;
+  const output = combined.length === 0 ? "(no output captured)" : combined.length <= maxChars ? combined : combined.slice(-maxChars);
+  return {
+    exitCode: result.exitCode,
+    output,
+    durationMs: Date.now() - started
+  };
+}
+async function listTrackedFiles(projectDir) {
+  const result = await runCommand(projectDir, ["git", "ls-files", "-z"]);
+  if (result.exitCode !== 0) {
+    return [];
+  }
+  return result.output.split("\x00").filter((path) => path !== "");
+}
+
+// src/platform/style.ts
+var COLORS = {
+  structure: "#3d3a4a",
+  accent: "#a78bfa",
+  success: "#6ee7b7",
+  warning: "#d4a574",
+  error: "#f87171",
+  info: "#93c5fd",
+  textMain: "#f5f5f7",
+  textMuted: "#9ca3af",
+  textDim: "#6b7280"
+};
+var SYMBOLS = {
+  check: "✔",
+  cross: "✖",
+  warning: "⚠",
+  arrow: "→",
+  arrowRight: "▸",
+  dot: "•",
+  bar: "│",
+  rule: "══",
+  dash: "──"
+};
+function rgb(hex) {
+  const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex.trim());
+  if (!match) {
+    return "255;255;255";
+  }
+  return [match[1], match[2], match[3]].map((part) => Number.parseInt(part, 16)).join(";");
+}
+var ESC = String.fromCharCode(27);
+var RESET = `${ESC}[0m`;
+function colorEnabled(env = process.env, argv = process.argv, isTty = process.stdout.isTTY === true) {
+  if ("NO_COLOR" in env) {
+    return false;
+  }
+  if (argv.includes("--no-color")) {
+    return false;
+  }
+  return isTty;
+}
+var STATUS_COLOR = {
+  ok: "success",
+  warn: "warning",
+  fail: "error",
+  info: "info"
+};
+var STATUS_MARK = {
+  ok: SYMBOLS.check,
+  warn: SYMBOLS.warning,
+  fail: SYMBOLS.cross,
+  info: SYMBOLS.arrowRight
+};
+var KV_WIDTH = 16;
+function createStyle(enabled = colorEnabled()) {
+  const wrap = (code, text) => enabled ? `${ESC}[${code}m${text}${RESET}` : text;
+  const paint = (name, text) => wrap(`38;2;${rgb(COLORS[name])}`, text);
+  return {
+    enabled,
+    paint,
+    bold: (text) => wrap("1", text),
+    dim: (text) => paint("textDim", text),
+    heading: (text) => paint("accent", `${SYMBOLS.rule} ${text} ${SYMBOLS.rule}`),
+    footer: (text) => paint("textDim", `${SYMBOLS.dash} ${text} ${SYMBOLS.dash}`),
+    kv: (label, value, width = KV_WIDTH) => `  ${paint("textMuted", `${label}:`.padEnd(width))} ${value}`,
+    status: (level, text) => `${paint(STATUS_COLOR[level], STATUS_MARK[level])} ${text}`
+  };
+}
+var PLAIN = createStyle(false);
+
+// src/platform/screen.ts
+function render(screen, style) {
+  const out = [style.heading(screen.title.toUpperCase())];
+  if (screen.summary && screen.summary.length > 0) {
+    out.push(`   ${screen.summary.join(style.dim(` ${SYMBOLS.bar} `))}`);
+  }
+  const width = Math.max(KV_WIDTH, ...screen.sections.flatMap((section) => (section.rows ?? []).map((row) => row.label.length + 1)));
+  for (const section of screen.sections) {
+    out.push("");
+    if (section.title) {
+      out.push(style.paint("accent", section.title));
+    }
+    for (const row of section.rows ?? []) {
+      const value = row.level ? style.status(row.level, row.value) : row.value;
+      out.push(style.kv(row.label, value, width));
+    }
+    for (const line of section.lines ?? []) {
+      out.push(line === "" ? "" : `  ${line}`);
+    }
+  }
+  if (screen.footer) {
+    out.push("", style.footer(screen.footer));
+  }
+  return out.join(`
+`);
+}
+
+// src/core/observability/observability.types.ts
+var DEFAULT_OBS = {
+  enabled: true,
+  signalPath: "obs.jsonl",
+  debugPath: "debug.jsonl",
+  debugEnabled: false,
+  includePayloads: false,
+  maxAttrChars: 500,
+  sessionCostAlertUsd: 5,
+  retentionDays: 14,
+  maxSignalEvents: 50000,
+  globalSpool: false
+};
+var SIGNAL_KINDS = new Set([
+  "session.start",
+  "session.end",
+  "generation.end",
+  "tool.fail",
+  "subagent.start",
+  "subagent.end",
+  "prompt.submit",
+  "compact",
+  "gate.outcome",
+  "cost.turn",
+  "cost.session_alert",
+  "ship.claim",
+  "policy.deny",
+  "policy.observe"
+]);
+var LIVE_ALLOWLIST = new Set([
+  "session.start",
+  "session.end",
+  "generation.end",
+  "tool.fail",
+  "shell.end",
+  "subagent.start",
+  "subagent.end",
+  "gate.outcome",
+  "cost.turn",
+  "cost.session_alert",
+  "ship.claim",
+  "policy.deny",
+  "compact",
+  "prompt.submit"
+]);
+function resolveObsLevel(kind, attrs = {}, forceDebug = false) {
+  if (forceDebug) {
+    return "debug";
+  }
+  if (kind === "shell.end" || kind === "shell.start") {
+    const permission = String(attrs.permission ?? "allow");
+    return permission === "allow" ? "debug" : "signal";
+  }
+  if (kind === "mcp.end") {
+    const outcome = String(attrs.outcome ?? attrs.status ?? "success");
+    return outcome === "error" || outcome === "fail" || outcome === "denied" ? "signal" : "debug";
+  }
+  return SIGNAL_KINDS.has(kind) ? "signal" : "debug";
+}
+var EVENT_KIND_TO_OBS_KIND = {
+  "session.start": "session.start",
+  "session.end": "session.end",
+  "prompt.submit": "prompt.submit",
+  "tool.before": "tool.start",
+  "tool.after": "tool.end",
+  "tool.failure": "tool.fail",
+  "shell.before": "shell.start",
+  "shell.after": "shell.end",
+  "mcp.before": "mcp.start",
+  "mcp.after": "mcp.end",
+  "read.before": "file.read",
+  "edit.after": "file.edit",
+  "subagent.start": "subagent.start",
+  "subagent.stop": "subagent.end",
+  stop: "generation.end",
+  "compact.before": "compact",
+  "response.after": "agent.response",
+  "thought.after": "agent.thought"
+};
+var SECRET_KEY = /(token|secret|password|api[_-]?key|authorization|credential|private[_-]?key)/i;
+var SECRET_VALUE = /\b(ghp_[A-Za-z0-9]{20,}|sk-[A-Za-z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,})\b/g;
+function redactDeep(value) {
+  if (typeof value === "string") {
+    return value.replace(SECRET_VALUE, "[REDACTED]");
+  }
+  if (Array.isArray(value)) {
+    return value.map(redactDeep);
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+      out[key] = SECRET_KEY.test(key) ? "[REDACTED]" : redactDeep(nested);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/core/comment-policy/comment-policy.service.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/core/comment-policy/comment-resolvability.ts
+var LEAK_RULES = [
+  {
+    kind: "change-narration",
+    pattern: /\b(?:used to|previously)\b/i,
+    says: "narrates the change instead of the state"
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bthis (?:was|used to)\b/i,
+    says: "narrates the change instead of the state"
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bthe old (?:code|version|implementation|approach|way|behaviou?r)\b/i,
+    says: "refers to code that is no longer here"
+  },
+  {
+    kind: "change-narration",
+    pattern: /\bbefore (?:this|the) (?:change|commit|fix|patch|refactor)\b/i,
+    says: "refers to a state the repository no longer holds"
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\((?:decision|item|step|phase|task|audit|option)\s*#?\d+\)/i,
+    says: "cites something only the authoring session could see"
+  },
+  {
+    kind: "dead-citation",
+    pattern: /§\s*\d/,
+    says: "cites a section of a document that is not in the repository"
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\bas (?:decided|agreed|discussed|mentioned|described) (?:above|earlier|previously|before)\b/i,
+    says: "points at a conversation the reader cannot see"
+  },
+  {
+    kind: "dead-citation",
+    pattern: /\b(?:per|from|in) the plan\b|\bthe plan above\b/i,
+    says: "points at a plan that is not in the repository"
+  },
+  {
+    kind: "review-vantage",
+    pattern: /\bthis (?:PR|MR|commit|patch|diff|changeset)\b/i,
+    says: "speaks from the change rather than from the repository"
+  },
+  {
+    kind: "review-vantage",
+    pattern: /\ba (?:later|follow-?up|subsequent) (?:PR|MR|commit)\b/i,
+    says: "speaks from the change rather than from the repository"
+  },
+  {
+    kind: "reviewer-addressed",
+    pattern: /\bthis is (?:safe|correct|fine|ok|okay)\b/i,
+    says: "argues its own correctness to a reviewer instead of stating the invariant"
+  },
+  {
+    kind: "reviewer-addressed",
+    pattern: /\brejected in review\b|\bthe reviewer\b/i,
+    says: "records who said what, which the repository cannot confirm"
+  },
+  {
+    kind: "flow-narration",
+    pattern: /\bfirst (?:we|it|this)\b[\s\S]{0,80}\bthen (?:we|it|this)\b/i,
+    says: "restates the control flow the code already shows"
+  }
+];
+function findLeaks(blockText) {
+  const leaks = [];
+  for (const rule of LEAK_RULES) {
+    const found = rule.pattern.exec(blockText);
+    if (found !== null) {
+      leaks.push({ kind: rule.kind, says: rule.says, match: found[0] });
+    }
+  }
+  return leaks;
+}
+function firstLeak(blockText) {
+  return findLeaks(blockText)[0] ?? null;
+}
+function leakReason(leak) {
+  return `unresolvable comment — ${leak.says} (\`${leak.match}\`)`;
+}
+
+// src/core/comment-policy/comment-syntax.catalog.ts
+var COMMENT_SYNTAX = [
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "python",
+    extensions: [".py", ".pyi", ".pyw"],
+    line: ["#"],
+    block: [
+      ['"""', '"""'],
+      ["'''", "'''"]
+    ],
+    middle: []
+  },
+  {
+    id: "ruby",
+    extensions: [".rb", ".rake", ".gemspec"],
+    line: ["#"],
+    block: [["=begin", "=end"]],
+    middle: []
+  },
+  {
+    id: "shell",
+    extensions: [".sh", ".bash", ".zsh", ".ksh", ".fish"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "go",
+    extensions: [".go"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "rust",
+    extensions: [".rs"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "java",
+    extensions: [".java"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "kotlin",
+    extensions: [".kt", ".kts"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "swift",
+    extensions: [".swift"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "c",
+    extensions: [".c", ".h"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "cpp",
+    extensions: [".cc", ".cpp", ".cxx", ".hpp", ".hh", ".hxx"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "csharp",
+    extensions: [".cs"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "php",
+    extensions: [".php"],
+    line: ["//", "#"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "scala",
+    extensions: [".scala", ".sc"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "dart",
+    extensions: [".dart"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "elixir",
+    extensions: [".ex", ".exs"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "erlang",
+    extensions: [".erl", ".hrl"],
+    line: ["%"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "haskell",
+    extensions: [".hs"],
+    line: ["--"],
+    block: [["{-", "-}"]],
+    middle: []
+  },
+  {
+    id: "lua",
+    extensions: [".lua"],
+    line: ["--"],
+    block: [["--[[", "]]"]],
+    middle: []
+  },
+  {
+    id: "sql",
+    extensions: [".sql"],
+    line: ["--"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "css",
+    extensions: [".css", ".scss", ".sass", ".less"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "yaml",
+    extensions: [".yaml", ".yml"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "toml",
+    extensions: [".toml"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "ini",
+    extensions: [".ini", ".cfg", ".conf", ".properties"],
+    line: [";", "#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "dockerfile",
+    extensions: [".dockerfile", "dockerfile"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "makefile",
+    extensions: [".mk", "makefile"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "terraform",
+    extensions: [".tf", ".tfvars"],
+    line: ["#", "//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "powershell",
+    extensions: [".ps1", ".psm1", ".psd1"],
+    line: ["#"],
+    block: [["<#", "#>"]],
+    middle: []
+  },
+  {
+    id: "perl",
+    extensions: [".pl", ".pm"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "r",
+    extensions: [".r"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "julia",
+    extensions: [".jl"],
+    line: ["#"],
+    block: [["#=", "=#"]],
+    middle: []
+  },
+  {
+    id: "vue",
+    extensions: [".vue", ".svelte"],
+    line: ["//"],
+    block: [
+      ["/*", "*/"],
+      ["<!--", "-->"]
+    ],
+    middle: ["*"]
+  },
+  {
+    id: "html",
+    extensions: [".html", ".htm", ".xml", ".xhtml"],
+    line: [],
+    block: [["<!--", "-->"]],
+    middle: []
+  },
+  {
+    id: "graphql",
+    extensions: [".graphql", ".gql"],
+    line: ["#"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "protobuf",
+    extensions: [".proto"],
+    line: ["//"],
+    block: [["/*", "*/"]],
+    middle: ["*"]
+  },
+  {
+    id: "zig",
+    extensions: [".zig"],
+    line: ["//"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "clojure",
+    extensions: [".clj", ".cljs", ".cljc", ".edn"],
+    line: [";"],
+    block: [],
+    middle: []
+  },
+  {
+    id: "ocaml",
+    extensions: [".ml", ".mli"],
+    line: [],
+    block: [["(*", "*)"]],
+    middle: ["*"]
+  },
+  {
+    id: "fsharp",
+    extensions: [".fs", ".fsi", ".fsx"],
+    line: ["//"],
+    block: [["(*", "*)"]],
+    middle: ["*"]
+  },
+  {
+    id: "vim",
+    extensions: [".vim"],
+    line: ['"'],
+    block: [],
+    middle: []
+  },
+  {
+    id: "tex",
+    extensions: [".tex", ".sty", ".cls"],
+    line: ["%"],
+    block: [],
+    middle: []
+  }
+];
+
+// src/core/comment-policy/comment-syntax.store.ts
+function buildIndex(entries) {
+  const byKey = new Map;
+  for (const entry of entries) {
+    const syntax = { line: entry.line, block: entry.block, middle: entry.middle };
+    for (const extension of entry.extensions) {
+      byKey.set(extension.toLowerCase(), syntax);
+    }
+  }
+  return byKey;
+}
+var INDEX = buildIndex(COMMENT_SYNTAX);
+function lookupSyntax(file, index = INDEX) {
+  const lower = file.toLowerCase().replace(/\\/g, "/");
+  const name = lower.slice(lower.lastIndexOf("/") + 1);
+  const direct = index.get(name);
+  if (direct) {
+    return direct;
+  }
+  let best = null;
+  let bestLength = 0;
+  for (const [extension, syntax] of index) {
+    if (extension.startsWith(".") && name.endsWith(extension) && extension.length > bestLength) {
+      best = syntax;
+      bestLength = extension.length;
+    }
+  }
+  return best;
+}
+function syntaxFor(file) {
+  return lookupSyntax(file);
+}
+function unknownExtensions(files) {
+  const unknown = new Set;
+  for (const file of files) {
+    if (lookupSyntax(file) === null) {
+      const name = file.toLowerCase().replace(/\\/g, "/").split("/").pop() ?? file;
+      const dot = name.lastIndexOf(".");
+      unknown.add(dot > 0 ? name.slice(dot) : name);
+    }
+  }
+  return [...unknown].sort();
+}
+var KNOWN_EXTENSION_COUNT = INDEX.size;
+
+// src/core/comment-policy/comment-policy.service.ts
+function matchesSyntax(text, syntax) {
+  const trimmed = text.trimStart();
+  if (trimmed === "") {
+    return false;
+  }
+  if (syntax.line.some((prefix) => prefix !== "" && trimmed.startsWith(prefix))) {
+    return true;
+  }
+  for (const [open, close] of syntax.block) {
+    if (trimmed.startsWith(open)) {
+      return true;
+    }
+    if (open !== close && trimmed.startsWith(close)) {
+      return false;
+    }
+  }
+  return syntax.middle.some((middle) => trimmed.startsWith(middle) && !trimmed.startsWith(middle + middle));
+}
+var TOOL_DIRECTIVE = /^\s*(?:\/\/|\/\*|\*|#)\s*(?:biome-ignore|eslint|@ts-|prettier-ignore|noqa|type:|shellcheck|!)/;
+var DECLARED_REASON = /^\s*(?:\/\/|\/\*|\*|#)\s*(?:why|hazard|invariant):\s*\S/i;
+var CLOSER_OR_CONTINUATION = /^\s*(?:\*\/|\*|\/\/)/;
+var COMMENT_MARKERS = ["why:", "hazard:", "invariant:"];
+function isCommentLine(text, file = "") {
+  const syntax = file === "" ? null : syntaxFor(file);
+  if (syntax === null) {
+    return false;
+  }
+  return matchesSyntax(text, syntax) && !TOOL_DIRECTIVE.test(text);
+}
+function declaresReason(text) {
+  return DECLARED_REASON.test(text);
+}
+var DECLARATION = /^\s*(?:(?:export|declare|public|private|protected|readonly|static|async|abstract)\s+)*(?:class|function|const|let|var|type|interface|enum|namespace)\s+([A-Za-z_$][\w$]*)|^\s*(?:readonly\s+)?([A-Za-z_$][\w$]*)\??\s*[:(<]/;
+function attachedIdentifier(codeLine) {
+  const match = codeLine === undefined ? null : DECLARATION.exec(codeLine);
+  return match ? match[1] ?? match[2] ?? null : null;
+}
+var STOPWORDS = new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "get",
+  "gets",
+  "has",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "of",
+  "on",
+  "or",
+  "return",
+  "returns",
+  "set",
+  "sets",
+  "that",
+  "the",
+  "then",
+  "this",
+  "to",
+  "true",
+  "when",
+  "which",
+  "with"
+]);
+function words(text) {
+  return text.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 1);
+}
+var MIN_INFORMATIVE_WORDS = 3;
+function isInformativeDoc(commentText, identifier) {
+  const named = new Set(words(identifier));
+  const remaining = words(commentText.replace(/^[\s/*]+|[\s*/]+$/g, "")).filter((word) => !named.has(word) && !STOPWORDS.has(word));
+  return new Set(remaining).size >= MIN_INFORMATIVE_WORDS;
+}
+function groupCommentBlocks(added) {
+  const blocks = [];
+  let block = [];
+  for (const line of added) {
+    if (!isCommentLine(line.text, line.file)) {
+      block = [];
+      continue;
+    }
+    const previous = block.at(-1);
+    if (previous && previous.file === line.file && previous.line === line.line - 1) {
+      block.push(line);
+      continue;
+    }
+    block = [line];
+    blocks.push(block);
+  }
+  return blocks;
+}
+var MAX_DECLARED_LINES = 4;
+function declarationAfter(file, tailLine, nextCodeLine) {
+  for (let line = tailLine + 1;line <= tailLine + 4; line += 1) {
+    const text = nextCodeLine(file, line);
+    if (text === undefined) {
+      continue;
+    }
+    if (text.trim() === "" || CLOSER_OR_CONTINUATION.test(text)) {
+      continue;
+    }
+    return text;
+  }
+  return;
+}
+function judge(block, mode, nextCodeLine) {
+  const head = block[0];
+  const tail = block.at(-1);
+  if (head.text.trimStart().startsWith("/**") && nextCodeLine) {
+    const identifier = attachedIdentifier(declarationAfter(head.file, tail.line, nextCodeLine));
+    if (identifier !== null) {
+      const body = block.map((line) => line.text).join(" ");
+      if (mode === "strict") {
+        return { violates: true, reason: "comment added this turn" };
+      }
+      if (!isInformativeDoc(body, identifier)) {
+        return { violates: true, reason: `doc comment only restates ${identifier}` };
+      }
+      const docLeak = mode === "resolvable" ? firstLeak(body) : null;
+      return docLeak === null ? { violates: false, reason: "" } : { violates: true, reason: leakReason(docLeak) };
+    }
+  }
+  if (mode === "strict") {
+    return { violates: true, reason: "comment added this turn" };
+  }
+  if (!declaresReason(head.text)) {
+    return { violates: true, reason: "undeclared comment added this turn" };
+  }
+  if (block.length > MAX_DECLARED_LINES) {
+    return { violates: true, reason: `declared comment runs past ${MAX_DECLARED_LINES} lines` };
+  }
+  if (mode === "resolvable") {
+    const leak = firstLeak(block.map((line) => line.text).join(" "));
+    if (leak !== null) {
+      return { violates: true, reason: leakReason(leak) };
+    }
+  }
+  return { violates: false, reason: "" };
+}
+function findAddedComments(added, mode = "declared", nextCodeLine) {
+  const findings = [];
+  for (const block of groupCommentBlocks(added)) {
+    if (block[0] === undefined) {
+      continue;
+    }
+    const verdict = judge(block, mode, nextCodeLine);
+    if (verdict.violates) {
+      const head = block[0];
+      findings.push({
+        file: head.file,
+        line: head.line,
+        reason: verdict.reason,
+        text: head.text.trim().slice(0, 120)
+      });
+    }
+  }
+  return findings;
+}
+function diskLineReader(projectDir) {
+  const cache = new Map;
+  return (file, line) => {
+    let lines = cache.get(file);
+    if (lines === undefined) {
+      try {
+        lines = readFileSync3(join2(projectDir, file), "utf8").split(`
+`);
+      } catch {
+        lines = [];
+      }
+      cache.set(file, lines);
+    }
+    return lines[line - 1];
+  };
+}
+async function scanAddedComments(projectDir, relativePaths, mode = "declared", base = "HEAD") {
+  const added = await listAddedLines(projectDir, relativePaths, base);
+  return findAddedComments(added, mode, diskLineReader(projectDir));
+}
+function commentViolationMessage(hits, mode = "declared") {
+  const need = mode === "resolvable" ? [
+    "NEED: restate each line below so a reader at HEAD can check it without the transcript of",
+    "this session — state the present behaviour, or state the counterfactual (`without X, Y`).",
+    "Delete it when nothing survives that restatement."
+  ] : mode === "strict" ? [
+    "NEED: delete every line below. This project does not accept agent-added comments.",
+    "If one is genuinely warranted, say so in your reply and let the operator write it."
+  ] : [
+    `NEED: delete each line below, or restate it as ${COMMENT_MARKERS.join(" / ")} when it`,
+    "records a non-obvious why, a hazard, or an external constraint. Narrating what the code",
+    "does is not a reason."
+  ];
+  return [
+    `BLOCKED: this turn added ${hits.length} comment(s).`,
+    "TRIED: compared the lines this turn added against the commit it started from; pre-existing",
+    "comments are never counted.",
+    "Each entry is one comment, reported at its first line.",
+    ...need,
+    "Tool directives (biome-ignore, @ts-, noqa, shellcheck, shebang) are exempt.",
+    "",
+    ...hits.slice(0, 20).map((h) => `${h.file}:${h.line}  ${h.text}`)
+  ].join(`
+`);
+}
+
+// src/core/duplication/duplication.service.ts
+var MIN_RUN = 6;
+var MIN_LINE_CHARS = 8;
+function normaliseLine(text) {
+  const collapsed = text.trim().replace(/\s+/g, " ").replace(/,$/, "");
+  return collapsed.length < MIN_LINE_CHARS ? null : collapsed;
+}
+var DEPENDENCY_LINE = /^\s*(?:import|from|export|require|#include|use|using|package|namespace|open)\b/;
+function isCodeLine(text, file) {
+  if (DEPENDENCY_LINE.test(text)) {
+    return false;
+  }
+  const syntax = syntaxFor(file);
+  return syntax === null ? true : !matchesSyntax(text, syntax);
+}
+var OPERATIONAL = /[(=]|\b(?:if|for|while|switch|return|throw|await|new|catch)\b/;
+var MIN_OPERATIONAL_RATIO = 0.5;
+function operationalEnough(window) {
+  const operations = window.filter((entry) => OPERATIONAL.test(entry.key)).length;
+  return operations >= Math.ceil(window.length * MIN_OPERATIONAL_RATIO);
+}
+var SITES_PER_RUN = 2;
+function runKey(window) {
+  return window.join(`
+`);
+}
+function indexRuns(lines, minRun = MIN_RUN) {
+  const index = new Map;
+  const usable = lines.map((entry) => ({
+    ...entry,
+    key: isCodeLine(entry.text, entry.file) ? normaliseLine(entry.text) : null
+  })).map((entry) => entry.key === null ? null : { file: entry.file, line: entry.line, key: entry.key });
+  for (let start = 0;start + minRun <= usable.length; start += 1) {
+    const window = usable.slice(start, start + minRun);
+    if (window.some((entry) => entry === null)) {
+      continue;
+    }
+    const solid = window;
+    const head = solid[0];
+    if (solid.some((entry, offset) => entry.file !== head.file || entry.line !== head.line + offset)) {
+      continue;
+    }
+    if (!operationalEnough(solid)) {
+      continue;
+    }
+    const key = runKey(solid.map((entry) => entry.key));
+    const sites = index.get(key) ?? [];
+    if (sites.length < SITES_PER_RUN) {
+      index.set(key, [...sites, { file: head.file, line: head.line }]);
+    }
+  }
+  return index;
+}
+function findDuplications(added, project, minRun = MIN_RUN) {
+  const found = [];
+  const reported = new Set;
+  for (const [key, sites] of indexRuns(added, minRun)) {
+    const where = sites[0];
+    const prior = (project.get(key) ?? []).find((site) => site.file !== where.file || site.line !== where.line);
+    if (prior === undefined) {
+      continue;
+    }
+    const seen = `${where.file}:${where.line}`;
+    if (reported.has(seen)) {
+      continue;
+    }
+    reported.add(seen);
+    found.push({
+      file: where.file,
+      line: where.line,
+      matchFile: prior.file,
+      matchLine: prior.line,
+      runLength: minRun
+    });
+  }
+  return found.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+}
+function duplicationMessage(hits) {
+  return [
+    `BLOCKED: this turn added ${hits.length} run(s) of ${MIN_RUN}+ lines that already exist in this project.`,
+    "TRIED: compared the lines this turn added against the rest of the repository, ignoring",
+    "comments, blank lines and whitespace. A run already duplicated before this turn is not counted.",
+    "NEED: call the existing code, or extract what both need. If the duplication is deliberate —",
+    "the two will diverge, or the shared form would couple them — say which, in one line, and continue.",
+    "",
+    ...hits.slice(0, 10).map((hit) => `${hit.file}:${hit.line}  already at  ${hit.matchFile}:${hit.matchLine}`)
+  ].join(`
+`);
+}
+var MAX_SCAN_FILES = 2000;
+var MAX_SCAN_BYTES = 8000000;
+function scanProject(files, readFile, minRun = MIN_RUN) {
+  const lines = [];
+  let bytes = 0;
+  let filesRead = 0;
+  let truncated = false;
+  for (const file of files) {
+    if (filesRead >= MAX_SCAN_FILES || bytes >= MAX_SCAN_BYTES) {
+      truncated = true;
+      break;
+    }
+    const text = readFile(file);
+    if (text === null) {
+      continue;
+    }
+    bytes += text.length;
+    filesRead += 1;
+    for (const [index, line] of text.split(`
+`).entries()) {
+      lines.push({ file, line: index + 1, text: line });
+    }
+  }
+  return { index: indexRuns(lines, minRun), filesRead, truncated };
+}
+
+// src/core/policy/policy.defaults.ts
+var DEFAULT_LESSONS_POLICY = {
+  enabled: false,
+  maxInjectSession: 5,
+  maxInjectRetry: 8,
+  maxCharsSession: 900,
+  maxCharsRetry: 1400,
+  promoteHitCount: 2,
+  decayLambda: 0.02,
+  projectBoost: 1.5,
+  syncRulesFile: "auto",
+  gardenOnSessionEnd: true
+};
+var DEFAULTS = {
+  version: 1,
+  mode: "solo",
+  codePaths: ["src", "apps", "libs", "packages"],
+  grind: {
+    enabled: false,
+    maxLoops: 5,
+    lintCommand: null,
+    testCommand: null,
+    appendFiles: "auto"
+  },
+  shipGate: {
+    enabled: false,
+    runtimePathPrefixes: ["src", "apps", "libs", "packages", "deploy", "scripts"],
+    runtimePathExcludes: [".tlc/", "**/node_modules/", "**/.git/"],
+    evidenceDir: null,
+    evidenceMaxAgeHours: 48,
+    emptyDiffAntiShip: false,
+    claimWindowMinutes: 10
+  },
+  subagents: {
+    enforceAllowlist: false,
+    requireModel: false,
+    allowedModels: [],
+    blockedPatterns: ["-fast(?:$|[^a-z0-9])", "/fast(?:$|[^a-z0-9])"],
+    minEffort: null,
+    blockParentFast: false,
+    blockMode: "deny",
+    readOnlyTypes: ["explore"]
+  },
+  docs: {
+    command: null,
+    severity: "warn"
+  },
+  observe: {
+    enabled: false,
+    rails: []
+  },
+  comments: {
+    enabled: false,
+    onViolation: "followup",
+    mode: "declared"
+  },
+  supplyChain: {
+    enabled: false
+  },
+  duplication: {
+    enabled: false,
+    minRun: MIN_RUN
+  },
+  obs: {
+    globalSpool: false,
+    includePayloads: DEFAULT_OBS.includePayloads,
+    maxAttrChars: DEFAULT_OBS.maxAttrChars,
+    sessionCostAlertUsd: DEFAULT_OBS.sessionCostAlertUsd,
+    retentionDays: DEFAULT_OBS.retentionDays
+  },
+  untrustedContent: {
+    mode: "frame",
+    enabled: false,
+    extraTools: [],
+    extraCommandPatterns: []
+  },
+  planGate: {
+    enabled: false,
+    windowMinutes: 120
+  },
+  shell: {
+    catastrophicAsk: true,
+    stallDetection: false,
+    stallRepeatThreshold: 3
+  },
+  intelligence: {
+    gapFeedback: true,
+    failureClassification: true,
+    progressiveHandoff: true,
+    progressiveContext: true,
+    autopilot: true,
+    idleTurnGate: false,
+    budgetContinue: false,
+    budgetContinueAfterLoops: 3,
+    lessons: { ...DEFAULT_LESSONS_POLICY }
+  },
+  mcpPrime: [],
+  bootstrapExtra: []
+};
+
+// src/contracts/effort.ts
+var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+function effortOrdinal(level) {
+  return EFFORT_LEVELS.indexOf(level);
+}
+function compareEffort(a, b) {
+  return effortOrdinal(a) - effortOrdinal(b);
+}
+function isEffortLevel(value) {
+  return typeof value === "string" && EFFORT_LEVELS.includes(value);
+}
+
+export { appendRecord, readTail, readStdinText, runProcess, sanitizeSegment, normalizeSeparators, listChangedRepoFiles, listAddedLines, filterCodeTargets, filterTestTargets, runCommand, listTrackedFiles, unknownExtensions, KNOWN_EXTENSION_COUNT, isCommentLine, declaresReason, findAddedComments, scanAddedComments, commentViolationMessage, MIN_RUN, findDuplications, duplicationMessage, scanProject, SYMBOLS, createStyle, PLAIN, render, DEFAULT_OBS, resolveObsLevel, EVENT_KIND_TO_OBS_KIND, redactDeep, DEFAULTS, compareEffort, isEffortLevel };