headlesscode 1.2.1 → 1.3.0

package/src/rsi/types.ts

@@ -3,7 +3,21 @@ 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 type ComputePolicy = "single" | "independent" | "adaptive-independent" | "planner-executors" | "critic-retry"
+
+export interface AdaptiveSearchDecision {
+	generation: number
+	decision: "continue" | "stop"
+	reason: "mixed-evidence" | "consistent-evidence" | "trajectory-cap" | "iteration-cap" | "runtime-cap" | "generation-cap" | "insufficient-results"
+	candidateIds: string[]
+	evidence: Array<{ candidateId: string; status: CandidateStatus; visiblePassRate?: number }>
+	allocatedTrajectories: number
+	remainingTrajectories: number
+	allocatedIterations: number
+	remainingIterations: number
+	elapsedMs: number
+	decidedAt: string
+}
 
 export interface MutationHypothesis {
 	statement: string
@@ -73,8 +87,30 @@ export interface ModelCandidate {
 	trainingConfig: TrainingConfig
 	artifactPath?: string
 	artifactHash?: string
-	status: "base" | "prepared" | "trained" | "evaluated" | "accepted" | "rejected"
+	status: "base" | "prepared" | "trained" | "evaluated" | "accepted" | "rejected" | "failed" | "partial"
 	createdAt: string
+	eligibleForSelection?: boolean
+	trainingResult?: {
+		status: "completed" | "failed" | "partial"
+		datasetVersion: string
+		datasetSha256: string
+		baseModelSha256: string
+		artifactSha256?: string
+		artifactBytes?: number
+		stepsCompleted: number
+		maxSteps: number
+		error?: string
+	}
+	pairedEvaluation?: {
+		cellSetSha256: string
+		baseResultSha256: string
+		adapterResultSha256?: string
+		baseMetric: number
+		adapterMetric?: number
+		completedCellCount: number
+		expectedCellCount: number
+		seed: number
+	}
 	provenance?: Record<string, string>
 }
 
@@ -151,8 +187,19 @@ export interface CurriculumTask {
 	difficulty: 1 | 2 | 3 | 4 | 5
 	capability: string
 	groundTruthCommand: string
+	fixtureId: string
+	fixtureDescription: string
 	provenance: { sourceCandidateIds: string[]; failureClass: string; generatedAt: string }
 	validated: boolean
+	validation?: {
+		baseCommit: string
+		command: string
+		validatedAt: string
+		replays: Array<{ idempotencyKey: string; ok: boolean; exitCode: number | null; outputSha256?: string; failure?: string }>
+		reproducible: boolean
+		reason: string
+	}
+	promotedAt?: string
 }
 
 export interface RsiConfig {
@@ -162,6 +209,7 @@ export interface RsiConfig {
 	generations: number
 	maxConcurrent: number
 	mutationTask: string
+	regressionCommand: string
 	evalCommands: string[]
 	hiddenEvalCommands: string[]
 	archiveDir: string
@@ -171,6 +219,9 @@ export interface RsiConfig {
 	dryRun: boolean
 	keepWorktrees: boolean
 	maxIterations: number
+	maxTrajectories?: number
+	maxTotalIterations?: number
+	maxRuntimeMs?: number
 	protectedPaths: string[]
 	commandTimeoutMs: number
 	parentSelectionPolicy?: ParentSelectionPolicy
@@ -212,9 +263,21 @@ export interface CandidateRecord {
 	failure?: string
 	result?: TrialResult
 	fitness?: Fitness
+	pairedComparison?: PairedComparison
 	trajectory?: TrajectorySummary
 }
 
+export interface PairedComparison {
+	baselinePasses: number
+	candidatePasses: number
+	trialCount: number
+	baselineDurationMs: number
+	candidateDurationMs: number
+	durationRatio: number
+	improved: boolean
+	reason: string
+}
+
 export interface TrialResult {
 	ok: boolean
 	command: string
@@ -223,6 +286,8 @@ export interface TrialResult {
 	stdout: string
 	stderr: string
 	timedOut?: boolean
+	outputArtifactSha256?: string
+	outputArtifactBytes?: number
 }
 
 export interface EvaluationSummary {
@@ -236,12 +301,15 @@ export interface EvaluationSummary {
 	committed?: boolean
 	complexity?: ComplexityMetrics
 	failureClassification?: string
+	adversarialPass?: boolean
+	adversarialPenalty?: number
 }
 
 export interface HardGates {
 	regressionPass: boolean
 	visibleEvalPass: boolean
 	hiddenEvalPass: boolean
+	adversarialPass: boolean
 	noProtectedPathViolation: boolean
 	completed: boolean
 	noCrash: boolean
@@ -262,6 +330,46 @@ export interface Fitness {
 	paretoRank?: number
 	hardGates: HardGates
 	reason: string
+	adversarialPenalty?: number
+}
+
+export interface AdversarialTestCase {
+	id: string
+	modulePath: string
+	exportName: string
+	args: unknown[]
+	expected: unknown
+	reason: string
+}
+
+export interface AdversarialFinding {
+	severity: "major" | "minor"
+	message: string
+	testId?: string
+}
+
+export interface AdversarialReviewRecord {
+	candidateId: string
+	role: "adversary"
+	provider: RoleModelConfig["provider"]
+	model: string
+	promptVersion: string
+	promptSha256: string
+	promptArtifactSha256: string
+	summary?: string
+	resultSha256?: string
+	resultArtifactSha256?: string
+	errorSha256?: string
+	errorArtifactSha256?: string
+	testArtifactSha256?: string
+	snapshotArtifactSha256?: string
+	createdAt: string
+	status: "passed" | "failed" | "error"
+	findings: AdversarialFinding[]
+	testResults: Array<{ id: string; passed: boolean; outputArtifactSha256?: string; failure?: string }>
+	penaltyPoints: number
+	jobId?: string
+	error?: string
 }
 
 export interface RsiRunRecord {
@@ -269,6 +377,8 @@ export interface RsiRunRecord {
 	startedAt: string
 	finishedAt?: string
 	baseline?: TrialResult
+	baselineEvaluation?: EvaluationSummary
+	baselineFitness?: Fitness
 	model: string
 	baseRef: string
 	baseCommit: string
@@ -281,7 +391,9 @@ export interface RsiRunRecord {
 	combinations?: HarnessModelCombination[]
 	jobs?: ExperimentJob[]
 	trajectoryRefs?: string[]
+	adaptiveSearch?: AdaptiveSearchDecision[]
 	curriculumTasks?: CurriculumTask[]
+	adversarialReviews?: AdversarialReviewRecord[]
 	candidates: CandidateRecord[]
 	reports: string[]
 }
@@ -310,6 +422,7 @@ export interface MutationRunner {
 export interface RsiHooks {
 	runCommand?: CommandRunner
 	runMutation?: MutationRunner
+	runAdversary?: (request: { role: RoleModelConfig; prompt: string }) => Promise<string>
 	now?: () => string
 	log?: (line: string) => void
 }

package/src/rsi/worker.ts

@@ -0,0 +1,264 @@
+import { execFileSync } from "node:child_process"
+import * as fs from "node:fs/promises"
+import * as os from "node:os"
+import * as path from "node:path"
+import { setTimeout as delay } from "node:timers/promises"
+import { openshellPreflight } from "../cloud/openshell-preflight.js"
+import { PostgresRsiJobQueue, fleetQueuePolicy, requiredFleetJobLeaseMs, type FleetJobLease, type FleetJobPayload } from "./postgres-queue.js"
+import { runOpenShellEvaluation, runOpenShellModelJob, runOpenShellMutation } from "./openshell.js"
+import type { CandidateRecord, ComputePolicy, EvaluationSummary, MutationHypothesis, MutationKind, RsiConfig, RsiRoleConfig, TrialResult } from "./types.js"
+
+const EVALUATION_PREVIEW_CHARS = 2048
+
+export async function externalizeEvaluationOutputs(
+	queue: PostgresRsiJobQueue,
+	evaluation: Pick<EvaluationSummary, "regression" | "visible">,
+): Promise<{ evaluation: Pick<EvaluationSummary, "regression" | "visible">; outputArtifact: { sha256: string; bytes: number } }> {
+	const trials = [evaluation.regression, ...evaluation.visible]
+	const rawOutputs = Buffer.from(JSON.stringify(trials.map((trial) => ({
+		command: trial.command,
+		stdout: trial.stdout,
+		stderr: trial.stderr,
+	}))))
+	const artifact = await queue.putArtifact(rawOutputs)
+	const compact = (trial: TrialResult): TrialResult => ({
+		...trial,
+		command: trial.command.slice(0, 512),
+		stdout: trial.stdout.slice(0, EVALUATION_PREVIEW_CHARS),
+		stderr: trial.stderr.slice(0, EVALUATION_PREVIEW_CHARS),
+		outputArtifactSha256: artifact.sha256,
+		outputArtifactBytes: artifact.byteLength,
+	})
+	return {
+		evaluation: { regression: compact(evaluation.regression), visible: evaluation.visible.map(compact) },
+		outputArtifact: { sha256: artifact.sha256, bytes: artifact.byteLength },
+	}
+}
+
+export interface RsiWorkerOptions {
+	queue: PostgresRsiJobQueue
+	workerId: string
+	gatewayId: string
+	hostname?: string
+	maxActive: number
+	resourceClasses: Array<"LOCAL_GPU" | "CPU" | "REMOTE_API" | "TRAINING_GPU">
+	scratchRoot: string
+	pollMs?: number
+	maxJobs?: number
+	signal?: AbortSignal
+	runMutation?: typeof runOpenShellMutation
+	runEvaluation?: typeof runOpenShellEvaluation
+	runModelJob?: typeof runOpenShellModelJob
+}
+
+function parsePositiveInteger(value: string | undefined, fallback: number, name: string): number {
+	if (value === undefined || value.trim() === "") return fallback
+	const parsed = Number(value)
+	if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error(`${name} must be a positive integer`)
+	return parsed
+}
+
+function taskConfig(payload: FleetJobPayload, root: string, queue: PostgresRsiJobQueue): RsiConfig {
+	const roles: RsiRoleConfig = { worker: { provider: "ollama", model: payload.model } }
+	return {
+		repoRoot: root,
+		model: payload.model,
+		population: 1,
+		generations: 1,
+		maxConcurrent: queue.policy.maxInFlight,
+		mutationTask: payload.task,
+		regressionCommand: payload.regressionCommand ?? "true",
+		evalCommands: payload.evalCommands ?? [],
+		hiddenEvalCommands: [],
+		archiveDir: path.join(root, ".headlesscode", "rsi-worker"),
+		worktreeDir: path.join(root, ".worktrees"),
+		baseRef: payload.snapshotCommit,
+		seed: `fleet-${payload.candidate.id}`,
+		dryRun: false,
+		keepWorktrees: true,
+		maxIterations: payload.maxIterations,
+		protectedPaths: payload.protectedPaths,
+		commandTimeoutMs: payload.timeoutMs,
+		computePolicy: (payload.candidate.computePolicy as ComputePolicy | undefined) ?? "single",
+		mutationKind: payload.candidate.mutationKind as MutationKind | undefined,
+		hypothesis: payload.candidate.hypothesis as MutationHypothesis | undefined,
+		roles,
+	}
+}
+
+function candidateFromPayload(payload: FleetJobPayload, root: string): CandidateRecord {
+	const descriptor = payload.candidate
+	const id = String(descriptor.id ?? "")
+	if (!/^[A-Za-z0-9._-]{1,100}$/.test(id) || !Number.isInteger(descriptor.generation)) throw new Error("fleet job candidate descriptor is malformed")
+	return {
+		id,
+		generation: Number(descriptor.generation),
+		parent: typeof descriptor.parent === "string" ? descriptor.parent : "baseline",
+		branch: `rsi-worker-${id}`,
+		worktree: root,
+		baseCommit: payload.snapshotCommit,
+		status: "mutating",
+		model: payload.model,
+		mutation: payload.task,
+		createdAt: new Date().toISOString(),
+		updatedAt: new Date().toISOString(),
+		commits: [],
+		changedFiles: [],
+		protectedPathViolations: [],
+		...(descriptor.mutationKind ? { mutationKind: descriptor.mutationKind as MutationKind } : {}),
+		...(descriptor.hypothesis ? { hypothesis: descriptor.hypothesis as MutationHypothesis } : {}),
+		...(descriptor.modelCandidateId ? { modelCandidateId: String(descriptor.modelCandidateId) } : {}),
+	}
+}
+
+function verifySanitizedBundle(root: string, expectedCommit: string, jobKind: FleetJobLease["job"]["jobKind"]): void {
+	const actual = execFileSync("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" }).trim()
+	if (actual !== expectedCommit) throw new Error("fleet snapshot commit did not match the queued digest-bound commit")
+	const count = execFileSync("git", ["rev-list", "--count", "--all"], { cwd: root, encoding: "utf8" }).trim()
+	if (count !== "1") throw new Error("fleet snapshot must contain exactly one commit")
+	const entries = execFileSync("git", ["ls-tree", "-r", "-z", "--full-tree", "HEAD"], { cwd: root, encoding: "buffer" }).toString("utf8").split("\0").filter(Boolean)
+	for (const entry of entries) {
+		const tab = entry.indexOf("\t")
+		if (tab < 0) throw new Error("fleet snapshot contains malformed Git tree metadata")
+		const [mode] = entry.slice(0, tab).split(" ")
+		const relativePath = entry.slice(tab + 1).replaceAll("\\", "/")
+		if (mode !== "100644" && mode !== "100755") throw new Error("fleet snapshot contains a symlink, submodule or special file")
+		if (relativePath === ".env" || relativePath.startsWith(".env.") || relativePath.startsWith("src/rsi/") || relativePath.startsWith(".headlesscode/") || relativePath.startsWith("scripts/eval-suite/") || (jobKind === "mutation" && (relativePath.startsWith("fixtures/rsi-curriculum/") || relativePath.startsWith("scripts/") || relativePath.startsWith("tests/") || relativePath.startsWith("test/") || relativePath.includes("/__tests__/") || /(?:^|\/)\D[^/]*\.(?:test|spec)\.[^/]+$/.test(relativePath)))) {
+			throw new Error(`fleet snapshot contains protected evaluator or credential material: ${relativePath}`)
+		}
+		if ((jobKind === "training" || jobKind === "model-evaluation") && !relativePath.startsWith(".headlesscode-rsi-model/")) {
+			// Model jobs may include ordinary application source, but reject any accidental
+			// local checkpoint/result files or repository history in the transfer bundle.
+			if (/^(?:\.rsi-base-model|\.headlesscode-rsi-model-output)(?:\/|$)/.test(relativePath)) throw new Error("model job snapshot contains a local model or prior result artifact")
+		}
+	}
+}
+
+async function executeLease(lease: FleetJobLease, options: RsiWorkerOptions): Promise<void> {
+	const payload = lease.job.payload
+	if (payload.schemaVersion !== 1 || payload.snapshotSha256 !== lease.job.artifactSha256 || !Number.isSafeInteger(payload.snapshotBytes) || payload.snapshotBytes < 1) {
+		await options.queue.fail(lease, "malformed or unbound fleet snapshot payload")
+		return
+	}
+	const requiredLeaseMs = requiredFleetJobLeaseMs(lease.job.jobKind, payload.timeoutMs, payload.evalCommands?.length ?? 0)
+	if (lease.job.leaseDurationMs < requiredLeaseMs) {
+		await options.queue.fail(lease, `job lease ${lease.job.leaseDurationMs}ms is below its OpenShell worst-case budget ${requiredLeaseMs}ms`)
+		return
+	}
+	const root = await fs.mkdtemp(path.join(options.scratchRoot, `${lease.job.jobId}-${lease.job.attempts}-`))
+	const bundlePath = path.join(root, "snapshot.bundle")
+	const repoRoot = path.join(root, "repo")
+	try {
+		const bundle = await options.queue.getArtifact(payload.snapshotSha256)
+		if (bundle.byteLength !== payload.snapshotBytes) throw new Error("fleet snapshot artifact length differed from queued metadata")
+		await fs.writeFile(bundlePath, bundle, { mode: 0o600, flag: "wx" })
+		const verifyRoot = path.join(root, "verify.git")
+		execFileSync("git", ["init", "--bare", "--quiet", verifyRoot], { cwd: root, stdio: "pipe" })
+		execFileSync("git", ["bundle", "verify", bundlePath], { cwd: verifyRoot, stdio: "pipe" })
+		execFileSync("git", ["clone", "--quiet", "--no-hardlinks", bundlePath, repoRoot], { cwd: root, stdio: "pipe" })
+		verifySanitizedBundle(repoRoot, payload.snapshotCommit, lease.job.jobKind)
+		const candidate = candidateFromPayload(payload, repoRoot)
+		const config = taskConfig(payload, repoRoot, options.queue)
+		const started = Date.now()
+		let result: Record<string, unknown>
+		if (lease.job.jobKind === "mutation") {
+			const mutation = await (options.runMutation ?? runOpenShellMutation)(candidate, config)
+			if (!mutation.ok) throw new Error(mutation.error ?? mutation.result?.stderr ?? "OpenShell mutation failed")
+			const patch = execFileSync("git", ["diff", "--binary", "--no-ext-diff", "--no-renames", `${candidate.baseCommit}...HEAD`], { cwd: repoRoot, encoding: "buffer", maxBuffer: options.queue.policy.maxInFlight * 1024 * 1024 * 16 })
+			if (patch.byteLength === 0) throw new Error("OpenShell mutation produced no patch")
+			const artifact = await options.queue.putArtifact(patch)
+			result = { ok: true, patchSha256: artifact.sha256, patchBytes: artifact.byteLength, durationMs: Date.now() - started }
+		} else if (lease.job.jobKind === "evaluation") {
+			const evaluation = await (options.runEvaluation ?? runOpenShellEvaluation)(candidate, config)
+			const externalized = await externalizeEvaluationOutputs(options.queue, evaluation)
+			result = { ok: true, ...externalized, durationMs: Date.now() - started }
+		} else {
+			const modelTask = payload.modelTask
+			if (!modelTask || (lease.job.jobKind === "training") !== (modelTask.kind === "qlora-train")) throw new Error("fleet model job kind and payload do not match")
+			const model = await (options.runModelJob ?? runOpenShellModelJob)(candidate, config, modelTask)
+			const outputArtifact = await options.queue.putArtifact(Buffer.from(JSON.stringify(model.result)))
+			const modelResult: Record<string, unknown> = { ...model.result, outputArtifactSha256: outputArtifact.sha256, outputArtifactBytes: outputArtifact.byteLength }
+			if (lease.job.jobKind === "training" && model.result.status === "completed") {
+				if (!model.adapterArchive) throw new Error("completed QLoRA job did not return its adapter archive")
+				const adapterArtifact = await options.queue.putArtifact(model.adapterArchive)
+				modelResult.adapterArtifactSha256 = adapterArtifact.sha256
+				modelResult.adapterArtifactBytes = adapterArtifact.byteLength
+			}
+			result = { ok: model.result.status === "completed", modelResult, durationMs: Date.now() - started }
+		}
+		const completion = await options.queue.complete(lease, result)
+		if (!completion.accepted) throw new Error("OpenShell result was fenced because this worker no longer owns the lease")
+	} catch (error) {
+		await options.queue.fail(lease, error instanceof Error ? error.message : String(error))
+	} finally {
+		await fs.rm(root, { recursive: true, force: true })
+	}
+}
+
+export async function runRsiWorker(options: RsiWorkerOptions): Promise<void> {
+	if (options.queue.artifactBackend !== "s3") throw new Error("fleet RSI workers require a shared S3-compatible artifact store; file storage is same-host development only")
+	if (!/^[A-Za-z0-9._-]{1,64}$/.test(options.workerId) || !/^[A-Za-z0-9._-]{1,64}$/.test(options.gatewayId)) throw new Error("worker and gateway IDs must be simple configured identifiers")
+	if (options.maxActive !== 1) throw new Error("each RSI OpenShell worker process currently runs one guest at a time; configure maxActive=1")
+	await fs.mkdir(options.scratchRoot, { recursive: true, mode: 0o700 })
+	await options.queue.migrate()
+	await options.queue.registerWorker({
+		workerId: options.workerId,
+		gatewayId: options.gatewayId,
+		hostname: options.hostname ?? os.hostname(),
+		maxActive: options.maxActive,
+		resourceClasses: options.resourceClasses,
+	})
+	let processed = 0
+	while (!options.signal?.aborted && (options.maxJobs === undefined || processed < options.maxJobs)) {
+		await options.queue.heartbeatWorker(options.workerId)
+		const lease = await options.queue.claim(options.workerId)
+		if (!lease) {
+			await delay(options.pollMs ?? 1000, undefined, { signal: options.signal }).catch(() => undefined)
+			continue
+		}
+		const heartbeat = setInterval(() => {
+			void options.queue.heartbeat(lease).catch(() => false)
+			void options.queue.heartbeatWorker(options.workerId).catch(() => false)
+		}, Math.max(1000, Math.floor(options.queue.policy.leaseMs / 3)))
+		try { await executeLease(lease, options) } finally { clearInterval(heartbeat) }
+		processed += 1
+	}
+	await options.queue.stopWorker(options.workerId)
+}
+
+export async function rsiWorkerMain(env: NodeJS.ProcessEnv = process.env): Promise<number> {
+	const workerId = env.HEADLESSCODE_RSI_WORKER_ID?.trim()
+	const gatewayId = env.HEADLESSCODE_RSI_GATEWAY_ID?.trim()
+	if (!workerId || !gatewayId) throw new Error("HEADLESSCODE_RSI_WORKER_ID and HEADLESSCODE_RSI_GATEWAY_ID are required")
+	const queueName = env.HEADLESSCODE_RSI_QUEUE_NAME?.trim() || "rsi-default"
+	const maxInFlight = parsePositiveInteger(env.HEADLESSCODE_RSI_MAX_IN_FLIGHT, 1, "HEADLESSCODE_RSI_MAX_IN_FLIGHT")
+	const policy = fleetQueuePolicy(queueName, maxInFlight, env)
+	const queue = PostgresRsiJobQueue.fromEnvironment(policy, env)
+	const maxActive = parsePositiveInteger(env.HEADLESSCODE_RSI_WORKER_MAX_ACTIVE, 1, "HEADLESSCODE_RSI_WORKER_MAX_ACTIVE")
+	const resourceClasses = (env.HEADLESSCODE_RSI_WORKER_RESOURCE_CLASSES ?? "LOCAL_GPU,CPU").split(",").map((entry) => entry.trim()).filter(Boolean) as RsiWorkerOptions["resourceClasses"]
+	if (resourceClasses.some((value) => !["LOCAL_GPU", "CPU", "REMOTE_API", "TRAINING_GPU"].includes(value))) throw new Error("HEADLESSCODE_RSI_WORKER_RESOURCE_CLASSES contains an unsupported class")
+	process.env.OPENSHELL_GATEWAY = gatewayId
+	const preflight = openshellPreflight({ requireOpenRouterCredential: false })
+	if (preflight) throw new Error(preflight)
+	const controller = new AbortController()
+	const stop = () => controller.abort()
+	process.once("SIGINT", stop)
+	process.once("SIGTERM", stop)
+	try {
+		await runRsiWorker({
+			queue,
+			workerId,
+			gatewayId,
+			maxActive,
+			resourceClasses,
+			scratchRoot: path.resolve(env.HEADLESSCODE_RSI_WORKER_SCRATCH_DIR ?? path.join(os.tmpdir(), "headlesscode-rsi-worker")),
+			pollMs: parsePositiveInteger(env.HEADLESSCODE_RSI_WORKER_POLL_MS, 1000, "HEADLESSCODE_RSI_WORKER_POLL_MS"),
+			signal: controller.signal,
+		})
+		return 0
+	} finally {
+		process.removeListener("SIGINT", stop)
+		process.removeListener("SIGTERM", stop)
+		await queue.close()
+	}
+}

package/src/rsi/workspace.ts

@@ -81,11 +81,22 @@ export async function removeCandidateWorktree(config: RsiConfig, candidate: Cand
 
 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()
+	const status = await execFile("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+		cwd: repoRoot,
+		encoding: "utf8",
+		maxBuffer: 4 * 1024 * 1024,
+	})
+	const entries = status.stdout.split("\0")
+	for (let index = 0; index < entries.length; index++) {
+		const entry = entries[index]
+		if (!entry) continue
+		const file = entry.slice(3)
 		if (file) files.add(file)
+		if (/[RC]/.test(entry.slice(0, 2))) {
+			const original = entries[++index]
+			if (original) files.add(original)
+		}
 	}
 	return [...files].sort()
 }

package/src/watcher/cli.ts

@@ -32,6 +32,7 @@ import * as path from "node:path"
 
 import { Logger } from "../engine/logger.js"
 import { watchIssues, type SweepResult } from "./watch.js"
+import { openshellPreflight } from "../cloud/openshell-preflight.js"
 
 const WATCH_USAGE = `headlesscode watch — Phase 5 GitHub issue watcher
 
@@ -61,6 +62,7 @@ Options:
                          <repo>/.worktrees/.watcher-state.json)
   --mode <slug>          Harness mode for workers (default: code; forwarded
                          to the spawner as ORCHESTRATOR_MODE)
+  --execution-provider <local|openshell> Worker runtime (default: local)
   --qa                   Pass-through: record that a QA round should follow
                          each batch (see docs/phase5-issue-watcher.md)
   --deploy               Pass-through: record that a deploy gate should follow
@@ -92,6 +94,7 @@ export interface WatchCliOptions {
 	maxConcurrentSessions: number
 	stateFile?: string
 	mode: string
+	executionProvider: "local" | "openshell"
 	qa: boolean
 	deploy: boolean
 	memoryDir?: string
@@ -110,6 +113,7 @@ export function parseWatchArgs(argv: string[]): { options: WatchCliOptions; erro
 		maxPerSweep: 5,
 		maxConcurrentSessions: 3,
 		mode: "code",
+		executionProvider: process.env.HEADLESSCODE_EXECUTION_PROVIDER === "openshell" ? "openshell" : "local",
 		qa: false,
 		deploy: false,
 		dryRun: false,
@@ -135,6 +139,12 @@ export function parseWatchArgs(argv: string[]): { options: WatchCliOptions; erro
 		}
 
 		switch (flag) {
+			case "--execution-provider": {
+				const v = next()
+				if (v !== "local" && v !== "openshell") return { options, error: "--execution-provider must be local or openshell" }
+				options.executionProvider = v
+				break
+			}
 			case "--owner": {
 				const v = next()
 				if (v === undefined) {
@@ -300,6 +310,13 @@ export async function watchMain(argv: string[]): Promise<number> {
 			return 2
 		}
 	}
+	if (!options.dryRun && options.executionProvider === "openshell") {
+		const issue = openshellPreflight()
+		if (issue) {
+			process.stderr.write(`headlesscode watch: OpenShell preflight failed: ${issue}\n`)
+			return 2
+		}
+	}
 
 	const ghRepo = options.ghRepo ?? path.basename(repoRoot)
 	const logger = new Logger({ level: "info" })
@@ -328,6 +345,7 @@ export async function watchMain(argv: string[]): Promise<number> {
 			retryFailed: options.retryFailed,
 			dryRun: options.dryRun,
 			mode: options.mode,
+			executionProvider: options.executionProvider,
 			memoryDir: options.memoryDir,
 			qa: options.qa,
 			deploy: options.deploy,

package/src/watcher/watch.ts

@@ -129,6 +129,7 @@ export interface WatcherConfig {
 	spawn?: (batch: SpawnBatch) => SpawnResult | Promise<SpawnResult>
 	/** Harness mode for workers (forwarded to the spawner as ORCHESTRATOR_MODE). */
 	mode?: string
+	executionProvider?: "local" | "openshell"
 	/** Memory dir for workers (forwarded to the spawner as HEADLESSCODE_MEMORY_DIR). */
 	memoryDir?: string
 	/** Phase 4 pass-through: recorded on the batch entry (see docs). */
@@ -480,7 +481,7 @@ function batchId(): string {
  * with cwd = the target repo so `git rev-parse --show-toplevel` resolves).
  * No worktree creation happens in TS; the bash script remains the spawner.
  */
-export function defaultSpawn(batch: SpawnBatch, config: Pick<WatcherConfig, "mode" | "memoryDir">): SpawnResult {
+export function defaultSpawn(batch: SpawnBatch, config: Pick<WatcherConfig, "mode" | "memoryDir" | "executionProvider">): SpawnResult {
 	const issues: SplitIssue[] = [
 		{ number: batch.issue.number, title: batch.issue.title, body: batch.issue.body },
 	]
@@ -511,6 +512,7 @@ export function defaultSpawn(batch: SpawnBatch, config: Pick<WatcherConfig, "mod
 			...process.env,
 			TARGET_REPO: batch.repoRoot,
 			ORCHESTRATOR_MODE: config.mode ?? "code",
+			HEADLESSCODE_EXECUTION_PROVIDER: config.executionProvider ?? process.env.HEADLESSCODE_EXECUTION_PROVIDER ?? "local",
 			HEADLESSCODE_PROJECT: path.basename(batch.repoRoot),
 			...(config.memoryDir ? { HEADLESSCODE_MEMORY_DIR: path.resolve(config.memoryDir) } : {}),
 		},