headlesscode 1.0.3 → 1.2.1

package/src/rsi/types.ts

@@ -0,0 +1,317 @@
+import type { ChildProcess } from "node:child_process"
+
+export type CandidateStatus = "planned" | "mutating" | "evaluating" | "accepted" | "rejected" | "failed"
+export type MutationKind = "corrective" | "architectural" | "search-policy" | "curriculum" | "model-adaptation"
+export type ParentSelectionPolicy = "champion-specialist-novelty" | "pareto-front" | "all-eligible"
+export type ComputePolicy = "single" | "independent" | "planner-executors" | "critic-retry"
+
+export interface MutationHypothesis {
+	statement: string
+	expectedEffect: string
+	potentialDownside: string
+	evidence?: string
+}
+
+export interface MetricVector {
+	correctness: number
+	reliability: number
+	generalization: number
+	hidden: number
+	efficiency: number
+	latency: number
+	tokenUse: number
+	recovery: number
+	fabricationRate: number
+	complexityPenalty: number
+}
+
+export interface ComplexityMetrics {
+	diffLines: number
+	changedFiles: number
+	newDependencies: number
+	additionalModelCalls: number
+	runtimeOverheadMs: number
+}
+
+export interface ParentSelectionReason {
+	strategy: "champion" | "specialist" | "novelty" | "pareto" | "archive" | "baseline"
+	reason: string
+	metrics?: Partial<MetricVector>
+}
+
+export type ModelRole =
+	| "worker"
+	| "mutation-architect"
+	| "failure-analyst"
+	| "critic"
+	| "adversary"
+	| "reviewer"
+	| "curriculum-designer"
+	| "training-data-curator"
+
+export interface RoleModelConfig {
+	provider: "ollama" | "openrouter" | "command"
+	model: string
+	baseUrl?: string
+	command?: string
+}
+
+export type RsiRoleConfig = Partial<Record<ModelRole, RoleModelConfig>>
+
+export interface TrainingConfig {
+	method: "none" | "lora" | "qlora" | "sft" | "preference"
+	command?: string
+	seed?: number
+	parameters?: Record<string, string | number | boolean>
+}
+
+export interface ModelCandidate {
+	id: string
+	parentModel: string
+	trainingMethod: TrainingConfig["method"]
+	datasetVersion?: string
+	trainingConfig: TrainingConfig
+	artifactPath?: string
+	artifactHash?: string
+	status: "base" | "prepared" | "trained" | "evaluated" | "accepted" | "rejected"
+	createdAt: string
+	provenance?: Record<string, string>
+}
+
+export interface HarnessModelCombination {
+	id: string
+	harnessCandidateId: string
+	modelCandidateId: string
+	status: "planned" | "evaluated" | "accepted" | "rejected"
+	metrics?: MetricVector
+	fitness?: Fitness
+	createdAt: string
+}
+
+export type ResourceClass = "LOCAL_GPU" | "CPU" | "REMOTE_API" | "TRAINING_GPU"
+export type ExperimentJobKind = "mutation" | "evaluation" | "adversarial" | "curriculum" | "training" | "model-evaluation" | "critic"
+export type ExperimentJobStatus = "queued" | "running" | "completed" | "failed" | "cancelled"
+
+export interface ResourceRequirements {
+	class: ResourceClass
+	units: number
+	concurrencyKey?: string
+}
+
+export interface ExperimentJob {
+	id: string
+	kind: ExperimentJobKind
+	status: ExperimentJobStatus
+	resource: ResourceRequirements
+	owner?: string
+	candidateId?: string
+	createdAt: string
+	updatedAt: string
+	attempts: number
+	error?: string
+}
+
+export interface TrajectoryMessage {
+	role: string
+	content?: string
+	tool_calls?: unknown[]
+	tool_call_id?: string
+	name?: string
+}
+
+export interface TrajectoryRecord {
+	id: string
+	task: string
+	environment: { repoRoot: string; baseCommit: string; generation: number }
+	model: { id: string; provider?: string; candidateId?: string }
+	harnessVersion: string
+	promptConfig: Record<string, unknown>
+	messages: TrajectoryMessage[]
+	toolCalls: number
+	outcome: "success" | "failure" | "incomplete"
+	verification: { verified: boolean; regressionPass: boolean; hiddenPass: boolean }
+	failureClassification?: string
+	criticDiagnosis?: string
+	fitnessImpact?: number
+	provenance: { source: string; capturedAt: string; trusted: boolean }
+}
+
+export interface TrajectorySummary {
+	path: string
+	messageCount: number
+	toolCalls: number
+	trusted: boolean
+	outcome: TrajectoryRecord["outcome"]
+	failureClassification?: string
+}
+
+export interface CurriculumTask {
+	id: string
+	task: string
+	difficulty: 1 | 2 | 3 | 4 | 5
+	capability: string
+	groundTruthCommand: string
+	provenance: { sourceCandidateIds: string[]; failureClass: string; generatedAt: string }
+	validated: boolean
+}
+
+export interface RsiConfig {
+	repoRoot: string
+	model: string
+	population: number
+	generations: number
+	maxConcurrent: number
+	mutationTask: string
+	evalCommands: string[]
+	hiddenEvalCommands: string[]
+	archiveDir: string
+	worktreeDir: string
+	baseRef: string
+	seed: string
+	dryRun: boolean
+	keepWorktrees: boolean
+	maxIterations: number
+	protectedPaths: string[]
+	commandTimeoutMs: number
+	parentSelectionPolicy?: ParentSelectionPolicy
+	eliteCount?: number
+	specialistCount?: number
+	noveltyRate?: number
+	mutationKind?: MutationKind
+	hypothesis?: MutationHypothesis
+	computePolicy?: ComputePolicy
+	modelCandidateId?: string
+	modelCandidates?: ModelCandidate[]
+	roles?: RsiRoleConfig
+	trajectoryDir?: string
+	curriculumDir?: string
+	resumeRunId?: string
+}
+
+export interface CandidateRecord {
+	id: string
+	generation: number
+	parent: string
+	branch: string
+	worktree: string
+	baseCommit: string
+	status: CandidateStatus
+	model: string
+	mutation: string
+	createdAt: string
+	updatedAt: string
+	commits: string[]
+	changedFiles: string[]
+	protectedPathViolations: string[]
+	mutationKind?: MutationKind
+	hypothesis?: MutationHypothesis
+	parentSelection?: ParentSelectionReason
+	parentCommit?: string
+	modelCandidateId?: string
+	combinationId?: string
+	failure?: string
+	result?: TrialResult
+	fitness?: Fitness
+	trajectory?: TrajectorySummary
+}
+
+export interface TrialResult {
+	ok: boolean
+	command: string
+	exitCode: number | null
+	durationMs: number
+	stdout: string
+	stderr: string
+	timedOut?: boolean
+}
+
+export interface EvaluationSummary {
+	regression: TrialResult
+	visible: TrialResult[]
+	hidden: TrialResult[]
+	completed: boolean
+	crashed: boolean
+	protectedPathViolation: boolean
+	changedFiles: string[]
+	committed?: boolean
+	complexity?: ComplexityMetrics
+	failureClassification?: string
+}
+
+export interface HardGates {
+	regressionPass: boolean
+	visibleEvalPass: boolean
+	hiddenEvalPass: boolean
+	noProtectedPathViolation: boolean
+	completed: boolean
+	noCrash: boolean
+	committed: boolean
+}
+
+export interface Fitness {
+	score: number
+	components: {
+	regression: number
+	visible: number
+		hidden: number
+		efficiency: number
+		recovery: number
+	}
+	metrics: MetricVector
+	complexity: ComplexityMetrics
+	paretoRank?: number
+	hardGates: HardGates
+	reason: string
+}
+
+export interface RsiRunRecord {
+	runId: string
+	startedAt: string
+	finishedAt?: string
+	baseline?: TrialResult
+	model: string
+	baseRef: string
+	baseCommit: string
+	generations: number
+	selected?: string
+	selectedCandidates?: string[]
+	parentSelectionPolicy?: ParentSelectionPolicy
+	parentChoices?: Record<string, ParentSelectionReason>
+	modelCandidates?: ModelCandidate[]
+	combinations?: HarnessModelCombination[]
+	jobs?: ExperimentJob[]
+	trajectoryRefs?: string[]
+	curriculumTasks?: CurriculumTask[]
+	candidates: CandidateRecord[]
+	reports: string[]
+}
+
+export interface RsiArchive {
+	schemaVersion: 2
+	updatedAt: string
+	runs: RsiRunRecord[]
+	activeRuns: RsiRunRecord[]
+	candidates: CandidateRecord[]
+	modelCandidates: ModelCandidate[]
+	combinations: HarnessModelCombination[]
+	jobs: ExperimentJob[]
+	trajectoryRefs: string[]
+	curriculumTasks: CurriculumTask[]
+}
+
+export interface CommandRunner {
+	(command: string, cwd: string, timeoutMs: number, env?: NodeJS.ProcessEnv): Promise<TrialResult>
+}
+
+export interface MutationRunner {
+	(candidate: CandidateRecord, config: RsiConfig): Promise<{ ok: boolean; result?: TrialResult; error?: string }>
+}
+
+export interface RsiHooks {
+	runCommand?: CommandRunner
+	runMutation?: MutationRunner
+	now?: () => string
+	log?: (line: string) => void
+}
+
+export type SpawnedProcess = ChildProcess

