tend-cli 0.7.0 → 0.9.0

package/dist/bin.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-import { ClaudeSession, EFFORT_LEVELS, EventBus, ReportBuilder, ReportSchema, Snapshot, addUsage, applyCliOverrides, assertGitRepo, buildDiff, buildProgram, changedVsHead, createGit, detectBuildCommand, detectPackageManager, filesUnder, filterToChanged, formatClock, gateUnitChanges, loadConfig, makeDeterministicFixUnit, makeTheme, orchestrate, planRepair, planWorkFromRepairs, reasonLabel, renderSummary, resolveRetryTarget, restoreSnapshot, retryCommand, runEslintSonarjs, runScanner, scannerStatus, showCommand, snapshotUnitFiles, snapshotUnitNow, toRepoRelative, unitChanged, zeroUsage } from "./config-DPlVYfKX.js";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { ClaudeSession, EFFORT_LEVELS, EventBus, ReportBuilder, ReportSchema, Snapshot, addUsage, applyCliOverrides, assertGitRepo, buildDiff, buildProgram, changedVsHead, createGit, detectBuildCommand, detectPackageManager, filesUnder, filterToChanged, formatClock, gateUnitChanges, loadConfig, makeDeterministicFixUnit, makeTheme, orchestrate, planRepair, planWorkFromRepairs, reasonLabel, renderSummary, resolveRetryTarget, restoreSnapshot, retryCommand, runEslintSonarjs, runScanner, scannerStatus, showCommand, snapshotUnitFiles, snapshotUnitNow, toRepoRelative, unitChanged, zeroUsage } from "./config-BPLYzcro.js";
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { execa } from "execa";
+import { createHash } from "node:crypto";
 import PQueue from "p-queue";
 import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
@@ -753,18 +754,28 @@ function templateForStrategy(strategy) {
 function renderFileList(files) {
 	return files.map((file) => `- ${file}`).join("\n");
 }
+/**
+* Render the editable files' current source as labelled fenced blocks, so the model can
+* edit without a preliminary Read (Fix 6). Templates that don't reference `{{fileContents}}`
+* are unaffected; an empty map renders a neutral note so the placeholder is never left raw.
+*/
+function renderFileContents(contents) {
+	if (contents.size === 0) return "(file content not supplied — read the file before editing)";
+	return [...contents].map(([file, source]) => `### ${file}\n\n\`\`\`\n${source}\n\`\`\``).join("\n\n");
+}
 function renderCommonTemplate(input) {
-	return replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(input.template, "{{strategyName}}", input.strategyName), "{{findings}}", input.findings), "{{editableFiles}}", renderFileList(input.editableFiles)), "{{verificationTargets}}", renderFileList(input.verificationTargets)).trim();
+	return replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(input.template, "{{strategyName}}", input.strategyName), "{{findings}}", input.findings), "{{editableFiles}}", renderFileList(input.editableFiles)), "{{verificationTargets}}", renderFileList(input.verificationTargets)), "{{fileContents}}", renderFileContents(input.fileContents ?? new Map())).trim();
 }
-/** Render the fix prompt for a unit's findings. */
-function renderPrompt(unit) {
+/** Render the fix prompt for a unit's findings. `fileContents` supplies on-disk source. */
+function renderPrompt(unit, fileContents) {
 	const strategyName = promptStrategyFor(unit);
 	return renderCommonTemplate({
 		template: templateForStrategy(strategyName),
 		strategyName,
 		findings: renderFindingsJson(unit.findings),
 		editableFiles: unit.files,
-		verificationTargets: unit.verificationTargets ?? unit.files
+		verificationTargets: unit.verificationTargets ?? unit.files,
+		fileContents
 	});
 }
 function firstRelevantLines(output, max = 20) {
@@ -800,8 +811,8 @@ function renderRegressionRepairPrompt(input) {
 	});
 	return replaceAllLiteral(replaceAllLiteral(replaceAllLiteral(prompt, "{{rejectedDiff}}", firstRelevantLines(input.rejectedDiff, 80)), "{{newFindings}}", renderFindingsJson(input.newFindings)), "{{gateDetails}}", [`Reason: ${input.gateReason}`, firstRelevantLines(input.gateOutput)].join("\n")).trim();
 }
