lalph 0.1.96 → 0.1.98

package/dist/cli.mjs

@@ -28564,6 +28564,17 @@ const provideServiceEffect = /* @__PURE__ */ dual(3, (self$1, key, service$2) =>
 */
 const runForEach$1 = /* @__PURE__ */ dual(2, (self$1, f) => runWith$1(self$1, (pull) => forever(flatMap(pull, f), { autoYield: false })));
 /**
+* @since 2.0.0
+* @category execution
+*/
+const runHead$1 = (self$1) => suspend$3(() => {
+	let head = none$3();
+	return runWith$1(self$1, (pull) => pull.pipe(asSome, flatMap((head_$1) => {
+		head = head_$1;
+		return done();
+	})), () => succeed$1(head));
+});
+/**
 * Runs a channel and folds over all output elements with an accumulator.
 *
 * @example
@@ -30247,6 +30258,11 @@ const runCollect = (self$1) => runFold(self$1.channel, () => [], (acc, chunk) =>
 	return acc;
 });
 /**
+* @since 2.0.0
+* @category destructors
+*/
+const runHead = (self$1) => map$6(runHead$1(self$1.channel), map$12(getUnsafe$1(0)));
+/**
 * Consumes all elements of the stream, passing them to the specified
 * callback.
 *
@@ -46145,15 +46161,15 @@ const black = `${ESC}30m`;
 /** @internal */
 const red = `${ESC}31m`;
 /** @internal */
-const green = `${ESC}32m`;
+const green$1 = `${ESC}32m`;
 /** @internal */
-const yellow = `${ESC}33m`;
+const yellow$1 = `${ESC}33m`;
 /** @internal */
 const blue = `${ESC}34m`;
 /** @internal */
 const magenta = `${ESC}35m`;
 /** @internal */
-const cyan = `${ESC}36m`;
+const cyan$1 = `${ESC}36m`;
 /** @internal */
 const white = `${ESC}37m`;
 /** @internal */
@@ -46543,12 +46559,12 @@ const renderAutoCompleteNextFrame = /* @__PURE__ */ fnUntraced(function* (state,
 const renderSelectSubmission = /* @__PURE__ */ fnUntraced(function* (state, options) {
 	const figures = yield* platformFigures;
 	const selected = options.choices[state].title;
-	return renderSelectOutput(annotate(figures.tick, green), annotate(figures.ellipsis, blackBright), options) + " " + annotate(selected, white) + "\n";
+	return renderSelectOutput(annotate(figures.tick, green$1), annotate(figures.ellipsis, blackBright), options) + " " + annotate(selected, white) + "\n";
 });
 const renderAutoCompleteSubmission = /* @__PURE__ */ fnUntraced(function* (state, options) {
 	const figures = yield* platformFigures;
 	const selected = options.choices[state.index].title;
-	return renderAutoCompleteOutput(state, annotate(figures.tick, green), annotate(figures.ellipsis, blackBright), options) + " " + annotate(selected, white) + "\n";
+	return renderAutoCompleteOutput(state, annotate(figures.tick, green$1), annotate(figures.ellipsis, blackBright), options) + " " + annotate(selected, white) + "\n";
 });
 const processSelectCursorUp = (state, choices) => {
 	if (state === 0) return succeed$1(Action.NextFrame({ state: choices.length - 1 }));
@@ -46701,7 +46717,7 @@ const renderTextNextFrame = /* @__PURE__ */ fnUntraced(function* (state, options
 });
 const renderTextSubmission = /* @__PURE__ */ fnUntraced(function* (state, options) {
 	const figures = yield* platformFigures;
-	return renderTextOutput(state, annotate(figures.tick, green), annotate(figures.ellipsis, blackBright), options, true) + "\n";
+	return renderTextOutput(state, annotate(figures.tick, green$1), annotate(figures.ellipsis, blackBright), options, true) + "\n";
 });
 const processTextBackspace = (state) => {
 	if (state.cursor <= 0) return succeed$1(Action.Beep());
@@ -62208,7 +62224,7 @@ const symlink = /* @__PURE__ */ (() => {
 	const nodeSymlink = /* @__PURE__ */ effectify(NFS.symlink, /* @__PURE__ */ handleErrnoException("FileSystem", "symlink"), /* @__PURE__ */ handleBadArgument("symlink"));
 	return (target, path$2) => nodeSymlink(target, path$2);
 })();
-const truncate = /* @__PURE__ */ (() => {
+const truncate$1 = /* @__PURE__ */ (() => {
 	const nodeTruncate = /* @__PURE__ */ effectify(NFS.truncate, /* @__PURE__ */ handleErrnoException("FileSystem", "truncate"), /* @__PURE__ */ handleBadArgument("truncate"));
 	return (path$2, length) => nodeTruncate(path$2, length !== void 0 ? Number(length) : void 0);
 })();
@@ -62296,7 +62312,7 @@ const makeFileSystem = /* @__PURE__ */ map$6(/* @__PURE__ */ serviceOption(Watch
 	rename,
 	stat,
 	symlink,
-	truncate,
+	truncate: truncate$1,
 	utimes,
 	watch(path$2) {
 		return watch(getOrUndefined(backend), path$2);
@@ -63229,14 +63245,6 @@ const runMain = runMain$1;
 //#region src/Kvs.ts
 const layerKvs = layerFileSystem(".lalph/config");
 
-//#endregion
-//#region src/shared/stream.ts
-const streamFilterJson = (schema$1) => {
-	const fromString = fromJsonString(schema$1);
-	const decode$2 = decodeEffect(fromString);
-	return flow(splitLines, filterMapEffect((line) => decode$2(line).pipe(catch_$1(() => succeed$1(failVoid)))));
-};
-
 //#endregion
 //#region src/shared/ansi-colors.ts
 const ansiColors = {
@@ -63247,45 +63255,148 @@ const ansiColors = {
 	yellow: "\x1B[33m"
 };
 
+//#endregion
+//#region src/shared/stream.ts
+const streamFilterJson = (schema$1) => {
+	const fromString = fromJsonString(schema$1);
+	const decode$2 = decodeEffect(fromString);
+	return flow(splitLines, filterMapEffect((line) => decode$2(line).pipe(catch_$1(() => succeed$1(failVoid)))));
+};
+
 //#endregion
 //#region src/CliAgent/claude.ts
 const claudeOutputTransformer = (stream$3) => stream$3.pipe(streamFilterJson(StreamJsonMessage), map$4((m) => m.format()));
 const ContentBlock = Struct({
 	type: String$1,
 	text: optional$2(String$1),
-	name: optional$2(String$1)
+	name: optional$2(String$1),
+	input: optional$2(Unknown),
+	content: optional$2(String$1),
+	is_error: optional$2(Boolean$2)
+});
+const ToolUseResult = Struct({
+	stdout: optional$2(String$1),
+	stderr: optional$2(String$1),
+	interrupted: optional$2(Boolean$2),
+	isImage: optional$2(Boolean$2)
 });
 var StreamJsonMessage = class extends Class("claude/StreamJsonMessage")({
 	type: String$1,
 	subtype: optional$2(String$1),
 	message: optional$2(Struct({ content: optional$2(Array$1(ContentBlock)) })),
+	tool_use_result: optional$2(ToolUseResult),
 	duration_ms: optional$2(Number$1),
 	total_cost_usd: optional$2(Number$1)
 }) {
 	format() {
 		switch (this.type) {
-			case "system": return this.subtype === "init" ? ansiColors.dim + "[Session started]" + ansiColors.reset + "\n" : "";
+			case "system": return this.subtype === "init" ? dim("[Session started]") + "\n" : "";
 			case "assistant": return formatAssistantMessage(this);
+			case "user": return formatToolResult(this);
 			case "result": return formatResult(this);
 			default: return "";
 		}
 	}
 };
+const BashInput = Struct({ command: optional$2(String$1) });
+const FileInput = Struct({ file_path: optional$2(String$1) });
+const PatternInput = Struct({ pattern: optional$2(String$1) });
+const QuestionOption = Struct({
+	label: String$1,
+	description: optional$2(String$1)
+});
+const Question = Struct({
+	question: String$1,
+	header: optional$2(String$1),
+	options: optional$2(Array$1(QuestionOption))
+});
+const AskUserQuestionInput = Struct({ questions: optional$2(Array$1(Question)) });
+const McpInputFields = [
+	"query",
+	"documentId",
+	"page",
+	"pattern",
+	"relative_path",
+	"name_path",
+	"file_path",
+	"root_path"
+];
+const truncate = (s, max$3) => s.length > max$3 ? s.slice(0, max$3) + "..." : s;
+const dim = (s) => ansiColors.dim + s + ansiColors.reset;
+const cyan = (s) => ansiColors.cyan + s + ansiColors.reset;
+const yellow = (s) => ansiColors.yellow + s + ansiColors.reset;
+const green = (s) => ansiColors.green + s + ansiColors.reset;
 const formatToolName = (name) => name.replace("mcp__", "").replace(/__/g, ":");
+const withDetail = (display, detail) => display + getOrElse(detail, () => "");
+const formatBashInput = (input) => pipe(decodeUnknownOption(BashInput)(input), flatMap$3((data) => fromNullishOr$2(data.command)), filter$6((cmd) => cmd.length > 0), map$12((cmd) => dim("$ " + truncate(cmd, 100)) + "\n"));
+const formatFileInput = (input) => pipe(decodeUnknownOption(FileInput)(input), flatMap$3((data) => fromNullishOr$2(data.file_path)), filter$6((path$2) => path$2.length > 0), map$12((path$2) => dim(path$2) + "\n"));
+const formatPatternInput = (input) => pipe(decodeUnknownOption(PatternInput)(input), flatMap$3((data) => fromNullishOr$2(data.pattern)), filter$6((pattern) => pattern.length > 0), map$12((pattern) => dim(pattern) + "\n"));
+const formatMcpInput = (input) => {
+	if (typeof input !== "object" || input === null) return none$3();
+	const data = input;
+	const parts$1 = McpInputFields.flatMap((field) => match$7(fromNullishOr$2(data[field]), {
+		onNone: () => [],
+		onSome: (value) => [`${field}=${truncate(String(value), 50)}`]
+	}));
+	return parts$1.length > 0 ? some(dim(parts$1.join(" ")) + "\n") : none$3();
+};
+const formatGenericInput = (input) => pipe(fromNullishOr$2(input), map$12((v) => dim(truncate(JSON.stringify(v), 100)) + "\n"));
+const formatUserQuestion = (input) => pipe(decodeUnknownOption(AskUserQuestionInput)(input), flatMap$3((data) => fromNullishOr$2(data.questions)), map$12((questions) => questions.map((q) => {
+	let result$2 = "\n" + yellow("⚠ WAITING FOR INPUT") + "\n";
+	result$2 += cyan((q.header ? `[${q.header}] ` : "") + q.question) + "\n";
+	if (q.options) result$2 += q.options.map((opt, i) => `  ${i + 1}. ${opt.label}${opt.description ? dim(` - ${opt.description}`) : ""}`).join("\n") + "\n";
+	return result$2;
+}).join("\n")), getOrElse(() => ""));
+const formatToolInput = (name, input) => {
+	const display = "\n" + cyan("▶ " + formatToolName(name)) + "\n";
+	if (name === "Bash") return withDetail(display, formatBashInput(input));
+	if (name === "AskUserQuestion") return display + formatUserQuestion(input);
+	if (name === "Read" || name === "Write" || name === "Edit") return withDetail(display, formatFileInput(input));
+	if (name === "Grep" || name === "Glob") return withDetail(display, formatPatternInput(input));
+	if (name.startsWith("mcp__")) return withDetail(display, formatMcpInput(input));
+	return withDetail(display, formatGenericInput(input));
+};
 const formatAssistantMessage = (msg) => {
 	const content = msg.message?.content;
 	if (!content) return "";
 	return content.map((block) => {
 		if (block.type === "text" && block.text) return block.text;
-		else if (block.type === "tool_use" && block.name) return "\n" + ansiColors.cyan + "▶ " + formatToolName(block.name) + ansiColors.reset + "\n";
+		if (block.type === "tool_use" && block.name) return formatToolInput(block.name, block.input);
 		return "";
 	}).join("");
 };
+const formatLongOutput = (text$3) => {
+	const lines$1 = text$3.trim().split("\n");
+	if (lines$1.length > 8) return dim([
+		...lines$1.slice(0, 4),
+		`... (${lines$1.length - 7} more lines)`,
+		...lines$1.slice(-3)
+	].join("\n")) + "\n";
+	return text$3.length > 500 ? dim(truncate(text$3, 500)) + "\n" : dim(text$3) + "\n";
+};
+const formatToolResult = (msg) => {
+	let output = "";
+	const result$2 = msg.tool_use_result;
+	if (result$2) {
+		if (result$2.stderr?.trim()) output += yellow("stderr: ") + truncate(result$2.stderr.trim(), 500) + "\n";
+		if (result$2.interrupted) output += yellow("[interrupted]") + "\n";
+		if (result$2.stdout?.trim()) output += formatLongOutput(result$2.stdout.trim());
+	}
+	const content = msg.message?.content;
+	if (content) {
+		for (const block of content) if (block.type === "tool_result") {
+			if (block.is_error) output += yellow("✗ Tool error") + "\n";
+			if (block.content) output += formatLongOutput(block.content);
+		}
+	}
+	return output;
+};
 const formatResult = (msg) => {
 	if (msg.subtype === "success") {
 		const info = [msg.duration_ms ? (msg.duration_ms / 1e3).toFixed(1) + "s" : "", msg.total_cost_usd ? "$" + msg.total_cost_usd.toFixed(4) : ""].filter(Boolean).join(" | ");
-		return "\n" + ansiColors.green + "✓ Done" + ansiColors.reset + " " + ansiColors.dim + info + ansiColors.reset + "\n";
-	} else if (msg.subtype === "error") return "\n" + ansiColors.yellow + "✗ Error" + ansiColors.reset + "\n";
+		return "\n" + green("✓ Done") + " " + dim(info) + "\n";
+	}
+	if (msg.subtype === "error") return "\n" + yellow("✗ Error") + "\n";
 	return "";
 };
 
@@ -63326,7 +63437,7 @@ const claude = new CliAgent({
 		stdout: outputMode,
 		stderr: outputMode,
 		stdin: "inherit"
-	})`claude --dangerously-skip-permissions --output-format stream-json --verbose -p ${`@${prdFilePath}
+	})`claude --dangerously-skip-permissions --output-format stream-json --verbose --disallowed-tools AskUserQuestion -p ${`@${prdFilePath}
 
 ${prompt}`}`,
 	outputTransformer: claudeOutputTransformer,
@@ -145054,6 +145165,14 @@ const getOrSelectCliAgent = gen(function* () {
 });
 const commandAgent = make$28("agent").pipe(withDescription("Select the CLI agent to use"), withHandler(() => selectCliAgent));
 
+//#endregion
+//#region src/shared/fs.ts
+const makeWaitForFile = gen(function* () {
+	const fs = yield* FileSystem;
+	const pathService = yield* Path$1;
+	return (directory$2, name) => pipe(fs.watch(directory$2), filter((e) => pathService.basename(e.path) === name), runHead);
+});
+
 //#endregion
 //#region src/Agents/instructor.ts
 const agentInstructor = fnUntraced(function* (options) {
@@ -145061,6 +145180,7 @@ const agentInstructor = fnUntraced(function* (options) {
 	const pathService = yield* Path$1;
 	const worktree = yield* Worktree;
 	const promptGen = yield* PromptGen;
+	const waitForFile = yield* makeWaitForFile;
 	yield* pipe(options.cliAgent.command({
 		outputMode: "pipe",
 		prompt: promptGen.promptInstructions({
@@ -145073,7 +145193,7 @@ const agentInstructor = fnUntraced(function* (options) {
 	}), setCwd(worktree.directory), options.commandPrefix, worktree.execWithStallTimeout({
 		cliAgent: options.cliAgent,
 		stallTimeout: options.stallTimeout
-	}));
+	}), raceFirst(waitForFile(pathService.join(worktree.directory, ".lalph"), "instructions.md")));
 	return yield* fs.readFileString(pathService.join(worktree.directory, ".lalph", "instructions.md"));
 });
 
@@ -145104,13 +145224,14 @@ const agentChooser = fnUntraced(function* (options) {
 	const worktree = yield* Worktree;
 	const promptGen = yield* PromptGen;
 	const prd = yield* Prd;
+	const taskJsonCreated = (yield* makeWaitForFile)(pathService.join(worktree.directory, ".lalph"), "task.json");
 	yield* pipe(options.cliAgent.resolveCommandChoose({
 		prompt: promptGen.promptChoose,
 		prdFilePath: pathService.join(".lalph", "prd.yml")
 	}), setCwd(worktree.directory), options.commandPrefix, exitCode, timeoutOrElse({
 		duration: options.stallTimeout,
 		onTimeout: () => fail$4(new RunnerStalled())
-	}));
+	}), raceFirst(taskJsonCreated));
 	const taskJson = yield* fs.readFileString(pathService.join(worktree.directory, ".lalph", "task.json"));
 	return yield* decodeEffect(ChosenTask)(taskJson).pipe(mapError$2(() => new ChosenTaskNotFound()), flatMap(fnUntraced(function* (task) {
 		const prdTask = yield* prd.findById(task.id);
@@ -145169,71 +145290,6 @@ const agentTimeout = fnUntraced(function* (options) {
 
 //#endregion
 //#region src/commands/root.ts
-const iterations = integer("iterations").pipe(withDescription$1("Number of iterations to run, defaults to unlimited"), withAlias("i"), withDefault(Number.POSITIVE_INFINITY));
-const concurrency = integer("concurrency").pipe(withDescription$1("Number of concurrent agents, defaults to 1"), withAlias("c"), withDefault(1));
-const targetBranch = string$1("target-branch").pipe(withDescription$1("Target branch for PRs. Defaults to current branch. Env variable: LALPH_TARGET_BRANCH"), withAlias("b"), withFallbackConfig(string$4("LALPH_TARGET_BRANCH")), withDefault(make$21`git branch --show-current`.pipe(string, orDie$2, flatMap((output) => {
-	const branch = output.trim();
-	return branch === "" ? fail$4(new MissingOption({ option: "--target-branch" })) : succeed$1(branch);
-}))), optional);
-const maxIterationMinutes = integer("max-minutes").pipe(withDescription$1("Maximum number of minutes to allow an iteration to run. Defaults to 90 minutes. Env variable: LALPH_MAX_MINUTES"), withFallbackConfig(int("LALPH_MAX_MINUTES")), withDefault(90));
-const stallMinutes = integer("stall-minutes").pipe(withDescription$1("If no activity occurs for this many minutes, the iteration will be stopped. Defaults to 5 minutes. Env variable: LALPH_STALL_MINUTES"), withFallbackConfig(int("LALPH_STALL_MINUTES")), withDefault(5));
-const specsDirectory = directory("specs").pipe(withDescription$1("Directory to store plan specifications. Env variable: LALPH_SPECS"), withAlias("s"), withFallbackConfig(string$4("LALPH_SPECS")), withDefault(".specs"));
-const verbose = boolean("verbose").pipe(withDescription$1("Enable verbose logging"), withAlias("v"));
-const reset = boolean("reset").pipe(withDescription$1("Reset the current issue source before running"), withAlias("r"));
-const commandRoot = make$28("lalph", {
-	iterations,
-	concurrency,
-	targetBranch,
-	maxIterationMinutes,
-	stallMinutes,
-	reset,
-	specsDirectory,
-	verbose
-}).pipe(withHandler(fnUntraced(function* ({ iterations: iterations$1, concurrency: concurrency$1, targetBranch: targetBranch$1, maxIterationMinutes: maxIterationMinutes$1, stallMinutes: stallMinutes$1, specsDirectory: specsDirectory$1 }) {
-	const source = yield* build(CurrentIssueSource.layer);
-	const commandPrefix = yield* getCommandPrefix;
-	yield* getOrSelectCliAgent;
-	const isFinite$3 = Number.isFinite(iterations$1);
-	const iterationsDisplay = isFinite$3 ? iterations$1 : "unlimited";
-	const runConcurrency = Math.max(1, concurrency$1);
-	const semaphore = makeSemaphoreUnsafe(runConcurrency);
-	const fibers = yield* make$25();
-	yield* resetInProgress.pipe(provide$1(source), withSpan("Main.resetInProgress"));
-	yield* log$1(`Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`);
-	if (isSome(targetBranch$1)) yield* log$1(`Using target branch: ${targetBranch$1.value}`);
-	let iteration = 0;
-	let quit = false;
-	while (true) {
-		yield* semaphore.take(1);
-		if (quit || isFinite$3 && iteration >= iterations$1) break;
-		const currentIteration = iteration;
-		const startedDeferred = yield* make$49();
-		yield* checkForWork.pipe(andThen(run({
-			startedDeferred,
-			targetBranch: targetBranch$1,
-			specsDirectory: specsDirectory$1,
-			stallTimeout: minutes(stallMinutes$1),
-			runTimeout: minutes(maxIterationMinutes$1),
-			commandPrefix
-		})), catchFilter((e) => e._tag === "NoMoreWork" || e._tag === "QuitError" ? fail$8(e) : e, (e) => logWarning(fail$5(e))), catchTags({
-			NoMoreWork(_) {
-				if (isFinite$3) {
-					iterations$1 = currentIteration;
-					return log$1(`No more work to process, ending after ${currentIteration} iteration(s).`);
-				}
-				const log$2 = size$1(fibers) <= 1 ? log$1("No more work to process, waiting 30 seconds...") : void_$1;
-				return andThen(log$2, sleep(seconds(30)));
-			},
-			QuitError(_) {
-				quit = true;
-				return void_$1;
-			}
-		}), annotateLogs({ iteration: currentIteration }), ensuring(semaphore.release(1)), ensuring(completeWith(startedDeferred, void_$1)), provide$1(source), run$1(fibers));
-		yield* _await(startedDeferred);
-		iteration++;
-	}
-	yield* awaitEmpty(fibers);
-}, scoped$1)));
 const run = fnUntraced(function* (options) {
 	const fs = yield* FileSystem;
 	const pathService = yield* Path$1;
@@ -145294,7 +145350,7 @@ const run = fnUntraced(function* (options) {
 			instructions
 		});
 		yield* log$1(`Agent exited with code: ${exitCode$1}`);
-		yield* agentReviewer({
+		if (options.review) yield* agentReviewer({
 			specsDirectory: options.specsDirectory,
 			stallTimeout: options.stallTimeout,
 			cliAgent,
@@ -145324,6 +145380,74 @@ const run = fnUntraced(function* (options) {
 	if ((yield* prd.findById(taskId))?.autoMerge) yield* autoMerge;
 	else yield* prd.maybeRevertIssue({ issueId: taskId });
 }, scoped$1, provide$1([PromptGen.layer, Prd.layer]));
+const iterations = integer("iterations").pipe(withDescription$1("Number of iterations to run, defaults to unlimited"), withAlias("i"), withDefault(Number.POSITIVE_INFINITY));
+const concurrency = integer("concurrency").pipe(withDescription$1("Number of concurrent agents, defaults to 1"), withAlias("c"), withDefault(1));
+const targetBranch = string$1("target-branch").pipe(withDescription$1("Target branch for PRs. Defaults to current branch. Env variable: LALPH_TARGET_BRANCH"), withAlias("b"), withFallbackConfig(string$4("LALPH_TARGET_BRANCH")), withDefault(make$21`git branch --show-current`.pipe(string, orDie$2, flatMap((output) => {
+	const branch = output.trim();
+	return branch === "" ? fail$4(new MissingOption({ option: "--target-branch" })) : succeed$1(branch);
+}))), optional);
+const maxIterationMinutes = integer("max-minutes").pipe(withDescription$1("Maximum number of minutes to allow an iteration to run. Defaults to 90 minutes. Env variable: LALPH_MAX_MINUTES"), withFallbackConfig(int("LALPH_MAX_MINUTES")), withDefault(90));
+const stallMinutes = integer("stall-minutes").pipe(withDescription$1("If no activity occurs for this many minutes, the iteration will be stopped. Defaults to 5 minutes. Env variable: LALPH_STALL_MINUTES"), withFallbackConfig(int("LALPH_STALL_MINUTES")), withDefault(5));
+const specsDirectory = directory("specs").pipe(withDescription$1("Directory to store plan specifications. Env variable: LALPH_SPECS"), withAlias("s"), withFallbackConfig(string$4("LALPH_SPECS")), withDefault(".specs"));
+const verbose = boolean("verbose").pipe(withDescription$1("Enable verbose logging"), withAlias("v"));
+const review = boolean("review").pipe(withDescription$1("Enabled the AI peer-review step"));
+const reset = boolean("reset").pipe(withDescription$1("Reset the current issue source before running"), withAlias("r"));
+const commandRoot = make$28("lalph", {
+	iterations,
+	concurrency,
+	targetBranch,
+	maxIterationMinutes,
+	stallMinutes,
+	reset,
+	review,
+	specsDirectory,
+	verbose
+}).pipe(withHandler(fnUntraced(function* ({ iterations: iterations$1, concurrency: concurrency$1, targetBranch: targetBranch$1, maxIterationMinutes: maxIterationMinutes$1, stallMinutes: stallMinutes$1, specsDirectory: specsDirectory$1, review: review$1 }) {
+	const source = yield* build(CurrentIssueSource.layer);
+	const commandPrefix = yield* getCommandPrefix;
+	yield* getOrSelectCliAgent;
+	const isFinite$3 = Number.isFinite(iterations$1);
+	const iterationsDisplay = isFinite$3 ? iterations$1 : "unlimited";
+	const runConcurrency = Math.max(1, concurrency$1);
+	const semaphore = makeSemaphoreUnsafe(runConcurrency);
+	const fibers = yield* make$25();
+	yield* resetInProgress.pipe(provide$1(source), withSpan("Main.resetInProgress"));
+	yield* log$1(`Executing ${iterationsDisplay} iteration(s) with concurrency ${runConcurrency}`);
+	if (isSome(targetBranch$1)) yield* log$1(`Using target branch: ${targetBranch$1.value}`);
+	let iteration = 0;
+	let quit = false;
+	while (true) {
+		yield* semaphore.take(1);
+		if (quit || isFinite$3 && iteration >= iterations$1) break;
+		const currentIteration = iteration;
+		const startedDeferred = yield* make$49();
+		yield* checkForWork.pipe(andThen(run({
+			startedDeferred,
+			targetBranch: targetBranch$1,
+			specsDirectory: specsDirectory$1,
+			stallTimeout: minutes(stallMinutes$1),
+			runTimeout: minutes(maxIterationMinutes$1),
+			commandPrefix,
+			review: review$1
+		})), catchFilter((e) => e._tag === "NoMoreWork" || e._tag === "QuitError" ? fail$8(e) : e, (e) => logWarning(fail$5(e))), catchTags({
+			NoMoreWork(_) {
+				if (isFinite$3) {
+					iterations$1 = currentIteration;
+					return log$1(`No more work to process, ending after ${currentIteration} iteration(s).`);
+				}
+				const log$2 = size$1(fibers) <= 1 ? log$1("No more work to process, waiting 30 seconds...") : void_$1;
+				return andThen(log$2, sleep(seconds(30)));
+			},
+			QuitError(_) {
+				quit = true;
+				return void_$1;
+			}
+		}), annotateLogs({ iteration: currentIteration }), ensuring(semaphore.release(1)), ensuring(completeWith(startedDeferred, void_$1)), provide$1(source), run$1(fibers));
+		yield* _await(startedDeferred);
+		iteration++;
+	}
+	yield* awaitEmpty(fibers);
+}, scoped$1)));
 
 //#endregion
 //#region src/commands/plan.ts
@@ -145455,7 +145579,7 @@ const commandSource = make$28("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.1.96";
+var version = "0.1.98";
 
 //#endregion
 //#region src/Tracing.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.1.96",
+  "version": "0.1.98",
   "publishConfig": {
     "access": "public"
   },

package/src/Agents/chooser.ts

@@ -5,6 +5,7 @@ import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import { RunnerStalled } from "../domain/Errors.ts"
 import type { CliAgent } from "../domain/CliAgent.ts"
+import { makeWaitForFile } from "../shared/fs.ts"
 
 export const agentChooser = Effect.fnUntraced(function* (options: {
   readonly stallTimeout: Duration.Duration
@@ -18,6 +19,12 @@ export const agentChooser = Effect.fnUntraced(function* (options: {
   const worktree = yield* Worktree
   const promptGen = yield* PromptGen
   const prd = yield* Prd
+  const waitForFile = yield* makeWaitForFile
+
+  const taskJsonCreated = waitForFile(
+    pathService.join(worktree.directory, ".lalph"),
+    "task.json",
+  )
 
   yield* pipe(
     options.cliAgent.resolveCommandChoose({
@@ -31,6 +38,7 @@ export const agentChooser = Effect.fnUntraced(function* (options: {
       duration: options.stallTimeout,
       onTimeout: () => Effect.fail(new RunnerStalled()),
     }),
+    Effect.raceFirst(taskJsonCreated),
   )
 
   const taskJson = yield* fs.readFileString(

package/src/Agents/instructor.ts

@@ -4,6 +4,7 @@ import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgent } from "../domain/CliAgent.ts"
 import type { PrdIssue } from "../domain/PrdIssue.ts"
+import { makeWaitForFile } from "../shared/fs.ts"
 
 export const agentInstructor = Effect.fnUntraced(function* (options: {
   readonly targetBranch: Option.Option<string>
@@ -20,6 +21,7 @@ export const agentInstructor = Effect.fnUntraced(function* (options: {
   const pathService = yield* Path.Path
   const worktree = yield* Worktree
   const promptGen = yield* PromptGen
+  const waitForFile = yield* makeWaitForFile
 
   yield* pipe(
     options.cliAgent.command({
@@ -38,6 +40,12 @@ export const agentInstructor = Effect.fnUntraced(function* (options: {
       cliAgent: options.cliAgent,
       stallTimeout: options.stallTimeout,
     }),
+    Effect.raceFirst(
+      waitForFile(
+        pathService.join(worktree.directory, ".lalph"),
+        "instructions.md",
+      ),
+    ),
   )
   return yield* fs.readFileString(
     pathService.join(worktree.directory, ".lalph", "instructions.md"),

package/src/CliAgent/claude.ts

@@ -1,7 +1,7 @@
-import { Schema, Stream } from "effect"
 import type { OutputTransformer } from "../domain/CliAgent.ts"
-import { streamFilterJson } from "../shared/stream.ts"
+import { Option, pipe, Schema, Stream } from "effect"
 import { ansiColors } from "../shared/ansi-colors.ts"
+import { streamFilterJson } from "../shared/stream.ts"
 
 export const claudeOutputTransformer: OutputTransformer = (stream) =>
   stream.pipe(
@@ -9,12 +9,20 @@ export const claudeOutputTransformer: OutputTransformer = (stream) =>
     Stream.map((m) => m.format()),
   )
 
-// Schema definitions
-
 const ContentBlock = Schema.Struct({
   type: Schema.String,
   text: Schema.optional(Schema.String),
   name: Schema.optional(Schema.String),
+  input: Schema.optional(Schema.Unknown),
+  content: Schema.optional(Schema.String),
+  is_error: Schema.optional(Schema.Boolean),
+})
+
+const ToolUseResult = Schema.Struct({
+  stdout: Schema.optional(Schema.String),
+  stderr: Schema.optional(Schema.String),
+  interrupted: Schema.optional(Schema.Boolean),
+  isImage: Schema.optional(Schema.Boolean),
 })
 
 class StreamJsonMessage extends Schema.Class<StreamJsonMessage>(
@@ -27,17 +35,18 @@ class StreamJsonMessage extends Schema.Class<StreamJsonMessage>(
       content: Schema.optional(Schema.Array(ContentBlock)),
     }),
   ),
+  tool_use_result: Schema.optional(ToolUseResult),
   duration_ms: Schema.optional(Schema.Number),
   total_cost_usd: Schema.optional(Schema.Number),
 }) {
   format(): string {
     switch (this.type) {
       case "system":
-        return this.subtype === "init"
-          ? ansiColors.dim + "[Session started]" + ansiColors.reset + "\n"
-          : ""
+        return this.subtype === "init" ? dim("[Session started]") + "\n" : ""
       case "assistant":
         return formatAssistantMessage(this)
+      case "user":
+        return formatToolResult(this)
       case "result":
         return formatResult(this)
       default:
@@ -46,32 +55,179 @@ class StreamJsonMessage extends Schema.Class<StreamJsonMessage>(
   }
 }
 
-const formatToolName = (name: string): string =>
+const BashInput = Schema.Struct({ command: Schema.optional(Schema.String) })
+const FileInput = Schema.Struct({ file_path: Schema.optional(Schema.String) })
+const PatternInput = Schema.Struct({ pattern: Schema.optional(Schema.String) })
+const QuestionOption = Schema.Struct({
+  label: Schema.String,
+  description: Schema.optional(Schema.String),
+})
+const Question = Schema.Struct({
+  question: Schema.String,
+  header: Schema.optional(Schema.String),
+  options: Schema.optional(Schema.Array(QuestionOption)),
+})
+const AskUserQuestionInput = Schema.Struct({
+  questions: Schema.optional(Schema.Array(Question)),
+})
+
+const McpInputFields = [
+  "query",
+  "documentId",
+  "page",
+  "pattern",
+  "relative_path",
+  "name_path",
+  "file_path",
+  "root_path",
+] as const
+
+const truncate = (s: string, max: number) =>
+  s.length > max ? s.slice(0, max) + "..." : s
+
+const dim = (s: string) => ansiColors.dim + s + ansiColors.reset
+const cyan = (s: string) => ansiColors.cyan + s + ansiColors.reset
+const yellow = (s: string) => ansiColors.yellow + s + ansiColors.reset
+const green = (s: string) => ansiColors.green + s + ansiColors.reset
+
+const formatToolName = (name: string) =>
   name.replace("mcp__", "").replace(/__/g, ":")
 
+const withDetail = (display: string, detail: Option.Option<string>) =>
+  display + Option.getOrElse(detail, () => "")
+
+const formatBashInput = (input: unknown) =>
+  pipe(
+    Schema.decodeUnknownOption(BashInput)(input),
+    Option.flatMap((data) => Option.fromNullishOr(data.command)),
+    Option.filter((cmd) => cmd.length > 0),
+    Option.map((cmd) => dim("$ " + truncate(cmd, 100)) + "\n"),
+  )
+
+const formatFileInput = (input: unknown) =>
+  pipe(
+    Schema.decodeUnknownOption(FileInput)(input),
+    Option.flatMap((data) => Option.fromNullishOr(data.file_path)),
+    Option.filter((path) => path.length > 0),
+    Option.map((path) => dim(path) + "\n"),
+  )
+
+const formatPatternInput = (input: unknown) =>
+  pipe(
+    Schema.decodeUnknownOption(PatternInput)(input),
+    Option.flatMap((data) => Option.fromNullishOr(data.pattern)),
+    Option.filter((pattern) => pattern.length > 0),
+    Option.map((pattern) => dim(pattern) + "\n"),
+  )
+
+const formatMcpInput = (input: unknown): Option.Option<string> => {
+  if (typeof input !== "object" || input === null) return Option.none()
+  const data = input as Record<string, unknown>
+  const parts = McpInputFields.flatMap((field) =>
+    Option.match(Option.fromNullishOr(data[field]), {
+      onNone: () => [],
+      onSome: (value) => [`${field}=${truncate(String(value), 50)}`],
+    }),
+  )
+  return parts.length > 0
+    ? Option.some(dim(parts.join(" ")) + "\n")
+    : Option.none()
+}
+
+const formatGenericInput = (input: unknown) =>
+  pipe(
+    Option.fromNullishOr(input),
+    Option.map((v) => dim(truncate(JSON.stringify(v), 100)) + "\n"),
+  )
+
+type DecodedQuestion = typeof Question.Encoded
+
+const formatUserQuestion = (input: unknown) =>
+  pipe(
+    Schema.decodeUnknownOption(AskUserQuestionInput)(input),
+    Option.flatMap((data) => Option.fromNullishOr(data.questions)),
+    Option.map((questions) =>
+      questions
+        .map((q: DecodedQuestion) => {
+          let result = "\n" + yellow("⚠ WAITING FOR INPUT") + "\n"
+          result += cyan((q.header ? `[${q.header}] ` : "") + q.question) + "\n"
+          if (q.options) {
+            result +=
+              q.options
+                .map(
+                  (opt, i) =>
+                    `  ${i + 1}. ${opt.label}${opt.description ? dim(` - ${opt.description}`) : ""}`,
+                )
+                .join("\n") + "\n"
+          }
+          return result
+        })
+        .join("\n"),
+    ),
+    Option.getOrElse(() => ""),
+  )
+
+const formatToolInput = (name: string, input: unknown): string => {
+  const display = "\n" + cyan("▶ " + formatToolName(name)) + "\n"
+
+  if (name === "Bash") return withDetail(display, formatBashInput(input))
+  if (name === "AskUserQuestion") return display + formatUserQuestion(input)
+  if (name === "Read" || name === "Write" || name === "Edit")
+    return withDetail(display, formatFileInput(input))
+  if (name === "Grep" || name === "Glob")
+    return withDetail(display, formatPatternInput(input))
+  if (name.startsWith("mcp__"))
+    return withDetail(display, formatMcpInput(input))
+  return withDetail(display, formatGenericInput(input))
+}
+
 const formatAssistantMessage = (msg: StreamJsonMessage): string => {
   const content = msg.message?.content
   if (!content) return ""
-
   return content
     .map((block) => {
-      if (block.type === "text" && block.text) {
-        return block.text
-      } else if (block.type === "tool_use" && block.name) {
-        return (
-          "\n" +
-          ansiColors.cyan +
-          "▶ " +
-          formatToolName(block.name) +
-          ansiColors.reset +
-          "\n"
-        )
-      }
+      if (block.type === "text" && block.text) return block.text
+      if (block.type === "tool_use" && block.name)
+        return formatToolInput(block.name, block.input)
       return ""
     })
     .join("")
 }
 
+const formatLongOutput = (text: string): string => {
+  const lines = text.trim().split("\n")
+  if (lines.length > 8) {
+    const preview = [
+      ...lines.slice(0, 4),
+      `... (${lines.length - 7} more lines)`,
+      ...lines.slice(-3),
+    ].join("\n")
+    return dim(preview) + "\n"
+  }
+  return text.length > 500 ? dim(truncate(text, 500)) + "\n" : dim(text) + "\n"
+}
+
+const formatToolResult = (msg: StreamJsonMessage): string => {
+  let output = ""
+  const result = msg.tool_use_result
+  if (result) {
+    if (result.stderr?.trim())
+      output += yellow("stderr: ") + truncate(result.stderr.trim(), 500) + "\n"
+    if (result.interrupted) output += yellow("[interrupted]") + "\n"
+    if (result.stdout?.trim()) output += formatLongOutput(result.stdout.trim())
+  }
+  const content = msg.message?.content
+  if (content) {
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        if (block.is_error) output += yellow("✗ Tool error") + "\n"
+        if (block.content) output += formatLongOutput(block.content)
+      }
+    }
+  }
+  return output
+}
+
 const formatResult = (msg: StreamJsonMessage): string => {
   if (msg.subtype === "success") {
     const duration = msg.duration_ms
@@ -79,19 +235,8 @@ const formatResult = (msg: StreamJsonMessage): string => {
       : ""
     const cost = msg.total_cost_usd ? "$" + msg.total_cost_usd.toFixed(4) : ""
     const info = [duration, cost].filter(Boolean).join(" | ")
-    return (
-      "\n" +
-      ansiColors.green +
-      "✓ Done" +
-      ansiColors.reset +
-      " " +
-      ansiColors.dim +
-      info +
-      ansiColors.reset +
-      "\n"
-    )
-  } else if (msg.subtype === "error") {
-    return "\n" + ansiColors.yellow + "✗ Error" + ansiColors.reset + "\n"
+    return "\n" + green("✓ Done") + " " + dim(info) + "\n"
   }
+  if (msg.subtype === "error") return "\n" + yellow("✗ Error") + "\n"
   return ""
 }

package/src/commands/root.ts

@@ -28,6 +28,174 @@ import { RunnerStalled } from "../domain/Errors.ts"
 import { agentReviewer } from "../Agents/reviewer.ts"
 import { agentTimeout } from "../Agents/timeout.ts"
 
+// Main iteration run logic
+
+const run = Effect.fnUntraced(
+  function* (options: {
+    readonly startedDeferred: Deferred.Deferred<void>
+    readonly targetBranch: Option.Option<string>
+    readonly specsDirectory: string
+    readonly stallTimeout: Duration.Duration
+    readonly runTimeout: Duration.Duration
+    readonly commandPrefix: (
+      command: ChildProcess.Command,
+    ) => ChildProcess.Command
+    readonly review: boolean
+  }) {
+    const fs = yield* FileSystem.FileSystem
+    const pathService = yield* Path.Path
+    const worktree = yield* Worktree
+    const gh = yield* GithubCli
+    const cliAgent = yield* getOrSelectCliAgent
+    const prd = yield* Prd
+    const source = yield* IssueSource
+
+    if (Option.isSome(options.targetBranch)) {
+      const targetWithRemote = options.targetBranch.value.includes("/")
+        ? options.targetBranch.value
+        : `origin/${options.targetBranch.value}`
+      yield* worktree.exec`git checkout ${targetWithRemote}`
+    }
+
+    // ensure cleanup of branch after run
+    yield* Effect.addFinalizer(
+      Effect.fnUntraced(function* () {
+        const currentBranchName = yield* worktree
+          .currentBranch(worktree.directory)
+          .pipe(Effect.option, Effect.map(Option.getOrUndefined))
+        if (!currentBranchName) return
+
+        // enter detached state
+        yield* worktree.exec`git checkout --detach ${currentBranchName}`
+        // delete the branch
+        yield* worktree.exec`git branch -D ${currentBranchName}`
+      }, Effect.ignore),
+    )
+
+    let taskId: string | undefined = undefined
+
+    // setup finalizer to revert issue if we fail
+    yield* Effect.addFinalizer(
+      Effect.fnUntraced(function* (exit) {
+        if (exit._tag === "Success") return
+        const prd = yield* Prd
+        if (taskId) {
+          yield* prd.maybeRevertIssue({
+            issueId: taskId,
+          })
+        } else {
+          yield* prd.revertUpdatedIssues
+        }
+      }, Effect.ignore),
+    )
+
+    // 1. Choose task
+    const chosenTask = yield* agentChooser({
+      stallTimeout: options.stallTimeout,
+      commandPrefix: options.commandPrefix,
+      cliAgent,
+    })
+    taskId = chosenTask.id
+    yield* prd.setChosenIssueId(taskId)
+
+    yield* source.ensureInProgress(taskId).pipe(
+      Effect.timeoutOrElse({
+        duration: "1 minute",
+        onTimeout: () => Effect.fail(new RunnerStalled()),
+      }),
+    )
+
+    yield* Deferred.completeWith(options.startedDeferred, Effect.void)
+
+    if (chosenTask.githubPrNumber) {
+      yield* worktree.exec`gh pr checkout ${chosenTask.githubPrNumber}`
+      const feedback = yield* gh.prFeedbackMd(chosenTask.githubPrNumber)
+      yield* fs.writeFileString(
+        pathService.join(worktree.directory, ".lalph", "feedback.md"),
+        feedback,
+      )
+    }
+
+    // 2. Generate instructions
+    const instructions = yield* agentInstructor({
+      stallTimeout: options.stallTimeout,
+      commandPrefix: options.commandPrefix,
+      specsDirectory: options.specsDirectory,
+      targetBranch: options.targetBranch,
+      task: chosenTask.prd,
+      cliAgent,
+      githubPrNumber: chosenTask.githubPrNumber ?? undefined,
+    })
+
+    yield* Effect.gen(function* () {
+      // 3. Work on task
+      const exitCode = yield* agentWorker({
+        specsDirectory: options.specsDirectory,
+        stallTimeout: options.stallTimeout,
+        cliAgent,
+        commandPrefix: options.commandPrefix,
+        instructions,
+      })
+      yield* Effect.log(`Agent exited with code: ${exitCode}`)
+
+      // 4. Review task
+      if (options.review) {
+        yield* agentReviewer({
+          specsDirectory: options.specsDirectory,
+          stallTimeout: options.stallTimeout,
+          cliAgent,
+          commandPrefix: options.commandPrefix,
+          instructions,
+        })
+      }
+    }).pipe(
+      Effect.timeout(options.runTimeout),
+      Effect.tapErrorTag("TimeoutError", () =>
+        agentTimeout({
+          specsDirectory: options.specsDirectory,
+          stallTimeout: options.stallTimeout,
+          cliAgent,
+          commandPrefix: options.commandPrefix,
+          task: chosenTask.prd,
+        }),
+      ),
+    )
+
+    // Auto-merge logic
+
+    const autoMerge = Effect.gen(function* () {
+      let prState = yield* worktree.viewPrState()
+      yield* Effect.log("PR state", prState)
+      if (Option.isNone(prState)) {
+        return yield* prd.maybeRevertIssue({ issueId: taskId })
+      }
+      if (Option.isSome(options.targetBranch)) {
+        yield* worktree.exec`gh pr edit --base ${options.targetBranch.value}`
+      }
+      yield* worktree.exec`gh pr merge -sd`
+      yield* Effect.sleep(Duration.seconds(3))
+      prState = yield* worktree.viewPrState(prState.value.number)
+      yield* Effect.log("PR state after merge", prState)
+      if (Option.isSome(prState) && prState.value.state === "MERGED") {
+        return
+      }
+      yield* Effect.log("Flagging unmergable PR")
+      yield* prd.flagUnmergable({ issueId: taskId })
+    }).pipe(Effect.annotateLogs({ phase: "autoMerge" }))
+
+    const task = yield* prd.findById(taskId)
+    if (task?.autoMerge) {
+      yield* autoMerge
+    } else {
+      yield* prd.maybeRevertIssue({ issueId: taskId })
+    }
+  },
+  Effect.scoped,
+  Effect.provide([PromptGen.layer, Prd.layer]),
+)
+
+// Command
+
 const iterations = Flag.integer("iterations").pipe(
   Flag.withDescription("Number of iterations to run, defaults to unlimited"),
   Flag.withAlias("i"),
@@ -95,6 +263,10 @@ const verbose = Flag.boolean("verbose").pipe(
   Flag.withAlias("v"),
 )
 
+const review = Flag.boolean("review").pipe(
+  Flag.withDescription("Enabled the AI peer-review step"),
+)
+
 // handled in cli.ts
 const reset = Flag.boolean("reset").pipe(
   Flag.withDescription("Reset the current issue source before running"),
@@ -108,6 +280,7 @@ export const commandRoot = Command.make("lalph", {
   maxIterationMinutes,
   stallMinutes,
   reset,
+  review,
   specsDirectory,
   verbose,
 }).pipe(
@@ -119,6 +292,7 @@ export const commandRoot = Command.make("lalph", {
       maxIterationMinutes,
       stallMinutes,
       specsDirectory,
+      review,
     }) {
       const source = yield* Layer.build(CurrentIssueSource.layer)
       const commandPrefix = yield* getCommandPrefix
@@ -164,6 +338,7 @@ export const commandRoot = Command.make("lalph", {
               stallTimeout: Duration.minutes(stallMinutes),
               runTimeout: Duration.minutes(maxIterationMinutes),
               commandPrefix,
+              review,
             }),
           ),
           Effect.catchFilter(
@@ -212,164 +387,3 @@ export const commandRoot = Command.make("lalph", {
     }, Effect.scoped),
   ),
 )
-
-const run = Effect.fnUntraced(
-  function* (options: {
-    readonly startedDeferred: Deferred.Deferred<void>
-    readonly targetBranch: Option.Option<string>
-    readonly specsDirectory: string
-    readonly stallTimeout: Duration.Duration
-    readonly runTimeout: Duration.Duration
-    readonly commandPrefix: (
-      command: ChildProcess.Command,
-    ) => ChildProcess.Command
-  }) {
-    const fs = yield* FileSystem.FileSystem
-    const pathService = yield* Path.Path
-    const worktree = yield* Worktree
-    const gh = yield* GithubCli
-    const cliAgent = yield* getOrSelectCliAgent
-    const prd = yield* Prd
-    const source = yield* IssueSource
-
-    if (Option.isSome(options.targetBranch)) {
-      const targetWithRemote = options.targetBranch.value.includes("/")
-        ? options.targetBranch.value
-        : `origin/${options.targetBranch.value}`
-      yield* worktree.exec`git checkout ${targetWithRemote}`
-    }
-
-    // ensure cleanup of branch after run
-    yield* Effect.addFinalizer(
-      Effect.fnUntraced(function* () {
-        const currentBranchName = yield* worktree
-          .currentBranch(worktree.directory)
-          .pipe(Effect.option, Effect.map(Option.getOrUndefined))
-        if (!currentBranchName) return
-
-        // enter detached state
-        yield* worktree.exec`git checkout --detach ${currentBranchName}`
-        // delete the branch
-        yield* worktree.exec`git branch -D ${currentBranchName}`
-      }, Effect.ignore),
-    )
-
-    let taskId: string | undefined = undefined
-
-    // setup finalizer to revert issue if we fail
-    yield* Effect.addFinalizer(
-      Effect.fnUntraced(function* (exit) {
-        if (exit._tag === "Success") return
-        const prd = yield* Prd
-        if (taskId) {
-          yield* prd.maybeRevertIssue({
-            issueId: taskId,
-          })
-        } else {
-          yield* prd.revertUpdatedIssues
-        }
-      }, Effect.ignore),
-    )
-
-    // 1. Choose task
-    const chosenTask = yield* agentChooser({
-      stallTimeout: options.stallTimeout,
-      commandPrefix: options.commandPrefix,
-      cliAgent,
-    })
-    taskId = chosenTask.id
-    yield* prd.setChosenIssueId(taskId)
-
-    yield* source.ensureInProgress(taskId).pipe(
-      Effect.timeoutOrElse({
-        duration: "1 minute",
-        onTimeout: () => Effect.fail(new RunnerStalled()),
-      }),
-    )
-
-    yield* Deferred.completeWith(options.startedDeferred, Effect.void)
-
-    if (chosenTask.githubPrNumber) {
-      yield* worktree.exec`gh pr checkout ${chosenTask.githubPrNumber}`
-      const feedback = yield* gh.prFeedbackMd(chosenTask.githubPrNumber)
-      yield* fs.writeFileString(
-        pathService.join(worktree.directory, ".lalph", "feedback.md"),
-        feedback,
-      )
-    }
-
-    // 2. Generate instructions
-    const instructions = yield* agentInstructor({
-      stallTimeout: options.stallTimeout,
-      commandPrefix: options.commandPrefix,
-      specsDirectory: options.specsDirectory,
-      targetBranch: options.targetBranch,
-      task: chosenTask.prd,
-      cliAgent,
-      githubPrNumber: chosenTask.githubPrNumber ?? undefined,
-    })
-
-    yield* Effect.gen(function* () {
-      // 3. Work on task
-      const exitCode = yield* agentWorker({
-        specsDirectory: options.specsDirectory,
-        stallTimeout: options.stallTimeout,
-        cliAgent,
-        commandPrefix: options.commandPrefix,
-        instructions,
-      })
-      yield* Effect.log(`Agent exited with code: ${exitCode}`)
-
-      // 4. Review task
-      yield* agentReviewer({
-        specsDirectory: options.specsDirectory,
-        stallTimeout: options.stallTimeout,
-        cliAgent,
-        commandPrefix: options.commandPrefix,
-        instructions,
-      })
-    }).pipe(
-      Effect.timeout(options.runTimeout),
-      Effect.tapErrorTag("TimeoutError", () =>
-        agentTimeout({
-          specsDirectory: options.specsDirectory,
-          stallTimeout: options.stallTimeout,
-          cliAgent,
-          commandPrefix: options.commandPrefix,
-          task: chosenTask.prd,
-        }),
-      ),
-    )
-
-    // Auto-merge logic
-
-    const autoMerge = Effect.gen(function* () {
-      let prState = yield* worktree.viewPrState()
-      yield* Effect.log("PR state", prState)
-      if (Option.isNone(prState)) {
-        return yield* prd.maybeRevertIssue({ issueId: taskId })
-      }
-      if (Option.isSome(options.targetBranch)) {
-        yield* worktree.exec`gh pr edit --base ${options.targetBranch.value}`
-      }
-      yield* worktree.exec`gh pr merge -sd`
-      yield* Effect.sleep(Duration.seconds(3))
-      prState = yield* worktree.viewPrState(prState.value.number)
-      yield* Effect.log("PR state after merge", prState)
-      if (Option.isSome(prState) && prState.value.state === "MERGED") {
-        return
-      }
-      yield* Effect.log("Flagging unmergable PR")
-      yield* prd.flagUnmergable({ issueId: taskId })
-    }).pipe(Effect.annotateLogs({ phase: "autoMerge" }))
-
-    const task = yield* prd.findById(taskId)
-    if (task?.autoMerge) {
-      yield* autoMerge
-    } else {
-      yield* prd.maybeRevertIssue({ issueId: taskId })
-    }
-  },
-  Effect.scoped,
-  Effect.provide([PromptGen.layer, Prd.layer]),
-)

package/src/domain/CliAgent.ts

@@ -77,7 +77,7 @@ const claude = new CliAgent({
       stdout: outputMode,
       stderr: outputMode,
       stdin: "inherit",
-    })`claude --dangerously-skip-permissions --output-format stream-json --verbose -p ${`@${prdFilePath}
+    })`claude --dangerously-skip-permissions --output-format stream-json --verbose --disallowed-tools AskUserQuestion -p ${`@${prdFilePath}
 
 ${prompt}`}`,
   outputTransformer: claudeOutputTransformer,

package/src/shared/fs.ts

@@ -0,0 +1,12 @@
+import { Effect, FileSystem, Path, pipe, Stream } from "effect"
+
+export const makeWaitForFile = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem
+  const pathService = yield* Path.Path
+  return (directory: string, name: string) =>
+    pipe(
+      fs.watch(directory),
+      Stream.filter((e) => pathService.basename(e.path) === name),
+      Stream.runHead,
+    )
+})