package/src/rsi/workspace.ts

@@ -0,0 +1,96 @@
+import { execFile as execFileCallback } from "node:child_process"
+import * as fs from "node:fs/promises"
+import * as path from "node:path"
+import { promisify } from "node:util"
+import { modelCombinationId } from "./models.js"
+import type { CandidateRecord, RsiConfig } from "./types.js"
+import type { ParentChoice } from "./selection.js"
+
+const execFile = promisify(execFileCallback)
+
+export function candidateId(generation: number, index: number, seed: string): string {
+	const cleanSeed = seed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "run"
+	return `g${generation}-c${String(index + 1).padStart(2, "0")}-${cleanSeed.slice(0, 20)}`
+}
+
+export function candidateBranch(id: string): string {
+	return `rsi/${id}`
+}
+
+export function candidateWorktree(config: RsiConfig, id: string): string {
+	return path.join(config.worktreeDir, id)
+}
+
+export async function gitOutput(repoRoot: string, args: string[]): Promise<string> {
+	const result = await execFile("git", args, { cwd: repoRoot, maxBuffer: 4 * 1024 * 1024 })
+	return result.stdout.trim()
+}
+
+export async function resolveBaseCommit(config: RsiConfig): Promise<string> {
+	return gitOutput(config.repoRoot, ["rev-parse", `${config.baseRef}^{commit}`])
+}
+
+export function newCandidate(
+	config: RsiConfig,
+	generation: number,
+	index: number,
+	baseCommit: string,
+	now: string,
+	parentChoice?: ParentChoice,
+): CandidateRecord {
+	const id = candidateId(generation, index, config.seed)
+	const modelCandidateId = config.modelCandidateId ?? "model-base"
+	return {
+		id,
+		generation,
+		parent: parentChoice?.candidateId ?? (generation === 0 ? "baseline" : "champion"),
+		branch: candidateBranch(id),
+		worktree: candidateWorktree(config, id),
+		baseCommit,
+		status: "planned",
+		model: config.model,
+		mutation: config.mutationTask,
+		createdAt: now,
+		updatedAt: now,
+		commits: [],
+		changedFiles: [],
+		protectedPathViolations: [],
+		mutationKind: config.mutationKind ?? "corrective",
+		hypothesis: config.hypothesis,
+		parentSelection: parentChoice?.reason ?? (generation === 0 ? { strategy: "baseline", reason: "initial base ref" } : undefined),
+		parentCommit: parentChoice?.baseCommit ?? baseCommit,
+		modelCandidateId,
+		combinationId: modelCombinationId(id, modelCandidateId),
+	}
+}
+
+export async function createCandidateWorktree(config: RsiConfig, candidate: CandidateRecord): Promise<void> {
+	await fs.mkdir(config.worktreeDir, { recursive: true })
+	await execFile("git", ["worktree", "add", "-b", candidate.branch, candidate.worktree, candidate.baseCommit], {
+		cwd: config.repoRoot,
+		maxBuffer: 4 * 1024 * 1024,
+	})
+}
+
+export async function removeCandidateWorktree(config: RsiConfig, candidate: CandidateRecord): Promise<void> {
+	await execFile("git", ["worktree", "remove", "--force", candidate.worktree], {
+		cwd: config.repoRoot,
+		maxBuffer: 4 * 1024 * 1024,
+	})
+}
+
+export async function changedFiles(repoRoot: string, baseCommit: string): Promise<string[]> {
+	const output = await gitOutput(repoRoot, ["diff", "--name-only", `${baseCommit}...HEAD`])
+	const status = await gitOutput(repoRoot, ["status", "--short"])
+	const files = new Set(output.split("\n").map((file) => file.trim()).filter(Boolean))
+	for (const line of status.split("\n")) {
+		const file = line.slice(3).trim()
+		if (file) files.add(file)
+	}
+	return [...files].sort()
+}
+
+export async function candidateCommits(repoRoot: string, baseCommit: string): Promise<string[]> {
+	const output = await gitOutput(repoRoot, ["log", "--format=%H", `${baseCommit}..HEAD`])
+	return output.split("\n").map((commit) => commit.trim()).filter(Boolean)
+}