-function renderNoEditRetryPrompt(unit) {
-	return `${renderPrompt(unit)}
+function renderNoEditRetryPrompt(unit, fileContents) {
+	return `${renderPrompt(unit, fileContents)}
 
 The previous session completed without changing any owned file. Retry once with a smaller, concrete edit:
 - Make the minimal behavior-preserving code change that clears the finding.
@@ -841,12 +852,19 @@ function makeFixUnit(deps) {
 		const before = snapshotUnitFiles(deps.cwd, snapshotFiles);
 		const restore = () => restoreSnapshot(deps.cwd, before);
 		const changedOnDisk = () => unitChanged(deps.cwd, unit.files, before);
+		const fileContents = new Map();
+		for (const file of unit.files) {
+			const source = before.get(file);
+			if (typeof source === "string") fileContents.set(file, source);
+		}
 		let usage = zeroUsage();
+		const activity = (stage) => (detail) => progress(stage, detail);
 		progress("ai-edit");
 		const res = await deps.session.run({
 			file: unit.file,
 			findings: unit.findings,
-			prompt: renderPrompt(unit)
+			prompt: renderPrompt(unit, fileContents),
+			onActivity: activity("ai-edit")
 		});
 		if (res.usage) usage = addUsage(usage, res.usage);
 		if (!res.ok) {
@@ -864,7 +882,8 @@ function makeFixUnit(deps) {
 			const retry = await deps.session.run({
 				file: unit.file,
 				findings: unit.findings,
-				prompt: renderNoEditRetryPrompt(unit)
+				prompt: renderNoEditRetryPrompt(unit, fileContents),
+				onActivity: activity("ai-no-edit-retry")
 			});
 			if (retry.usage) usage = addUsage(usage, retry.usage);
 			if (!retry.ok) {
@@ -906,7 +925,8 @@ function makeFixUnit(deps) {
 					newFindings: outcome$1.reason === "regression" ? await scanNewFindings() : [],
 					gateReason: outcome$1.reason,
 					gateOutput: outcome$1.detail ?? ""
-				})
+				}),
+				onActivity: activity("regression-repair")
 			});
 			if (repair.usage) usage = addUsage(usage, repair.usage);
 			if (!repair.ok) {
@@ -931,7 +951,8 @@ function makeFixUnit(deps) {
 							newFindings: [],
 							gateReason: "broke-test",
 							gateOutput: `Fix left previously-green test(s) red:\n${regressed.map((test) => test.name).join("\n")}`
-						})
+						}),
+						onActivity: activity("test-repair")
 					});
 					if (repair.usage) usage = addUsage(usage, repair.usage);
 					if (!repair.ok) repairFailureDetail = `Repair session failed: ${repair.error}`;
@@ -957,14 +978,83 @@ function makeFixUnit(deps) {
 	};
 }
 
+//#endregion
+//#region src/fixing/thinking-budget.ts
+/** Thinking disabled — mechanical fixes don't need reasoning tokens. */
+const THINKING_OFF = 0;
+/**
+* Upper bound on extended-thinking tokens per fix session. Unbounded thinking
+* measured ~7000 tokens per finding regardless of difficulty; capping it keeps
+* reasoning fixes correct (gate stays green) at a fraction of the latency.
+*/
+const THINKING_BUDGET_CAP = 4096;
+function isMechanical(finding) {
+	return finding.category === "dead-code" || finding.autofixable === true;
+}
+/**
+* Decide the extended-thinking token budget for one finding's fix session.
+* Mechanical findings (dead-code removal, autofixable rules) get thinking off;
+* everything else — reasoning findings and any unrecognized category — gets the
+* bounded cap (the safe default: never spend more than the cap, never starve a
+* finding that might need reasoning). A configured `thinkingBudget` overrides
+* the policy outright, with 0 meaning thinking off.
+*/
+function thinkingBudgetFor(finding, config) {
+	if (config?.thinkingBudget !== void 0) return config.thinkingBudget;
+	return isMechanical(finding) ? THINKING_OFF : THINKING_BUDGET_CAP;
+}
+/**
+* Budget for a whole work unit (one file's findings). Takes the most-conservative
+* (largest) per-finding budget so a reasoning finding is never starved of thinking
+* just because it shares the file with a mechanical one. An empty unit and any
+* unrecognized category fall back to the cap. A configured budget overrides all.
+*/
+function thinkingBudgetForUnit(findings, config) {
+	if (config?.thinkingBudget !== void 0) return config.thinkingBudget;
+	if (findings.length === 0) return THINKING_BUDGET_CAP;
+	return Math.max(...findings.map((finding) => thinkingBudgetFor(finding)));
+}
+/**
+* Delivery to the `claude -p` session boundary: the env overlay that pins the
+* session's extended-thinking budget. Spread onto the child process env.
+*/
+function thinkingEnv(findings, config) {
+	return { MAX_THINKING_TOKENS: String(thinkingBudgetForUnit(findings, config)) };
+}
+
 //#endregion
 //#region src/fixing/worker-sandbox.ts
