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

package/dist/init-project.mjs

@@ -1,784 +1,27 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// tools/init-project.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, join as join4, sep } from "node:path";
-
-// bin/write-user-hooks.mjs
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-
-// src/providers/claude/claude.wiring.ts
-import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
-
-// src/platform/paths.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
-function harnessDir(root) {
-  return join(root, ".tlc", "harness");
-}
-function conventionalRuntimeHome() {
-  return join(homedir(), ".tlc", "harness");
-}
-function runtimeHome(env = process.env) {
-  return env.TLC_HOME ?? conventionalRuntimeHome();
-}
-function projectConfigPath(root) {
-  return join(harnessDir(root), "config.json");
-}
-function claudeConfigDir() {
-  const custom = process.env.CLAUDE_CONFIG_DIR?.trim();
-  return custom && custom.length > 0 ? custom : join(homedir(), ".claude");
-}
-function cursorConfigDir() {
-  const custom = process.env.CURSOR_CONFIG_DIR?.trim();
-  return custom && custom.length > 0 ? custom : join(homedir(), ".cursor");
-}
-
-// src/providers/claude/claude.wiring.ts
-function isPlainRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function isHooksRecord(value) {
-  return isPlainRecord(value);
-}
-function deepEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (Array.isArray(a) || Array.isArray(b)) {
-    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
-      return false;
-    }
-    return a.every((item, index) => deepEqual(item, b[index]));
-  }
-  if (isPlainRecord(a) && isPlainRecord(b)) {
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length) {
-      return false;
-    }
-    return aKeys.every((key) => bKeys.includes(key) && deepEqual(a[key], b[key]));
-  }
-  return false;
-}
-function desiredHooksFor(entries) {
-  const hooks = {};
-  for (const entry of entries) {
-    const group = {
-      hooks: [{ type: "command", command: entry.command, args: entry.args }]
-    };
-    hooks[entry.hookEvent] = [...hooks[entry.hookEvent] ?? [], group];
-  }
-  return hooks;
-}
-var LAUNCHER_MARKER = "tlc-exec.mjs";
-function isHarnessGroup(group) {
-  return JSON.stringify(group ?? null).includes(LAUNCHER_MARKER);
-}
-function canonicalLauncherPath(path, resolve = realpathSync) {
-  try {
-    return resolve(path);
-  } catch {
-    return path;
-  }
-}
-function canonicalizeGroups(groups, resolve) {
-  return JSON.parse(JSON.stringify(groups ?? null, (_key, value) => typeof value === "string" && value.includes(LAUNCHER_MARKER) ? canonicalLauncherPath(value, resolve) : value));
-}
-function mergeClaudeSettings(existingText, entries) {
-  const desired = desiredHooksFor(entries);
-  let settings = {};
-  if (existingText !== null && existingText.trim() !== "") {
-    let parsed;
-    try {
-      parsed = JSON.parse(existingText);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return { ok: false, error: message, block: JSON.stringify({ hooks: desired }, null, 2) };
-    }
-    if (!isPlainRecord(parsed)) {
-      return {
-        ok: false,
-        error: "settings.json root is not a JSON object",
-        block: JSON.stringify({ hooks: desired }, null, 2)
-      };
-    }
-    settings = parsed;
-  }
-  const currentHooks = isHooksRecord(settings.hooks) ? settings.hooks : {};
-  const mergedHooks = { ...currentHooks };
-  let changed = false;
-  for (const [hookEvent, groups] of Object.entries(desired)) {
-    const existingGroups = mergedHooks[hookEvent] ?? [];
-    const foreign = existingGroups.filter((group) => !isHarnessGroup(group));
-    const nextGroups = [...foreign, ...groups];
-    if (!deepEqual(canonicalizeGroups(existingGroups), canonicalizeGroups(nextGroups))) {
-      changed = true;
-    }
-    mergedHooks[hookEvent] = nextGroups;
-  }
-  const mergedSettings = { ...settings, hooks: mergedHooks };
-  return { ok: true, settingsText: JSON.stringify(mergedSettings, null, 2), changed };
-}
-function applyClaudeWiring(settingsPath, entries) {
-  const existingText = existsSync(settingsPath) ? readFileSync(settingsPath, "utf8") : null;
-  const result = mergeClaudeSettings(existingText, entries);
-  if (result.ok && result.changed) {
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, result.settingsText, "utf8");
-  }
-  return result;
-}
-// src/providers/provider.degrade.ts
-var NO_HUMAN_MODES = new Set(["bypassPermissions", "dontAsk"]);
-// bin/write-user-hooks.mjs
-var CURSOR_MARKER = "tlc-exec.mjs";
-function quoteIfNeeded(token) {
-  return token.includes(" ") ? `"${token}"` : token;
-}
-function commandStringFor(entry) {
-  return [entry.command, ...entry.args].map(quoteIfNeeded).join(" ");
-}
-function renderCursorHooksDocument(entries) {
-  const hooks = {};
-  for (const entry of entries) {
-    const rendered = { command: commandStringFor(entry), timeout: entry.timeoutSeconds };
-    if (entry.failClosed) {
-      rendered.failClosed = true;
-    }
-    if (entry.matcher !== undefined) {
-      rendered.matcher = entry.matcher;
-    }
-    if (entry.loopLimit !== undefined) {
-      rendered.loop_limit = entry.loopLimit;
-    }
-    hooks[entry.hookEvent] = [...hooks[entry.hookEvent] ?? [], rendered];
-  }
-  return { version: 1, hooks };
-}
-function isCursorWired(targetPath) {
-  return existsSync2(targetPath) && readFileSync2(targetPath, "utf8").includes(CURSOR_MARKER);
-}
-function applyCursorWiring(wiring, { force = false } = {}) {
-  const targetPath = wiring.target;
-  const document = renderCursorHooksDocument(wiring.entries);
-  const rendered = `${JSON.stringify(document, null, 2)}
-`;
-  if (existsSync2(targetPath) && !force) {
-    if (isCursorWired(targetPath)) {
-      return { status: "unchanged", target: targetPath };
-    }
-    return {
-      status: "refused",
-      target: targetPath,
-      reason: `${targetPath} exists without harness entries — rerun with --force to overwrite, or merge manually.`
-    };
-  }
-  mkdirSync2(dirname2(targetPath), { recursive: true });
-  writeFileSync2(targetPath, rendered);
-  return { status: "written", target: targetPath };
-}
-if (false) {}
-
-// 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);
-var KNOWN_EXTENSION_COUNT = INDEX.size;
-
-// src/core/comment-policy/comment-policy.service.ts
-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"
-]);
-
-// src/core/duplication/duplication.service.ts
-var MIN_RUN = 6;
-
-// 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"
-]);
-
-// 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/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(`
-`);
-}
+import {
+  applyCursorWiring,
+  renderCursorHooksDocument
+} from "./chunks/compact-before-7sdmwswh.mjs";
+import"./chunks/compact-before-j9y4jgn4.mjs";
+import {
+  applyClaudeWiring
+} from "./chunks/compact-before-w1293m4n.mjs";
+import {
+  DEFAULTS,
+  PLAIN,
+  render
+} from "./chunks/compact-before-49j320yp.mjs";
+import {
+  __require,
+  claudeConfigDir,
+  cursorConfigDir,
+  projectConfigPath,
+  runtimeHome
+} from "./chunks/compact-before-4jrq0sqs.mjs";
 
 // tools/init-project.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
 class UsageError extends Error {
 }
 function parseFlags(args) {
@@ -809,7 +52,7 @@ function usageText(style = PLAIN) {
   return render(usageScreen(), style);
 }
 function launcherPath(home = runtimeHome()) {
-  return join4(home, "bin", "tlc-exec.mjs");
+  return join(home, "bin", "tlc-exec.mjs");
 }
 var SHIM_COMMAND = { command: "node", argsPrefix: [] };
 var CURSOR_SHIM_SPECS = [
@@ -853,14 +96,14 @@ function claudeShimEntries(launcher) {
     ...spec.loopLimit !== undefined ? { loopLimit: spec.loopLimit } : {}
   }));
 }
-var PROJECT_SHIMS = [join4(".cursor", "hooks.json"), join4(".claude", "settings.json")];
+var PROJECT_SHIMS = [join(".cursor", "hooks.json"), join(".claude", "settings.json")];
 var GITIGNORE_STATE = ".tlc/harness/state/";
 function gitignoreEntries() {
   return [GITIGNORE_STATE, ...PROJECT_SHIMS.map((path) => path.split(sep).join("/"))];
 }
 function mergeGitignore(root) {
-  const path = join4(root, ".gitignore");
-  const existing = existsSync3(path) ? readFileSync3(path, "utf8") : "";
+  const path = join(root, ".gitignore");
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
   const lines = existing.split(`
 `);
   const missing = gitignoreEntries().filter((entry) => !lines.includes(entry));
@@ -882,15 +125,15 @@ function resolvePolicy(root, flags, stdinText) {
     }
     return JSON.parse(stdinText);
   }
-  if (!flags.minimal && !flags.stdinJson && existsSync3(projectConfigPath(root))) {
-    return JSON.parse(readFileSync3(projectConfigPath(root), "utf8"));
+  if (!flags.minimal && !flags.stdinJson && existsSync(projectConfigPath(root))) {
+    return JSON.parse(readFileSync(projectConfigPath(root), "utf8"));
   }
   return DEFAULTS;
 }
 function detectProviders(dirs = {}) {
   return {
-    cursor: existsSync3(dirs.cursor ?? cursorConfigDir()),
-    claude: existsSync3(dirs.claude ?? claudeConfigDir())
+    cursor: existsSync(dirs.cursor ?? cursorConfigDir()),
+    claude: existsSync(dirs.claude ?? claudeConfigDir())
   };
 }
 function buildPlan(root, flags, stdinText, presence) {
@@ -906,28 +149,28 @@ function buildPlan(root, flags, stdinText, presence) {
 function applyPlan(root, flags, presence, stdinText) {
   const policy = resolvePolicy(root, flags, stdinText);
   const configPath = projectConfigPath(root);
-  mkdirSync3(dirname3(configPath), { recursive: true });
-  writeFileSync3(configPath, `${JSON.stringify(policy, null, 2)}
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(policy, null, 2)}
 `);
   const launcher = launcherPath();
   const cursor = presence.cursor ? (() => {
     const result = applyCursorWiring({
-      target: join4(root, ".cursor", "hooks.json"),
+      target: join(root, ".cursor", "hooks.json"),
       strategy: "replace",
       entries: cursorShimEntries(launcher)
     }, { force: flags.force });
     return { skipped: false, status: result.status, target: result.target };
   })() : { skipped: true };
   const claude = presence.claude ? (() => {
-    const result = applyClaudeWiring(join4(root, ".claude", "settings.json"), claudeShimEntries(launcher));
+    const result = applyClaudeWiring(join(root, ".claude", "settings.json"), claudeShimEntries(launcher));
     return {
       skipped: false,
       status: result.ok ? result.changed ? "written" : "unchanged" : "failed",
-      target: join4(root, ".claude", "settings.json")
+      target: join(root, ".claude", "settings.json")
     };
   })() : { skipped: true };
   const gitignore = mergeGitignore(root);
-  writeFileSync3(join4(root, ".gitignore"), gitignore.text);
+  writeFileSync(join(root, ".gitignore"), gitignore.text);
   return { configPath, cursor, claude };
 }
 async function readStdin() {