package/src/tools/executor.ts

@@ -190,6 +190,8 @@ export interface ToolExecutorOptions {
 	permissions?: PermissionsConfig
 	/** See ToolContext.guardLargeOverwrites (types.ts) for the full writeup. */
 	guardLargeOverwrites?: boolean
+	/** See ToolContext.disableReadFileCache (types.ts) for the full writeup. */
+	disableReadFileCache?: boolean
 	/**
 	 * Live worker monitoring: fired at the same lifecycle points where the
 	 * `.harness.needs-decision` marker is written/cleared, so the session can
@@ -359,6 +361,7 @@ export class ToolExecutor {
 				workspaceRoot: this.workspaceRoot,
 				permissions: this.permissions,
 				guardLargeOverwrites: this.options.guardLargeOverwrites,
+				disableReadFileCache: this.options.disableReadFileCache,
 				decisionTimeoutMs: this.options.decisionTimeoutMs,
 				decisionPollIntervalMs: this.options.decisionPollIntervalMs,
 				pauseBudgetClock: this.pauseBudgetClock,
@@ -799,7 +802,32 @@ function readFileHandler(
 		// cached hash can be reused without re-reading the file; any mismatch
 		// (including a same-length rewrite, which changes mtime) falls back to
 		// a full read + sha256 below.
+		//
+		// 2026-09-02: real, confirmed, live-observed failure mode of this
+		// short-circuit against a local model -- ctx.disableReadFileCache
+		// skips both cache-hit checks in this function entirely, always
+		// serving real content. A session's edit_file call failed ("no
+		// match found"), the error told it to re-read and retry, it DID
+		// call read_file again exactly as instructed, and got back
+		// "[cache] this file is unchanged... re-read the earlier tool
+		// result" instead of the actual content -- correct per this
+		// mechanism's own design (the safety valve is "the SECOND
+		// consecutive identical call serves real content again"), but the
+		// model never made that second call: it read the cache-hit message
+		// as "you already have what you need", gave up, and called
+		// attempt_completion claiming the endpoint worked -- a genuine
+		// fabrication directly caused by this response, not a model
+		// hallucination from nothing. This short-circuit's own rationale
+		// (avoid paying full token cost for content the conversation
+		// already has) is a real concern for a REMOTE model's per-token API
+		// bill; re-serving a few hundred lines of file content costs a
+		// local session near-nothing (it's prefill, not generation, so it
+		// barely affects wall-clock time either) against a GPU with no
+		// per-token price. Cheap insurance against a much more expensive
+		// failure mode locally; the cloud sessions this genuinely saves
+		// money for are unaffected (disableReadFileCache stays unset there).
 		if (
+			!ctx.disableReadFileCache &&
 			cache !== undefined &&
 			!cache.toldUnchanged &&
 			cache.size === stat.size &&
@@ -818,8 +846,9 @@ function readFileHandler(
 
 		// Cache-check the CURRENT on-disk content (never "no write tool was
 		// called"): identical args + identical hash => byte-identical output.
+		// See the disableReadFileCache comment on the check above.
 		const currentHash = hashFileContent(content)
-		if (cache !== undefined && cache.hash === currentHash && !cache.toldUnchanged) {
+		if (!ctx.disableReadFileCache && cache !== undefined && cache.hash === currentHash && !cache.toldUnchanged) {
 			cache.toldUnchanged = true
 			return ok(READ_FILE_CACHE_HIT_MESSAGE)
 		}
@@ -1565,9 +1594,48 @@ function executeCommandHandler(args: Record<string, unknown>, ctx: ToolContext):
 
 	return (async () => {
 		let cwd = ctx.workspaceRoot
-		if (args.cwd != null && args.cwd !== "") {
+		// 2026-09-02: real, confirmed, fully deterministic bug -- a local
+		// LoRA backend's tool-call parser was found sending the literal
+		// 4-character STRING "null" (or "None") for an unset optional
+		// `cwd`, not a real absent/null value. `args.cwd != null` is only
+		// false for the JS primitive null -- a non-empty string "null"
+		// sails through this check as if it were a real requested cwd,
+		// resolving to "<workspaceRoot>/null", which (almost) never
+		// exists. That was fixed at the source (the LoRA server's own
+		// parser), but defend here too: any backend/model can make the
+		// same JSON-serialization slip, and treating the literal text
+		// null/None the same as a real null is cheap and unambiguous --
+		// no real directory is ever named exactly "null" or "None".
+		const isNullish = args.cwd == null || args.cwd === "" || args.cwd === "null" || args.cwd === "None"
+		if (!isNullish) {
 			const cwdArg = requireString(args, "cwd")
 			cwd = safeTarget(ctx, cwdArg)
+			// Validate BEFORE spawning rather than let a bad cwd reach
+			// spawn(): Node's child_process misattributes a chdir()
+			// failure (nonexistent cwd) to the SHELL itself -- "spawn
+			// /bin/bash ENOENT" -- with no mention of cwd anywhere in the
+			// error, which is exactly the "infrastructure spawn failure"
+			// pattern several ground-truth eval runs hit today (verified
+			// directly: spawning with a nonexistent cwd reproduces that
+			// precise error string/code/path). That misattribution isn't
+			// specific to the null-string bug above -- ANY nonexistent
+			// cwd the model supplies (a stale/hallucinated path) hits it
+			// the same way. Checking here turns a misleading spawn crash
+			// into a clear, actionable, model-facing error instead, and
+			// correctly counts it as a real mistake (it's the model's
+			// bad path, not infrastructure).
+			let cwdStat: fs.Stats | undefined
+			try {
+				cwdStat = fs.statSync(cwd)
+			} catch {
+				cwdStat = undefined
+			}
+			if (cwdStat === undefined || !cwdStat.isDirectory()) {
+				const rel = path.relative(ctx.workspaceRoot, cwd).toPosix() || path.basename(cwd)
+				return err(
+					`execute_command: cwd '${rel}' does not exist in this workspace.\n\nRecovery suggestions:\n1. Use list_files to confirm the real directory structure before setting cwd\n2. Omit cwd (or pass null) to run in the workspace root\n3. If you meant a path from a different task/workspace, it doesn't exist here`,
+				)
+			}
 		}
 
 		// Permissions gate (command allow/deny + dangerous substitution +
@@ -1889,7 +1957,15 @@ function listFilesHandler(
 		const key = `${target} ${recursive}`
 		const entry = calls?.get(key)
 
-		if (calls !== undefined && generation !== undefined && entry !== undefined && entry.generation === generation) {
+		// See readFileHandler's disableReadFileCache comment for the full
+		// rationale (same short-circuit shape, same local-backend risk).
+		if (
+			!ctx.disableReadFileCache &&
+			calls !== undefined &&
+			generation !== undefined &&
+			entry !== undefined &&
+			entry.generation === generation
+		) {
 			if (!entry.toldUnchanged) {
 				entry.toldUnchanged = true
 				return ok(