+/** Prefix every tend sandbox worktree directory carries, so we can recognize our own. */
+const WORKTREE_PREFIX = "tend-worker-";
 var SandboxSetupError = class extends Error {
 	constructor(message) {
 		super(message);
 		this.name = "SandboxSetupError";
 	}
 };
+/**
+* Files whose presence in a unit means the install graph may have changed, so a sandbox
+* must reinstall rather than reuse the main checkout's node_modules. Matched by basename,
+* so nested-package manifests (e.g. `packages/app/package.json`) count too.
+*/
+const DEPENDENCY_MANIFESTS = new Set([
+	"package.json",
+	"package-lock.json",
+	"npm-shrinkwrap.json",
+	"pnpm-lock.yaml",
+	"pnpm-workspace.yaml",
+	"yarn.lock",
+	"bun.lockb",
+	"bun.lock"
+]);
+/**
+* The reuse decision (Fix 4): a sandbox can reuse the main repo's installed deps unless
+* the unit edits a dependency manifest, in which case it must reinstall. Package-manager-
+* agnostic — driven entirely by which files the unit may change.
+*/
+function shouldReinstall(unit) {
+	return allowedPatchFiles(unit).some((file) => DEPENDENCY_MANIFESTS.has(basename(normalizeRel(file))));
+}
 const cleanExcludes = [
 	"node_modules",
 	"node_modules/**",
@@ -1003,7 +1093,7 @@ function installArgs(pm) {
 	}
 }
 var GitWorkerSandbox = class {
-	prepared = false;
+	preparedMode = "none";
 	constructor(cwd$1, deps) {
 		this.cwd = cwd$1;
 		this.deps = deps;
@@ -1021,8 +1111,37 @@ var GitWorkerSandbox = class {
 			...cleanExcludes.flatMap((pattern) => ["-e", pattern])
 		]);
 	}
-	async prepare() {
-		if (this.prepared || this.deps.prepareDependencies === false) return;
+	async prepare(unit) {
+		if (this.deps.prepareDependencies === false) return;
+		if (shouldReinstall(unit)) {
+			if (this.preparedMode === "install") return;
+			this.removeNodeModulesLink();
+			await this.install();
+			this.preparedMode = "install";
+			return;
+		}
+		if (this.preparedMode !== "none") return;
+		if (this.tryReuseMainDeps()) {
+			this.preparedMode = "reuse";
+			return;
+		}
+		await this.install();
+		this.preparedMode = "install";
+	}
+	/** Symlink the main repo's node_modules into this worktree. Returns false if main has none. */
+	tryReuseMainDeps() {
+		const mainModules = join(this.deps.mainRoot, "node_modules");
+		if (!existsSync(mainModules)) return false;
+		const link = join(this.cwd, "node_modules");
+		if (existsSync(link)) return true;
+		symlinkSync(mainModules, link, "junction");
+		return true;
+	}
+	removeNodeModulesLink() {
+		const link = join(this.cwd, "node_modules");
+		rmSync(link, { force: true });
+	}
+	async install() {
 		const args = installArgs(this.deps.packageManager);
 		const result = await this.deps.exec(this.deps.packageManager, args, {
 			cwd: this.cwd,
@@ -1030,7 +1149,6 @@ var GitWorkerSandbox = class {
 			timeout: 10 * 6e4
 		});
 		if ((result.exitCode ?? 1) !== 0) throw new SandboxSetupError(`sandbox dependency install failed: ${result.stderr || result.stdout || `exit ${result.exitCode ?? 1}`}`);
-		this.prepared = true;
 	}
 	async collectPatch(unit) {
 		const git = createGit(this.cwd);
@@ -1101,14 +1219,14 @@ var WorkerSandboxPool = class {
 	idle = [];
 	sandboxes = new Set();
 	counter = 0;
-	disposed = false;
+	disposing;
 	exec;
 	constructor(deps) {
 		this.deps = deps;
 		this.queue = new PQueue({ concurrency: deps.maxSandboxes });
 		this.exec = deps.exec ?? execa;
 	}
-	async withSandbox(run) {
+	async withSandbox(unit, run) {
 		return this.queue.add(async () => {
 			let sandbox;
 			try {
@@ -1118,7 +1236,7 @@ var WorkerSandboxPool = class {
 			}
 			try {
 				await sandbox.reset();
-				await sandbox.prepare();
+				await sandbox.prepare(unit);
 			} catch (error) {
 				this.idle.push(sandbox);
 				throw error instanceof SandboxSetupError ? error : new SandboxSetupError(error instanceof Error ? error.message : String(error));
@@ -1160,9 +1278,16 @@ var WorkerSandboxPool = class {
 			return { ok: true };
 		});
 	}
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
+	/**
+	* Tear down every sandbox (remove worktrees). Idempotent and concurrency-safe: the SIGINT
+	* handler and the run's finally path may both call this at once, so all callers share — and
+	* await — the same in-flight teardown. Without this, a second caller returning early would let
+	* the signal handler's process.exit() race ahead and leak a worktree.
+	*/
+	dispose() {
+		return this.disposing ??= this.runDispose();
+	}
+	async runDispose() {
 		await this.queue.onIdle();
 		await Promise.all([...this.sandboxes].map((sandbox) => sandbox.dispose()));
 		this.idle.length = 0;
@@ -1173,7 +1298,7 @@ var WorkerSandboxPool = class {
 		if (existing) return existing;
 		const parent = this.deps.tempRoot ?? tmpdir();
 		mkdirSync(parent, { recursive: true });
-		const path = `${parent}/tend-worker-${process.pid}-${this.counter++}`;
+		const path = `${parent}/${WORKTREE_PREFIX}${process.pid}-${this.counter++}`;
 		const mainGit = createGit(this.deps.mainRoot);
 		await mainGit.raw([
 			"worktree",
@@ -1190,11 +1315,168 @@ var WorkerSandboxPool = class {
 		return sandbox;
 	}
 };
+/** Paths of every worktree currently registered for the repo at `mainRoot`. */
+async function registeredWorktrees(mainRoot) {
+	const raw = await createGit(mainRoot).raw([
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	return raw.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("worktree ")).map((line) => line.slice(9).trim());
+}
+/**
+* Self-heal after a crashed or cancelled prior run: force-remove any leftover `tend-worker-*`
+* worktrees still registered for `mainRoot`, then `git worktree prune` to clear stale admin
+* records. Best-effort and idempotent — never throws (a run must start even if cleanup hiccups).
+*/
+async function pruneStaleWorktrees(mainRoot) {
+	const git = createGit(mainRoot);
+	try {
+		for (const path of await registeredWorktrees(mainRoot)) {
+			if (!basename(path).startsWith(WORKTREE_PREFIX)) continue;
+			try {
+				await git.raw([
+					"worktree",
+					"remove",
+					"--force",
+					path
+				]);
+			} catch {}
+			rmSync(path, {
+				recursive: true,
+				force: true
+			});
+		}
+		await git.raw(["worktree", "prune"]);
+	} catch {}
+}
 function mapOwnerRoot(mainRoot, mainOwnerRoot, sandboxRoot) {
 	const rel = normalizeRel(relative(mainRoot, mainOwnerRoot));
 	return rel === "" ? sandboxRoot : `${sandboxRoot}/${rel}`;
 }
 
+//#endregion
+//#region src/process/signals.ts
+const SIGNALS = ["SIGINT", "SIGTERM"];
+/**
+* Run `handler` once when the process is asked to terminate (Ctrl-C / SIGTERM), so a run can
+* tear down its sandboxes before exiting instead of leaking worktrees. Each signal fires the
+* handler at most once (the run then exits). Returns an unregister function for the normal
+* completion path. The emitter is injectable so tests don't have to raise real signals.
+*/
+function onTerminationSignals(handler, emitter = process) {
+	const wrappers = new Map();
+	for (const signal of SIGNALS) {
+		const wrapper = () => handler(signal);
+		emitter.once(signal, wrapper);
+		wrappers.set(signal, wrapper);
+	}
+	return () => {
+		for (const [signal, wrapper] of wrappers) emitter.removeListener(signal, wrapper);
+	};
+}
+
+//#endregion
+//#region src/session/stream-activity.ts
+/** A short human label for one stream event's activity, or null for non-activity events. */
+function activityLabels(event) {
+	if (event.type !== "assistant") return [];
+	const labels = [];
+	for (const block of event.message?.content ?? []) if (block.type === "tool_use" && typeof block.name === "string") {
+		const path = block.input?.["file_path"];
+		labels.push(typeof path === "string" ? `${block.name} ${path}` : block.name);
+	} else if (block.type === "text") labels.push("thinking");
+	return labels;
+}
+/**
+* Incremental consumer for Claude Code `--output-format stream-json` stdout. Buffers
+* partial lines across chunks and reports a short activity label per assistant event
+* (tool uses with their target file, text turns as "thinking"). Malformed or truncated
+* lines are skipped — this is progress decoration only and must never throw; the
+* authoritative outcome is still judged from the disk after the session ends.
+*/
+function createStreamActivityScanner(onActivity) {
+	let buffer = "";
+	let last;
+	const consume = (line) => {
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		let event;
+		try {
+			event = JSON.parse(trimmed);
+		} catch {
+			return;
+		}
+		for (const label of activityLabels(event)) {
+			if (label === last) continue;
+			last = label;
+			onActivity(label);
+		}
+	};
+	return {
+		push(chunk) {
+			buffer += chunk;
+			const lines$1 = buffer.split("\n");
+			buffer = lines$1.pop() ?? "";
+			for (const line of lines$1) consume(line);
+		},
+		end() {
+			consume(buffer);
+			buffer = "";
+		}
+	};
+}
+
+//#endregion
+//#region src/fixing/typecheck-cache.ts
+const TSC_TIMEOUT_MS$1 = 5 * 6e4;
+/**
+* tsc arguments for an incremental, cached `--noEmit` typecheck. **Only** caching/speed
+* flags are added (`--incremental`, `--tsBuildInfoFile`) — never a correctness or
+* tsconfig-semantic flag (`--skipLibCheck`, `--strict`, `--target`, …). The owning
+* package's tsconfig is still resolved from the cwd, so its semantics are unchanged.
+*/
+function incrementalTscArgs(cacheFile) {
+	return [
+		"tsc",
+		"--noEmit",
+		"--incremental",
+		"--tsBuildInfoFile",
+		cacheFile
+	];
+}
+/**
+* A stable, tend-owned build-info cache path for the package rooted at `ownerRoot`.
+*
+* The caller roots `cacheDir` at the **main** repo's `.tend/cache` — outside any sandbox
+* worktree — so the file survives `reset()`/`git clean` between iterations and is reused.
+* The filename encodes the owner's repo-relative path (slug + hash) so monorepo packages
+* get distinct caches that don't collide.
+*/
+function tscCacheFile(cacheDir, mainRoot, ownerRoot) {
+	const rel = relative(mainRoot, ownerRoot).replaceAll("\\", "/") || ".";
+	const slug = rel === "." ? "root" : rel.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "pkg";
+	const hash = createHash("sha1").update(rel).digest("hex").slice(0, 8);
+	return join(cacheDir, `${slug}-${hash}.tsbuildinfo`);
+}
+/**
+* Run `tsc --noEmit` with an incremental cache. Ensures the cache directory exists, then
+* runs tsc. tsc itself tolerates a missing or corrupt build-info file (it rebuilds from
+* scratch and overwrites), so correctness is unaffected — only cold runs are slower.
+*/
+async function runIncrementalTsc(deps) {
+	mkdirSync(dirname(deps.cacheFile), { recursive: true });
+	const r = await deps.exec("npx", incrementalTscArgs(deps.cacheFile), {
+		cwd: deps.cwd,
+		reject: false,
+		timeout: deps.timeoutMs ?? TSC_TIMEOUT_MS$1
+	});
+	return {
+		exitCode: r.exitCode ?? 1,
+		output: `${r.stdout ?? ""}\n${r.stderr ?? ""}`
+	};
+}
+
 //#endregion
 //#region src/output/env.ts
 /** Truthy in the env-var sense: present and not an explicit off value. */
@@ -1317,6 +1599,7 @@ var LiveReporter = class extends BaseReporter {
 	currentConcurrency;
 	rules = new Map();
 	stages = new Map();
+	stageDetails = new Map();
 	scannerStates = new Map();
 	currentScanLoop;
 	header;
@@ -1368,6 +1651,7 @@ var LiveReporter = class extends BaseReporter {
 				this.currentConcurrency = event.concurrency;
 				this.rules.clear();
 				this.stages.clear();
+				this.stageDetails.clear();
 				this.labelWidth = Math.max(0, ...event.files.map((f) => basename(f).length));
 				this.phases.push({
 					kind: "fix",
@@ -1388,6 +1672,8 @@ var LiveReporter = class extends BaseReporter {
 			case "file-stage":
 				this.currentFile = event.file;
 				this.stages.set(event.file, event.stage);
+				if (event.detail) this.stageDetails.set(event.file, event.detail);
+				else this.stageDetails.delete(event.file);
 				this.refreshHeader();
 				break;
 			case "file-result":
@@ -1541,7 +1827,11 @@ var LiveReporter = class extends BaseReporter {
 	fileTitle(file) {
 		const rule = this.rules.get(file);
 		const stage = this.stages.get(file);
-		const detail = [rule, stage ? fixStageLabel(stage) : void 0].filter(Boolean).join(" · ");
+		const detail = [
+			rule,
+			stage ? fixStageLabel(stage) : void 0,
+			this.stageDetails.get(file)
+		].filter(Boolean).join(" · ");
 		const suffix = detail ? `  ${this.theme.dim(detail)}` : "";
 		return `${this.fileLabel(file)}${suffix}`;
 	}
@@ -1616,6 +1906,7 @@ const cwd = process.cwd();
 const TEND_DIR = join(cwd, ".tend");
 const SNAPSHOT_PATH = join(TEND_DIR, "snapshot.json");
 const REPORT_PATH = join(TEND_DIR, "report.json");
+const TEND_CACHE_DIR = join(TEND_DIR, "cache");
 const CLAUDE_TIMEOUT_MS = 10 * 6e4;
 const BUILD_TIMEOUT_MS = 5 * 6e4;
 const TSC_TIMEOUT_MS = 5 * 6e4;
@@ -1681,7 +1972,7 @@ async function makeProductionFixUnit(config, baselineTargets, ownerRoot = cwd, b
 		const repoRoot = sandbox?.cwd ?? cwd;
 		const gateOwnerRoot = sandbox ? mapOwnerRoot(cwd, ownerRoot, sandbox.cwd) : ownerRoot;
 		const session = new ClaudeSession({ spawn: async (req) => {
-			const r = await execa("claude", [
+			const child = execa("claude", [
 				"-p",
 				req.prompt,
 				"--model",
@@ -1695,8 +1986,16 @@ async function makeProductionFixUnit(config, baselineTargets, ownerRoot = cwd, b
 			], {
 				cwd: repoRoot,
 				reject: false,
-				timeout: CLAUDE_TIMEOUT_MS
+				timeout: CLAUDE_TIMEOUT_MS,
+				env: {
+					...process.env,
+					...thinkingEnv(req.findings, config)
+				}
 			});
+			const scanner = createStreamActivityScanner((activity) => req.onActivity?.(activity));
+			child.stdout?.on("data", (chunk) => scanner.push(chunk.toString()));
+			child.stdout?.on("end", () => scanner.end());
+			const r = await child;
 			const exitCode = r.exitCode ?? (r.timedOut ? 143 : r.failed ? 1 : 0);
 			return {
 				stdout: typeof r.stdout === "string" ? r.stdout : "",
@@ -1706,17 +2005,12 @@ async function makeProductionFixUnit(config, baselineTargets, ownerRoot = cwd, b
 		return {
 			cwd: repoRoot,
 			typescript,
-			runTsc: async () => {
-				const r = await execa("npx", ["tsc", "--noEmit"], {
-					cwd: gateOwnerRoot,
-					reject: false,
-					timeout: TSC_TIMEOUT_MS
-				});
-				return {
-					exitCode: r.exitCode ?? 1,
-					output: `${r.stdout}\n${r.stderr}`
-				};
-			},
+			runTsc: async () => runIncrementalTsc({
+				exec: execa,
+				cwd: gateOwnerRoot,
+				cacheFile: tscCacheFile(TEND_CACHE_DIR, cwd, ownerRoot),
+				timeoutMs: TSC_TIMEOUT_MS
+			}),
 			runBuild: buildArgs ? async () => {
 				const r = await execa(pm, buildArgs, {
 					cwd: gateOwnerRoot,
@@ -1755,7 +2049,7 @@ async function makeProductionFixUnit(config, baselineTargets, ownerRoot = cwd, b
 	const fixUnit = async (unit, loop) => {
 		if (!sandboxPool) return buildFixUnit()(unit, loop);
 		try {
-			return await sandboxPool.withSandbox(async (sandbox) => {
+			return await sandboxPool.withSandbox(unit, async (sandbox) => {
 				const outcome = await buildFixUnit(sandbox)(unit, loop);
 				if (!outcome.kept) return outcome;
 				bus?.emit({
@@ -1914,6 +2208,7 @@ async function runRun(opts) {
 	const scopeNote = describeScopeNote(opts.all, paths, scope);
 	reporter.note(`${scopeNote} · ${plural(available.length, "scanner")}`);
 	if (runner && baselineTargets.length > 0) reporter.note(`baseline: ${runner} related ${describeScopeNote(opts.all, paths, scope)} (one-time)`);
+	await pruneStaleWorktrees(snapshot.repoRoot());
 	const sandboxPool = new WorkerSandboxPool({
 		mainRoot: snapshot.repoRoot(),
 		snapshotSha: snapshot.commitSha(),
@@ -1924,6 +2219,9 @@ async function runRun(opts) {
 		typescript,
 		runner
 	}, sandboxPool);
+	const stopSignals = onTerminationSignals((signal) => {
+		sandboxPool.dispose().finally(() => process.exit(signal === "SIGINT" ? 130 : 143));
+	});
 	const start = Date.now();
 	const drawing = reporter.run();
 	let result;
@@ -1948,6 +2246,7 @@ async function runRun(opts) {
 		finalIntegrationResult = await finalIntegration();
 		if (!finalIntegrationResult.ok) result.exitStatus = 1;
 	} finally {
+		stopSignals();
 		await sandboxPool.dispose();
 		reporter.close();
 	}

package/dist/{config-DPlVYfKX.js → config-BPLYzcro.js}

@@ -1350,10 +1350,11 @@ async function currentFiles(root) {
 * so the on-disk record is a 40-char id rather than a copy of every file.
 */
 var Snapshot = class Snapshot {
-	constructor(cwd, root, sha) {
+	constructor(cwd, root, sha, indexTree = null) {
 		this.cwd = cwd;
 		this.root = root;
 		this.sha = sha;
+		this.indexTree = indexTree;
 	}
 	static async capture(_git, cwd) {
 		const git = createGit(cwd);
@@ -1362,6 +1363,12 @@ var Snapshot = class Snapshot {
 		ensureTendIgnored(gitDir);
 		const rg = createGit(root);
 		const tree = await writeWorkingTree(root);
+		let indexTree = null;
+		try {
+			indexTree = (await rg.raw(["write-tree"])).trim();
+		} catch {
+			indexTree = null;
+		}
 		let parent = null;
 		try {
 			parent = (await rg.revparse(["HEAD"])).trim();
@@ -1387,14 +1394,15 @@ var Snapshot = class Snapshot {
 			SNAP_REF,
 			sha
 		]);
-		return new Snapshot(cwd, root, sha);
+		return new Snapshot(cwd, root, sha, indexTree);
 	}
 	/** Serialize to a tiny object for `.tend/snapshot.json` (powers `undo` across invocations). */
 	toJSON() {
 		return {
 			cwd: this.cwd,
 			root: this.root,
-			sha: this.sha
+			sha: this.sha,
+			indexTree: this.indexTree
 		};
 	}
 	commitSha() {
@@ -1404,7 +1412,7 @@ var Snapshot = class Snapshot {
 		return this.root;
 	}
 	static fromJSON(data) {
-		return new Snapshot(data.cwd, data.root, data.sha);
+		return new Snapshot(data.cwd, data.root, data.sha, data.indexTree ?? null);
 	}
 	/** Files whose contents differ from the snapshot, or that are new/deleted since it (sorted). */
 	async changedSince(_git) {
@@ -1446,6 +1454,7 @@ var Snapshot = class Snapshot {
 			this.sha
 		])));
 		for (const rel of await currentFiles(this.root)) if (!inSnapshot.has(rel)) rmSync(join(this.root, rel), { force: true });
+		if (this.indexTree) await rg.raw(["read-tree", this.indexTree]);
 	}
 };
 
@@ -3636,6 +3645,7 @@ const ConfigSchema = z.object({
 	includeTests: z.boolean().default(false),
 	model: z.string().default("sonnet"),
 	effort: z.enum(EFFORT_LEVELS).optional(),
+	thinkingBudget: z.number().int().nonnegative().optional(),
 	fix: FixScopeConfigSchema,
 	tools: z.record(z.string(), ToolConfigSchema).default({})
 });

package/dist/index.d.ts

@@ -236,6 +236,12 @@ type SessionRequest = {
   findings: Finding[];
   /** The fully-rendered prompt for the AI. */
   prompt: string;
+  /**
+   * Live progress hook: called with a short label (e.g. "Edit src/a.ts") as activity
+   * streams from the running session. Decoration only — outcomes are still judged
+   * from the disk after the session ends.
+   */
+  onActivity?: (activity: string) => void;
 };
 type FailureClass = "tool-timeout" | "rate-limit" | "model-tool-failure" | "sandbox-setup-failed" | "patch-conflict" | "unowned-patch" | "final-integration-failed" | "no-edit" | "no-op" | "regression" | "typecheck" | "broke-test" | "suppression" | "needs-lockfile-update";
 /**
@@ -1800,6 +1806,7 @@ declare class Snapshot {
   private readonly cwd;
   private readonly root;
   private readonly sha;
+  private readonly indexTree;
   private constructor();
   static capture(_git: SimpleGit, cwd: string): Promise<Snapshot>;
   /** Serialize to a tiny object for `.tend/snapshot.json` (powers `undo` across invocations). */
@@ -1807,6 +1814,7 @@ declare class Snapshot {
     cwd: string;
     root: string;
     sha: string;
+    indexTree: string | null;
   };
   commitSha(): string;
   repoRoot(): string;
@@ -1814,6 +1822,7 @@ declare class Snapshot {
     cwd: string;
     root: string;
     sha: string;
+    indexTree?: string | null;
   }): Snapshot;
   /** Files whose contents differ from the snapshot, or that are new/deleted since it (sorted). */
   changedSince(_git: SimpleGit): Promise<string[]>;
@@ -1863,6 +1872,8 @@ declare const ConfigSchema: z.ZodObject<{
   model: z.ZodDefault<z.ZodString>;
   /** Reasoning effort for fixes; unset → claude's own default. */
   effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
+  /** Extended-thinking token budget per fix session; unset → per-finding policy decides. */
+  thinkingBudget: z.ZodOptional<z.ZodNumber>;
   /** Report/fix scope policy. Reports stay broad; fixes default away from generated/tooling paths. */
   fix: z.ZodDefault<z.ZodObject<{
     include: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -1909,6 +1920,7 @@ declare const ConfigSchema: z.ZodObject<{
   }>;
   test?: string | undefined;
   effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+  thinkingBudget?: number | undefined;
 }, {
   maxSessions?: number | undefined;
   maxLoops?: number | undefined;
@@ -1918,6 +1930,7 @@ declare const ConfigSchema: z.ZodObject<{
   includeTests?: boolean | undefined;
   model?: string | undefined;
   effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
+  thinkingBudget?: number | undefined;
   fix?: {
     include?: string[] | undefined;
     exclude?: string[] | undefined;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { ClaudeSession, ConfigSchema, EventBus, FindingSchema, FindingStore, REPAIR_STRATEGIES, ReportBuilder, ReportSchema, Snapshot, addUsage, applyCliOverrides, applyRepairPlanToFinding, assertGitRepo, buildProgram, changedFiles, changedVsHead, detectPackageManager, dispatch, filterToChanged, fingerprint, groupRemaining, isAiDispatchStrategy, isAvailable, loadConfig, makeDeterministicFixUnit, makeDeterministicFixer, normalize, orchestrate, planRepair, planWork, planWorkFromRepairs, renderSummary, retryCommand, revertFile, route, runScanner, scopeFindings, showCommand, trackForTool, zeroUsage } from "./config-DPlVYfKX.js";
+import { ClaudeSession, ConfigSchema, EventBus, FindingSchema, FindingStore, REPAIR_STRATEGIES, ReportBuilder, ReportSchema, Snapshot, addUsage, applyCliOverrides, applyRepairPlanToFinding, assertGitRepo, buildProgram, changedFiles, changedVsHead, detectPackageManager, dispatch, filterToChanged, fingerprint, groupRemaining, isAiDispatchStrategy, isAvailable, loadConfig, makeDeterministicFixUnit, makeDeterministicFixer, normalize, orchestrate, planRepair, planWork, planWorkFromRepairs, renderSummary, retryCommand, revertFile, route, runScanner, scopeFindings, showCommand, trackForTool, zeroUsage } from "./config-BPLYzcro.js";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tend-cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Audit a JS/TS repo with established scanners, then fix the findings with parallel AI sessions in a safe scan-fix-rescan loop.",
   "keywords": [
     "lint",

package/prompts/single-file-ai-edit.md

@@ -20,6 +20,14 @@ Only edit these repo-relative files:
 Do not edit any other file. If the correct fix requires another file, leave the
 files unchanged.
 
+## Current file content
+
+The current on-disk content of the editable file(s) follows, so you can edit
+without reading first. Treat it as the source of truth; if it differs from what
+you expect, re-read before editing.
+
+{{fileContents}}
+
 ## Verification targets
 
 The gate will verify these repo-relative files: