lalph 0.3.85 → 0.3.86

package/dist/cli.mjs

@@ -9478,6 +9478,23 @@ const forEachSequential = (iterable, f, options) => suspend$4(() => {
 });
 const filterOrElse$1 = /* @__PURE__ */ dual(3, (self, predicate, orElse) => flatMap$6(self, (a) => predicate(a) ? succeed$7(a) : orElse(a)));
 /** @internal */
+const filter$6 = /* @__PURE__ */ dual((args) => isIterable(args[0]) && !isEffect$1(args[0]), (elements, predicate, options) => suspend$4(() => {
+	const out = [];
+	return as$2(forEach$5(elements, (a, i) => {
+		const result = predicate(a, i);
+		if (typeof result === "boolean") {
+			if (result) out.push(a);
+			return void_$4;
+		}
+		return map$12(result, (keep) => {
+			if (keep) out.push(a);
+		});
+	}, {
+		discard: true,
+		concurrency: options?.concurrency
+	}), out);
+}));
+/** @internal */
 const filterMapEffect$2 = /* @__PURE__ */ dual((args) => isIterable(args[0]) && !isEffect$1(args[0]), (elements, filter, options) => suspend$4(() => {
 	const out = [];
 	return as$2(forEach$5(elements, (a) => map$12(filter(a), (result) => {
@@ -14539,6 +14556,28 @@ const withFiber = withFiber$1;
 */
 const fromOption = fromOption$1;
 /**
+* Converts a yieldable value to an Effect.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+* import * as Option from "effect/Option"
+*
+* // Option is yieldable in Effect
+* const program = Effect.gen(function*() {
+*   const value = yield* Effect.fromYieldable(Option.some(42))
+*   return value * 2
+* })
+*
+* Effect.runPromise(program).then(console.log)
+* // Output: 84
+* ```
+*
+* @since 4.0.0
+* @category Conversions
+*/
+const fromYieldable = fromYieldable$1;
+/**
 * Chains effects to produce new `Effect` instances, useful for combining
 * operations that depend on previous results.
 *
@@ -14996,6 +15035,53 @@ const asSome = asSome$1;
 * @category Mapping
 */
 const asVoid = asVoid$2;
+/**
+* Combines two effects sequentially and applies a function to their results to
+* produce a single value.
+*
+* **When to Use**
+*
+* The `zipWith` function is similar to {@link zip}, but instead of returning a
+* tuple of results, it applies a provided function to the results of the two
+* effects, combining them into a single value.
+*
+* **Concurrency**
+*
+* By default, the effects are run sequentially. To execute them concurrently,
+* use the `{ concurrent: true }` option.
+*
+* @example
+* ```ts
+* // Title: Combining Effects with a Custom Function
+* import { Effect } from "effect"
+*
+* const task1 = Effect.succeed(1).pipe(
+*   Effect.delay("200 millis"),
+*   Effect.tap(Effect.log("task1 done"))
+* )
+* const task2 = Effect.succeed("hello").pipe(
+*   Effect.delay("100 millis"),
+*   Effect.tap(Effect.log("task2 done"))
+* )
+*
+* const task3 = Effect.zipWith(
+*   task1,
+*   task2,
+*   // Combines results into a single value
+*   (number, string) => number + string.length
+* )
+*
+* Effect.runPromise(task3).then(console.log)
+* // Output:
+* // timestamp=... level=INFO fiber=#3 message="task1 done"
+* // timestamp=... level=INFO fiber=#2 message="task2 done"
+* // 6
+* ```
+*
+* @since 2.0.0
+* @category Zipping
+*/
+const zipWith = zipWith$1;
 const catch_$2 = catch_$3;
 /**
 * Catches and handles specific errors by their `_tag` field, which is used as a
@@ -15766,6 +15852,27 @@ const sleep = sleep$1;
 */
 const raceFirst = raceFirst$1;
 /**
+* Filters elements of an iterable using a predicate, refinement, or effectful
+* predicate.
+*
+* @example
+* ```ts
+* import { Effect } from "effect"
+*
+* // Sync predicate
+* const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
+*
+* // Effectful predicate
+* const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
+*
+* // Use Effect.filterMapEffect for effectful Filter.Filter callbacks
+* ```
+*
+* @since 2.0.0
+* @category Filtering
+*/
+const filter$5 = filter$6;
+/**
 * Effectfully filters and maps elements of an iterable with a `FilterEffect`.
 *
 * @since 4.0.0
@@ -49589,6 +49696,33 @@ const custom$1 = (initialState, handlers) => {
 * @since 4.0.0
 * @category constructors
 */
+const file$3 = (options = {}) => {
+	const opts = {
+		type: options.type ?? "file",
+		message: options.message ?? `Choose a file`,
+		startingPath: fromUndefinedOr(options.startingPath),
+		maxPerPage: options.maxPerPage ?? 10,
+		filter: options.filter ?? (() => succeed$3(true))
+	};
+	return custom$1(gen(function* () {
+		const files = yield* getFileList(yield* resolveCurrentPath(none$4(), opts), opts);
+		const confirm = Confirm.Hide();
+		return {
+			cursor: 0,
+			files,
+			path: none$4(),
+			confirm
+		};
+	}), {
+		render: handleFileRender(opts),
+		process: handleFileProcess(opts),
+		clear: handleFileClear(opts)
+	});
+};
+/**
+* @since 4.0.0
+* @category constructors
+*/
 const integer$3 = (options) => {
 	const opts = {
 		min: Number.NEGATIVE_INFINITY,
@@ -49793,6 +49927,41 @@ const clearOutputWithError = (outputText, columns, errorText) => {
 };
 const renderBeep = "\x07";
 const NEWLINE_REGEXP = /\r?\n/;
+const CONFIRM_MESSAGE = "The selected directory contains files. Would you like to traverse the selected directory?";
+const Confirm = /* @__PURE__ */ taggedEnum();
+const showConfirmation = /* @__PURE__ */ Confirm.$is("Show");
+const resolveCurrentPath = (path, options) => {
+	if (isSome(path)) return succeed$3(path.value);
+	if (isSome(options.startingPath)) {
+		const startingPath = options.startingPath.value;
+		return flatMap$4(FileSystem.asEffect(), (fs) => orDie$2(fs.exists(startingPath)).pipe(flatMap$4((exists) => exists ? void_$2 : die$2(`The provided starting path '${startingPath}' does not exist`)), as$1(startingPath)));
+	}
+	return sync(() => process.cwd());
+};
+const getFileList = /* @__PURE__ */ fnUntraced(function* (directory, options) {
+	const fs = yield* FileSystem;
+	const path = yield* Path$1;
+	const files = yield* orDie$2(fs.readDirectory(directory)).pipe(map$9((files) => ["..", ...files]));
+	return yield* filter$5(files, (file) => {
+		const result = options.filter(file);
+		return zipWith(isEffect(result) ? result : succeed$3(result), options.type === "directory" ? map$9(orDie$2(fs.stat(path.join(directory, file))), (info) => info.type === "Directory") : succeed$3(true), (a, b) => a && b);
+	}, { concurrency: files.length });
+});
+const handleFileClear = (options) => {
+	return fnUntraced(function* (state, _) {
+		const columns = yield* (yield* Terminal).columns;
+		const path = yield* Path$1;
+		const figures = yield* platformFigures;
+		const currentPath = yield* resolveCurrentPath(state.path, options);
+		const selectedPath = state.files[state.cursor];
+		const resolvedPath = path.resolve(currentPath, selectedPath);
+		const resolvedPathText = `${figures.pointerSmall} ${resolvedPath}`;
+		const isConfirming = showConfirmation(state.confirm);
+		const promptText = isConfirming ? renderPrompt("(Y/n)", CONFIRM_MESSAGE, "?", figures.pointerSmall, { plain: true }) : renderPrompt("", options.message, figures.tick, figures.ellipsis, { plain: true });
+		const filesText = isConfirming ? "" : renderFiles(state, state.files, figures, options, { plain: true });
+		return eraseText(isConfirming ? `${promptText}\n${resolvedPathText}` : `${promptText}\n${resolvedPathText}\n${filesText}`, columns) + (eraseLine + cursorLeft);
+	});
+};
 const renderPrompt = (confirm, message, leadingSymbol, trailingSymbol, options) => {
 	const prefix = leadingSymbol + " ";
 	const annotate = options?.plain === true ? (line) => line : annotateLine;
@@ -49803,6 +49972,137 @@ const renderPrompt = (confirm, message, leadingSymbol, trailingSymbol, options)
 		}
 	});
 };
+const renderPrefix = (state, toDisplay, currentIndex, length, figures, renderOptions) => {
+	let prefix = " ";
+	if (currentIndex === toDisplay.startIndex && toDisplay.startIndex > 0) prefix = figures.arrowUp;
+	else if (currentIndex === toDisplay.endIndex - 1 && toDisplay.endIndex < length) prefix = figures.arrowDown;
+	if (state.cursor === currentIndex) return renderOptions?.plain === true ? figures.pointer + prefix : annotate(figures.pointer, cyanBright) + prefix;
+	return prefix + " ";
+};
+const renderFileName = (file, isSelected, renderOptions) => {
+	if (renderOptions?.plain === true) return file;
+	return isSelected ? annotate(file, combine(underlined, cyanBright)) : file;
+};
+const renderFiles = (state, files, figures, options, renderOptions) => {
+	const length = files.length;
+	const toDisplay = entriesToDisplay(state.cursor, length, options.maxPerPage);
+	const documents = [];
+	for (let index = toDisplay.startIndex; index < toDisplay.endIndex; index++) {
+		const isSelected = state.cursor === index;
+		const prefix = renderPrefix(state, toDisplay, index, length, figures, renderOptions);
+		const fileName = renderFileName(files[index], isSelected, renderOptions);
+		documents.push(prefix + fileName);
+	}
+	return documents.join("\n");
+};
+const renderFileNextFrame = /* @__PURE__ */ fnUntraced(function* (state, options) {
+	const path = yield* Path$1;
+	const figures = yield* platformFigures;
+	const currentPath = yield* resolveCurrentPath(state.path, options);
+	const selectedPath = state.files[state.cursor];
+	const resolvedPath = path.resolve(currentPath, selectedPath);
+	const resolvedPathMsg = annotate(figures.pointerSmall + " " + resolvedPath, blackBright);
+	if (showConfirmation(state.confirm)) {
+		const leadingSymbol = annotate("?", cyanBright);
+		const trailingSymbol = annotate(figures.pointerSmall, blackBright);
+		return cursorHide + renderPrompt(annotate("(Y/n)", blackBright), CONFIRM_MESSAGE, leadingSymbol, trailingSymbol) + "\n" + resolvedPathMsg;
+	}
+	const leadingSymbol = annotate(figures.tick, green$1);
+	const trailingSymbol = annotate(figures.ellipsis, blackBright);
+	const promptMsg = renderPrompt("", options.message, leadingSymbol, trailingSymbol);
+	const files = renderFiles(state, state.files, figures, options);
+	return cursorHide + promptMsg + "\n" + resolvedPathMsg + "\n" + files;
+});
+const renderFileSubmission = /* @__PURE__ */ fnUntraced(function* (value, options) {
+	const figures = yield* platformFigures;
+	const leadingSymbol = annotate(figures.tick, green$1);
+	const trailingSymbol = annotate(figures.ellipsis, blackBright);
+	return renderPrompt("", options.message, leadingSymbol, trailingSymbol) + " " + annotate(value, white) + "\n";
+});
+const handleFileRender = (options) => {
+	return (_, action) => {
+		return Action.$match(action, {
+			Beep: () => succeed$3(renderBeep),
+			NextFrame: ({ state }) => renderFileNextFrame(state, options),
+			Submit: ({ value }) => renderFileSubmission(value, options)
+		});
+	};
+};
+const processFileCursorUp = (state) => {
+	const cursor = state.cursor - 1;
+	return succeed$3(Action.NextFrame({ state: {
+		...state,
+		cursor: cursor < 0 ? state.files.length - 1 : cursor
+	} }));
+};
+const processFileCursorDown = (state) => {
+	return succeed$3(Action.NextFrame({ state: {
+		...state,
+		cursor: (state.cursor + 1) % state.files.length
+	} }));
+};
+const processSelection = /* @__PURE__ */ fnUntraced(function* (state, options) {
+	const fs = yield* FileSystem;
+	const path = yield* Path$1;
+	const currentPath = yield* resolveCurrentPath(state.path, options);
+	const selectedPath = state.files[state.cursor];
+	const resolvedPath = path.resolve(currentPath, selectedPath);
+	if ((yield* orDie$2(fs.stat(resolvedPath))).type === "Directory") {
+		const files = yield* getFileList(resolvedPath, options);
+		const filesWithoutParent = files.filter((file) => file !== "..");
+		if (options.type === "directory" || options.type === "either") return filesWithoutParent.length === 0 ? Action.Submit({ value: resolvedPath }) : Action.NextFrame({ state: {
+			...state,
+			confirm: Confirm.Show()
+		} });
+		return Action.NextFrame({ state: {
+			cursor: 0,
+			files,
+			path: some$2(resolvedPath),
+			confirm: Confirm.Hide()
+		} });
+	}
+	return Action.Submit({ value: resolvedPath });
+});
+const handleFileProcess = (options) => {
+	return fnUntraced(function* (input, state) {
+		switch (input.key.name) {
+			case "k":
+			case "up": return yield* processFileCursorUp(state);
+			case "j":
+			case "down":
+			case "tab": return yield* processFileCursorDown(state);
+			case "enter":
+			case "return": return yield* processSelection(state, options);
+			case "y":
+			case "t":
+				if (showConfirmation(state.confirm)) {
+					const path = yield* Path$1;
+					const currentPath = yield* resolveCurrentPath(state.path, options);
+					const selectedPath = state.files[state.cursor];
+					const resolvedPath = path.resolve(currentPath, selectedPath);
+					const files = yield* getFileList(resolvedPath, options);
+					return Action.NextFrame({ state: {
+						cursor: 0,
+						files,
+						path: some$2(resolvedPath),
+						confirm: Confirm.Hide()
+					} });
+				}
+				return Action.Beep();
+			case "n":
+			case "f":
+				if (showConfirmation(state.confirm)) {
+					const path = yield* Path$1;
+					const currentPath = yield* resolveCurrentPath(state.path, options);
+					const selectedPath = state.files[state.cursor];
+					const resolvedPath = path.resolve(currentPath, selectedPath);
+					return Action.Submit({ value: resolvedPath });
+				}
+				return Action.Beep();
+			default: return Action.Beep();
+		}
+	});
+};
 const renderMultiSelectError = (state, pointer, renderOptions) => {
 	if (isSome(state.error)) return match$7(state.error.value.split(NEWLINE_REGEXP), {
 		onEmpty: () => "",
@@ -90884,15 +91184,27 @@ const PlatformServices = layer$16;
 //#endregion
 //#region src/domain/Project.ts
 const ProjectId = String$1.pipe(brand("lalph/ProjectId"));
-var Project$2 = class extends Class$2("lalph/Project")({
+var Project$2 = class Project$2 extends Class$2("lalph/Project")({
 	id: ProjectId,
 	enabled: Boolean$2,
 	targetBranch: Option(String$1),
 	concurrency: Int.check(isGreaterThanOrEqualTo(1)),
-	gitFlow: Literals(["pr", "commit"]),
+	gitFlow: Literals([
+		"pr",
+		"commit",
+		"ralph"
+	]),
+	ralphSpec: optional$3(String$1),
 	researchAgent: Boolean$2.pipe(withDecodingDefault(() => false)),
 	reviewAgent: Boolean$2
-}) {};
+}) {
+	update(updates) {
+		return new Project$2({
+			...this,
+			...updates
+		});
+	}
+};
 //#endregion
 //#region src/shared/lalphDirectory.ts
 const findProjectRoot = fnUntraced(function* (cwd) {
@@ -91131,8 +91443,7 @@ ${prompt}`], {
 			prompt,
 			"--thinking",
 			...extraArgs,
-			"-f",
-			prdFilePath
+			...prdFilePath ? ["-f", prdFilePath] : []
 		], {
 			extendEnv: true,
 			env: { OPENCODE_PERMISSION: "{\"*\":\"allow\", \"question\":\"deny\"}" },
@@ -91140,9 +91451,9 @@ ${prompt}`], {
 			stderr: "pipe",
 			stdin: "inherit"
 		}),
-		commandPlan: ({ prompt, prdFilePath, dangerous }) => make$45("opencode", ["--prompt", `@${prdFilePath}
+		commandPlan: ({ prompt, prdFilePath, dangerous }) => make$45("opencode", ["--prompt", prdFilePath ? `@${prdFilePath}
 
-${prompt}`], {
+${prompt}` : prompt], {
 			extendEnv: true,
 			...dangerous ? { env: { OPENCODE_PERMISSION: "{\"*\":\"allow\"}" } } : {},
 			stdout: "inherit",
@@ -91162,9 +91473,9 @@ ${prompt}`], {
 			"AskUserQuestion",
 			...extraArgs,
 			"--",
-			`@${prdFilePath}
+			prdFilePath ? `@${prdFilePath}
 
-${prompt}`
+${prompt}` : prompt
 		], {
 			stdout: "pipe",
 			stderr: "pipe",
@@ -91186,17 +91497,17 @@ ${prompt}`], {
 			"exec",
 			"--dangerously-bypass-approvals-and-sandbox",
 			...extraArgs,
-			`@${prdFilePath}
+			prdFilePath ? `@${prdFilePath}
 
-${prompt}`
+${prompt}` : prompt
 		], {
 			stdout: "pipe",
 			stderr: "pipe",
 			stdin: "inherit"
 		}),
-		commandPlan: ({ prompt, prdFilePath, dangerous }) => make$45("codex", [...dangerous ? ["--dangerously-bypass-approvals-and-sandbox"] : [], `@${prdFilePath}
+		commandPlan: ({ prompt, prdFilePath, dangerous }) => make$45("codex", [...dangerous ? ["--dangerously-bypass-approvals-and-sandbox"] : [], prdFilePath ? `@${prdFilePath}
 
-${prompt}`], {
+${prompt}` : prompt], {
 			stdout: "inherit",
 			stderr: "inherit",
 			stdin: "inherit"
@@ -91209,9 +91520,9 @@ ${prompt}`], {
 			"--dangerously-allow-all",
 			"--stream-json-thinking",
 			...extraArgs,
-			`@${prdFilePath}
+			prdFilePath ? `@${prdFilePath}
 
-${prompt}`
+${prompt}` : prompt
 		], {
 			stdout: "pipe",
 			stderr: "pipe",
@@ -92548,6 +92859,9 @@ var Settings = class Settings extends Service$1()("lalph/Settings", { make: gen(
 	static set(setting, value) {
 		return Settings.use((_) => _.set(setting, value));
 	}
+	static update(setting, f) {
+		return Settings.use((_) => _.get(setting).pipe(map$9(f), flatMap$4((v) => _.set(setting, v))));
+	}
 	static getProject(setting) {
 		return Settings.use((_) => _.getProject(setting));
 	}
@@ -92575,6 +92889,7 @@ var ProjectSetting = class {
 	}
 };
 new Setting("selectedCliAgentId", Literals(allCliAgents.map((a) => a.id)));
+const allProjects = new Setting("projects", Array$1(Project$2));
 //#endregion
 //#region src/shared/schema.ts
 const withEncodeDefault = (defaultValue) => (schema) => optionalKey(schema).pipe(decodeTo(toType(schema), {
@@ -239422,23 +239737,28 @@ const getOrSelectIssueSource = gen(function* () {
 });
 var CurrentIssueSource = class CurrentIssueSource extends Service$1()("lalph/CurrentIssueSource") {
 	static layer = effectServices(gen(function* () {
+		const settings = yield* Settings;
 		const source = yield* getOrSelectIssueSource;
 		const build$1 = build(source.layer).pipe(map$9(get$15(IssueSource)), withSpan$1("CurrentIssueSource.build"));
 		const ref = yield* fromAcquire(build$1);
 		const services$2 = yield* services();
 		const refresh = set$4(ref, build$1).pipe(provideServices$2(services$2));
+		const unlessRalph = (projectId, orElse) => (effect) => settings.get(allProjects).pipe(map$9(filter$10((projects) => projects.some((p) => p.id === projectId && p.gitFlow === "ralph"))), flatMap$4(match$10({
+			onNone: () => effect,
+			onSome: () => orElse
+		})));
 		const proxy = IssueSource.of({
-			issues: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.issues(projectId)), tapErrorTag("IssueSourceError", (e) => logWarning("Rebuilding issue source due to error", fail$7(e)).pipe(andThen(ignore$1(refresh)))), retry$3(refreshSchedule)),
-			createIssue: (projectId, options) => get$6(ref).pipe(flatMap$4((source) => source.createIssue(projectId, options))),
-			updateIssue: (options) => get$6(ref).pipe(flatMap$4((source) => source.updateIssue(options))),
-			cancelIssue: (projectId, issueId) => get$6(ref).pipe(flatMap$4((source) => source.cancelIssue(projectId, issueId))),
+			issues: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.issues(projectId)), tapErrorTag("IssueSourceError", (e) => logWarning("Rebuilding issue source due to error", fail$7(e)).pipe(andThen(ignore$1(refresh)))), retry$3(refreshSchedule), unlessRalph(projectId, succeed$3([]))),
+			createIssue: (projectId, options) => get$6(ref).pipe(flatMap$4((source) => source.createIssue(projectId, options)), unlessRalph(projectId, interrupt$1)),
+			updateIssue: (options) => get$6(ref).pipe(flatMap$4((source) => source.updateIssue(options)), unlessRalph(options.projectId, void_$2)),
+			cancelIssue: (projectId, issueId) => get$6(ref).pipe(flatMap$4((source) => source.cancelIssue(projectId, issueId)), unlessRalph(projectId, void_$2)),
 			reset: get$6(ref).pipe(flatMap$4((source) => source.reset)),
-			settings: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.settings(projectId))),
-			info: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.info(projectId))),
+			settings: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.settings(projectId)), unlessRalph(projectId, void_$2)),
+			info: (projectId) => get$6(ref).pipe(flatMap$4((source) => source.info(projectId)), unlessRalph(projectId, void_$2)),
 			issueCliAgentPreset: (issue) => get$6(ref).pipe(flatMap$4((source) => source.issueCliAgentPreset(issue))),
 			updateCliAgentPreset: (preset) => get$6(ref).pipe(flatMap$4((source) => source.updateCliAgentPreset(preset))),
 			cliAgentPresetInfo: (preset) => get$6(ref).pipe(flatMap$4((source) => source.cliAgentPresetInfo(preset))),
-			ensureInProgress: (projectId, issueId) => get$6(ref).pipe(flatMap$4((source) => source.ensureInProgress(projectId, issueId)))
+			ensureInProgress: (projectId, issueId) => get$6(ref).pipe(flatMap$4((source) => source.ensureInProgress(projectId, issueId)), unlessRalph(projectId, void_$2))
 		});
 		return IssueSource.serviceMap(proxy).pipe(add$3(CurrentIssueSource, source));
 	})).pipe(provide$3([Settings.layer, PlatformServices]));
@@ -239447,8 +239767,9 @@ const refreshSchedule = exponential(100, 1.5).pipe(either(spaced("30 seconds")))
 const issueSourceRuntime = atomRuntime(CurrentIssueSource.layer.pipe(orDie$3));
 const currentIssuesAtom = family((projectId) => pipe$1(issueSourceRuntime.atom(IssueSource.use((s) => s.issues(projectId)).pipe(withSpan$1("currentIssuesAtom"))), atomRuntime.withReactivity([`issues:${projectId}`]), withRefresh("30 seconds"), keepAlive));
 const getCurrentIssues = (projectId) => getResult$1(currentIssuesAtom(projectId), { suspendOnWaiting: true });
-const checkForWork = gen(function* () {
-	if (!(yield* getCurrentIssues(yield* CurrentProjectId)).some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return yield* new NoMoreWork({});
+const checkForWork = fnUntraced(function* (project) {
+	if (project.gitFlow === "ralph") return;
+	if (!(yield* getCurrentIssues(project.id)).some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return yield* new NoMoreWork({});
 });
 const resetInProgress = gen(function* () {
 	const source = yield* IssueSource;
@@ -239551,6 +239872,12 @@ Set \`githubPrNumber\` to the PR number if one exists, otherwise use \`null\`.
   - The pull request will contain the task id in the title or description.` : ""}
 - Use the "chooseTask" function to select the task you have chosen.
 ${options.gitFlow.requiresGithubPr ? `\n  - Set \`githubPrNumber\` to the PR number if one exists, otherwise use \`null\`.` : "\n  Leave `githubPrNumber` as null."}
+`;
+	const promptChooseRalph = (options) => `- Read the spec file at \`${options.specFile}\` to understand the current project.
+- Choose the next most important task to work on from the specification.
+- If all of the tasks are complete then do nothing more. Otherwise, write the chosen task in a ".lalph/task.md" file.
+
+Note: The task should be a specific, actionable item that can be completed in a reasonable amount of time.
 `;
 	const keyInformation = (options) => `## Important: Adding new tasks
 
@@ -239664,6 +239991,28 @@ All steps must be done before the task can be considered complete.${options.task
 5. **After ${options.gitFlow.requiresGithubPr ? "pushing" : "committing"}** your changes, update current task to reflect any changes in the task state.
    - Rewrite the notes in the description to include only the key discoveries and information that could speed up future work on other tasks. Make sure to preserve important information such as specification file references.
    - If you believe the task is complete, update the \`state\` to "in-review".`;
+	const promptRalph = (options) => `${options.task}
+
+## Project specification
+
+Make sure to review the project specification at \`${options.specFile}\` for any key information that may help you with this task.
+
+### Instructions
+
+All steps must be done before the task can be considered complete.
+
+1. ${options.gitFlow.setupInstructions({ githubPrNumber: void 0 })}
+2. Implement the task.
+  - Along the way, update the specification file with any important discoveries or issues found.
+3. Run any checks / feedback loops, such as type checks, unit tests, or linting.
+4. Update the specification implementation plan at \`${options.specFile}\` to reflect changes to task states.
+4. ${options.gitFlow.commitInstructions({
+		githubPrInstructions: sourceMeta.githubPrInstructions,
+		githubPrNumber: void 0,
+		taskId: "unknown",
+		targetBranch: options.targetBranch
+	})}
+`;
 	const promptResearch = (options) => `Your job is to gather all the necessary information and details to complete the task described below. Do not make any code changes yet, your job is just to research and gather information.
 
 In the final report:
@@ -239717,6 +240066,18 @@ permission.
 5. If any specifications need updating based on your new understanding, update them.
 
 ${prdNotes(options)}`;
+	const promptTimeoutRalph = (options) => `Your earlier attempt to complete the following task took too
+long and has timed out.
+
+The following instructions should be done without interaction or asking for
+permission.
+
+1. Investigate why you think the task took too long. Research the codebase
+   further to understand what is needed to complete the task.
+2. Update the specification file at \`${options.specFile}\` to break the task
+   down into smaller tasks, and include any important discoveries from your research.
+3. Commit the changes to the specification file without pushing.
+`;
 	const promptTimeoutClanka = (options) => `Your earlier attempt to complete the task with id \`${options.taskId}\` took too
 long and has timed out.
 
@@ -239822,13 +240183,16 @@ Make sure to setup dependencies between the tasks using the \`blockedBy\` field.
 	return {
 		promptChoose,
 		promptChooseClanka,
+		promptChooseRalph,
 		prompt,
+		promptRalph,
 		promptClanka,
 		promptResearch,
 		promptReview,
 		promptReviewCustom,
 		promptTimeout,
 		promptTimeoutClanka,
+		promptTimeoutRalph,
 		planPrompt,
 		promptPlanTasks,
 		promptPlanTasksClanka,
@@ -239927,7 +240291,6 @@ const withWorkerState = (projectId) => (effect) => AtomRegistry.use((registry) =
 const layerProjectIdPrompt = effect$1(CurrentProjectId, gen(function* () {
 	return (yield* selectProject).id;
 })).pipe(provide$3(Settings.layer), provide$3(CurrentIssueSource.layer));
-const allProjects = new Setting("projects", Array$1(Project$2));
 const getAllProjects = Settings.get(allProjects).pipe(map$9(getOrElse$2(() => [])));
 const projectById = fnUntraced(function* (projectId) {
 	return findFirst$5(yield* getAllProjects, (p) => p.id === projectId);
@@ -239961,7 +240324,7 @@ const welcomeWizard = gen(function* () {
 	console.log(welcome);
 	return yield* addOrUpdateProject();
 });
-const addOrUpdateProject = fnUntraced(function* (existing) {
+const addOrUpdateProject = fnUntraced(function* (existing, fromPlanMode = false) {
 	const projects = yield* getAllProjects;
 	const id = existing ? existing.id : yield* text$2({
 		message: "Project name",
@@ -239982,18 +240345,29 @@ const addOrUpdateProject = fnUntraced(function* (existing) {
 	}), trim, liftPredicate(isNonEmpty$1));
 	const gitFlow = yield* select({
 		message: "Git flow",
-		choices: [{
-			title: "Pull Request",
-			description: "Create a pull request for each task",
-			value: "pr",
-			selected: existing ? existing.gitFlow === "pr" : false
-		}, {
-			title: "Commit",
-			description: "Tasks are committed directly to the target branch",
-			value: "commit",
-			selected: existing ? existing.gitFlow === "commit" : false
-		}]
+		choices: [
+			{
+				title: "Pull Request",
+				description: "Create a pull request for each task",
+				value: "pr",
+				selected: existing ? existing.gitFlow === "pr" : false
+			},
+			{
+				title: "Commit",
+				description: "Tasks are committed directly to the target branch",
+				value: "commit",
+				selected: existing ? existing.gitFlow === "commit" : false
+			},
+			{
+				title: "Ralph",
+				description: "Tasks are determined from a spec file",
+				value: "ralph",
+				selected: existing ? existing.gitFlow === "ralph" : false
+			}
+		]
 	});
+	let ralphSpec = none$4();
+	if (gitFlow === "ralph" && !fromPlanMode) ralphSpec = yield* file$3({ message: "Path to Ralph spec file" }).pipe(fromYieldable, map$9(some$2));
 	const researchAgent = yield* toggle({
 		message: "Enable research agent?",
 		initial: existing ? existing.researchAgent : true
@@ -240008,13 +240382,14 @@ const addOrUpdateProject = fnUntraced(function* (existing) {
 		concurrency,
 		targetBranch,
 		gitFlow,
+		ralphSpec: getOrUndefined$2(ralphSpec),
 		researchAgent,
 		reviewAgent
 	});
 	yield* Settings.set(allProjects, some$2(existing ? projects.map((p) => p.id === project.id ? project : p) : [...projects, project]));
 	const source = yield* IssueSource;
 	yield* source.reset.pipe(provideService$2(CurrentProjectId, project.id));
-	yield* source.settings(project.id);
+	if (gitFlow !== "ralph") yield* source.settings(project.id);
 	return project;
 });
 //#endregion
@@ -240350,6 +240725,15 @@ var Prd = class extends Service$1()("lalph/Prd", { make: gen(function* () {
 		layer$32,
 		CurrentIssueSource.layer
 	]));
+	static layerNoop = succeed$4(this, {
+		path: "",
+		maybeRevertIssue: () => void_$2,
+		revertUpdatedIssues: void_$2,
+		flagUnmergable: () => void_$2,
+		findById: () => succeed$3(null),
+		setChosenIssueId: () => void_$2,
+		setAutoMerge: () => void_$2
+	});
 };
 //#endregion
 //#region src/TaskTools.ts
@@ -240497,7 +240881,7 @@ const runClanka = fnUntraced(function* (options) {
 	return yield* stream.pipe(runDrain, as$1(""), catchTag$1("AgentFinished", (e) => succeed$3(e.summary)));
 }, scoped$1, (effect, options) => provide$1(effect, layerLocal({
 	directory: options.directory,
-	tools: options.withChoose ? TaskChooseTools : TaskTools
+	tools: options.mode === "ralph" ? void 0 : options.mode === "choose" ? TaskChooseTools : TaskTools
 }).pipe(merge$6(ClankaModels.get(options.model)))), provide$1([layerUndici, TaskToolsHandlers]));
 //#endregion
 //#region src/Agents/worker.ts
@@ -240523,13 +240907,14 @@ ${research}`
 				}])
 			}),
 			stallTimeout: options.stallTimeout,
-			steer: options.steer
+			steer: options.steer,
+			mode: options.ralph ? "ralph" : "default"
 		});
 		return ExitCode(0);
 	}
 	return yield* pipe$1(options.preset.cliAgent.command({
 		prompt: options.prompt,
-		prdFilePath: pathService.join(".lalph", "prd.yml"),
+		prdFilePath: options.ralph ? void 0 : pathService.join(".lalph", "prd.yml"),
 		extraArgs: options.preset.extraArgs
 	}), setCwd(worktree.directory), options.preset.withCommandPrefix).pipe(worktree.execWithStallTimeout({
 		cliAgent: options.preset.cliAgent,
@@ -240633,6 +241018,31 @@ But you **do not** need to git push your changes or switch branches.
 		})
 	});
 })).pipe(provide$3(layer$14));
+const GitFlowRalph = effect$1(GitFlow, gen(function* () {
+	const workerState = yield* get$3((yield* CurrentWorkerState).state);
+	return GitFlow.of({
+		requiresGithubPr: false,
+		branch: `lalph/worker-${workerState.id}`,
+		setupInstructions: () => `You are already on a new branch for this task. You do not need to checkout any other branches.`,
+		commitInstructions: () => `When you have completed your changes, **you must** commit them to the current local branch. Do not git push your changes or switch branches.
+   - **DO NOT** commit any of the files in the \`.lalph\` directory.`,
+		reviewInstructions: `You are already on the branch with their changes.
+After making any changes, **you must** commit them to the same branch.
+But you **do not** need to git push your changes or switch branches.
+
+ - **DO NOT** commit any of the files in the \`.lalph\` directory.
+ - You have full permission to create git commits.`,
+		postWork: fnUntraced(function* ({ worktree, targetBranch }) {
+			if (!targetBranch) return yield* logWarning("GitFlowRalph: No target branch specified, skipping postWork.");
+			const parsed = parseBranch(targetBranch);
+			yield* worktree.exec`git fetch ${parsed.remote}`;
+			yield* worktree.exec`git restore --worktree .`;
+			if ((yield* worktree.exec`git rebase ${parsed.branchWithRemote}`) !== 0) return yield* new GitFlowError({ message: `Failed to rebase onto ${parsed.branchWithRemote}. Aborting task.` });
+			if ((yield* worktree.exec`git push ${parsed.remote} ${`HEAD:${parsed.branch}`}`) !== 0) return yield* new GitFlowError({ message: `Failed to push changes to ${parsed.branchWithRemote}. Aborting task.` });
+		}),
+		autoMerge: () => void_$2
+	});
+})).pipe(provide$3(layer$14));
 var GitFlowError = class extends TaggedError("GitFlowError") {};
 //#endregion
 //#region src/Agents/chooser.ts
@@ -240651,10 +241061,10 @@ const agentChooser = fnUntraced(function* (options) {
 			model: options.preset.extraArgs.join(" "),
 			prompt: promptGen.promptChooseClanka({ gitFlow }),
 			stallTimeout: options.stallTimeout,
-			withChoose: true
-		}).pipe(provideService$2(ChosenTaskDeferred, deferred), flatMap$4(() => fail$6(new ChosenTaskNotFound())), raceFirst(_await(deferred)));
+			mode: "choose"
+		}).pipe(provideService$2(ChosenTaskDeferred, deferred), flatMap$4(() => fail$6(new ChosenTaskNotFound$1())), raceFirst(_await(deferred)));
 		const prdTask = yield* prd.findById(result.taskId);
-		if (!prdTask) return yield* new ChosenTaskNotFound();
+		if (!prdTask) return yield* new ChosenTaskNotFound$1();
 		return {
 			id: result.taskId,
 			githubPrNumber: result.githubPrNumber ?? null,
@@ -240670,16 +241080,16 @@ const agentChooser = fnUntraced(function* (options) {
 		duration: options.stallTimeout,
 		onTimeout: () => fail$6(new RunnerStalled())
 	}), raceFirst(taskJsonCreated));
-	return yield* pipe$1(fs.readFileString(pathService.join(worktree.directory, ".lalph", "task.json")), flatMap$4(decodeEffect(ChosenTask)), mapError$2((_) => new ChosenTaskNotFound()), flatMap$4(fnUntraced(function* (task) {
+	return yield* pipe$1(fs.readFileString(pathService.join(worktree.directory, ".lalph", "task.json")), flatMap$4(decodeEffect(ChosenTask)), mapError$2((_) => new ChosenTaskNotFound$1()), flatMap$4(fnUntraced(function* (task) {
 		const prdTask = yield* prd.findById(task.id);
 		if (prdTask) return {
 			...task,
 			prd: prdTask
 		};
-		return yield* new ChosenTaskNotFound();
+		return yield* new ChosenTaskNotFound$1();
 	})));
 });
-var ChosenTaskNotFound = class extends TaggedError("ChosenTaskNotFound") {
+var ChosenTaskNotFound$1 = class extends TaggedError("ChosenTaskNotFound") {
 	message = "The AI agent failed to choose a task.";
 };
 const ChosenTask = fromJsonString(Struct$2({
@@ -240699,7 +241109,7 @@ const agentReviewer = fnUntraced(function* (options) {
 		yield* runClanka({
 			directory: worktree.directory,
 			model: options.preset.extraArgs.join(" "),
-			system: promptGen.systemClanka(options),
+			system: options.ralph ? void 0 : promptGen.systemClanka(options),
 			prompt: match$10(customInstructions, {
 				onNone: () => promptGen.promptReview({
 					prompt: options.instructions,
@@ -240711,7 +241121,8 @@ const agentReviewer = fnUntraced(function* (options) {
 					removePrdNotes: true
 				})
 			}),
-			stallTimeout: options.stallTimeout
+			stallTimeout: options.stallTimeout,
+			mode: options.ralph ? "ralph" : "default"
 		});
 		return ExitCode(0);
 	}
@@ -240744,21 +241155,28 @@ const agentTimeout = fnUntraced(function* (options) {
 		yield* runClanka({
 			directory: worktree.directory,
 			model: options.preset.extraArgs.join(" "),
-			system: promptGen.systemClanka(options),
-			prompt: promptGen.promptTimeoutClanka({
-				taskId: options.task.id,
+			system: options.task._tag === "ralph" ? void 0 : promptGen.systemClanka(options),
+			prompt: options.task._tag === "ralph" ? promptGen.promptTimeoutRalph({
+				task: options.task.task,
+				specFile: options.task.specFile
+			}) : promptGen.promptTimeoutClanka({
+				taskId: options.task.task.id,
 				specsDirectory: options.specsDirectory
 			}),
-			stallTimeout: options.stallTimeout
+			stallTimeout: options.stallTimeout,
+			mode: options.task._tag === "ralph" ? "ralph" : "default"
 		});
 		return ExitCode(0);
 	}
 	return yield* pipe$1(options.preset.cliAgent.command({
-		prompt: promptGen.promptTimeout({
-			taskId: options.task.id,
+		prompt: options.task._tag === "ralph" ? promptGen.promptTimeoutRalph({
+			task: options.task.task,
+			specFile: options.task.specFile
+		}) : promptGen.promptTimeout({
+			taskId: options.task.task.id,
 			specsDirectory: options.specsDirectory
 		}),
-		prdFilePath: pathService.join(".lalph", "prd.yml"),
+		prdFilePath: options.task._tag === "ralph" ? void 0 : pathService.join(".lalph", "prd.yml"),
 		extraArgs: options.preset.extraArgs
 	}), setCwd(worktree.directory), options.preset.withCommandPrefix).pipe(worktree.execWithStallTimeout({
 		cliAgent: options.preset.cliAgent,
@@ -240780,6 +241198,33 @@ const agentResearcher = fnUntraced(function* (options) {
 	}).pipe(asSome);
 });
 //#endregion
+//#region src/Agents/chooserRalph.ts
+const agentChooserRalph = fnUntraced(function* (options) {
+	const fs = yield* FileSystem;
+	const pathService = yield* Path$1;
+	const worktree = yield* Worktree;
+	const promptGen = yield* PromptGen;
+	if (!options.preset.cliAgent.command) yield* runClanka({
+		directory: worktree.directory,
+		model: options.preset.extraArgs.join(" "),
+		prompt: promptGen.promptChooseRalph({ specFile: options.specFile }),
+		stallTimeout: options.stallTimeout,
+		mode: "ralph"
+	});
+	else yield* pipe$1(options.preset.cliAgent.command({
+		prompt: promptGen.promptChooseRalph({ specFile: options.specFile }),
+		prdFilePath: void 0,
+		extraArgs: options.preset.extraArgs
+	}), setCwd(worktree.directory), options.preset.withCommandPrefix, worktree.execWithWorkerOutput({ cliAgent: options.preset.cliAgent }), timeoutOrElse({
+		duration: options.stallTimeout,
+		onTimeout: () => fail$6(new RunnerStalled())
+	}));
+	return yield* pipe$1(fs.readFileString(pathService.join(worktree.directory, ".lalph", "task.md")), mapError$2((_) => new ChosenTaskNotFound()));
+});
+var ChosenTaskNotFound = class extends TaggedError("ChosenTaskNotFound") {
+	message = "The AI agent failed to choose a task.";
+};
+//#endregion
 //#region src/commands/root.ts
 const run = fnUntraced(function* (options) {
 	const projectId = yield* CurrentProjectId;
@@ -240871,10 +241316,12 @@ const run = fnUntraced(function* (options) {
 		});
 		yield* log$1(`Agent exited with code: ${yield* agentWorker({
 			stallTimeout: options.stallTimeout,
+			system: promptGen.systemClanka(options),
 			preset: taskPreset,
 			prompt: instructions,
 			research: researchResult,
-			steer
+			steer,
+			ralph: false
 		}).pipe(provideService$2(CurrentTaskRef, issueRef), catchStallInReview, withSpan$1("Main.agentWorker"))}`);
 		if (options.review) {
 			yield* source.updateIssue({
@@ -240887,7 +241334,8 @@ const run = fnUntraced(function* (options) {
 				specsDirectory: options.specsDirectory,
 				stallTimeout: options.stallTimeout,
 				preset: taskPreset,
-				instructions
+				instructions,
+				ralph: false
 			}).pipe(catchStallInReview, withSpan$1("Main.agentReviewer"));
 			yield* source.updateIssue({
 				projectId,
@@ -240899,7 +241347,10 @@ const run = fnUntraced(function* (options) {
 		specsDirectory: options.specsDirectory,
 		stallTimeout: options.stallTimeout,
 		preset: taskPreset,
-		task: chosenTask.prd
+		task: {
+			_tag: "task",
+			task: chosenTask.prd
+		}
 	})), raceFirst(watchTaskState({ issueId: taskId })), as$1(false), catchTag$1("TaskStateChanged", (error) => log$1(`Task ${error.issueId} moved to ${error.state}; cancelling run.`).pipe(as$1(true))))) return;
 	yield* gitFlow.postWork({
 		worktree,
@@ -240913,6 +241364,69 @@ const run = fnUntraced(function* (options) {
 	});
 	else yield* prd.maybeRevertIssue({ issueId: taskId });
 }, scoped$1, provide$1(SemanticSearchLayer.pipe(provideMerge(Prd.layer)), { local: true }));
+const runRalph = fnUntraced(function* (options) {
+	const worktree = yield* Worktree;
+	const gitFlow = yield* GitFlow;
+	const currentWorker = yield* CurrentWorkerState;
+	const registry = yield* AtomRegistry;
+	const projectId = yield* CurrentProjectId;
+	const preset = yield* getDefaultCliAgentPreset;
+	yield* addFinalizer(fnUntraced(function* () {
+		const currentBranchName = yield* worktree.currentBranch(worktree.directory).pipe(option$1, map$9(getOrUndefined$2));
+		if (!currentBranchName) return;
+		yield* worktree.exec`git checkout --detach ${currentBranchName}`;
+		yield* worktree.exec`git branch -D ${currentBranchName}`;
+	}, ignore$1()));
+	registry.update(currentWorker.state, (s) => s.transitionTo(WorkerStatus.ChoosingTask()));
+	const chosenTask = yield* agentChooserRalph({
+		stallTimeout: options.stallTimeout,
+		preset,
+		specFile: options.specFile
+	}).pipe(tapErrorTag("ChosenTaskNotFound", fnUntraced(function* () {
+		yield* Settings.update(allProjects, map$16((projects) => projects.map((p) => p.id === projectId ? p.update({ enabled: false }) : p)));
+	})), withSpan$1("Main.chooser"));
+	yield* gen(function* () {
+		registry.update(currentWorker.state, (s) => s.transitionTo(WorkerStatus.Working({ issueId: "ralph" })));
+		let researchResult = none$4();
+		const instructions = (yield* PromptGen).promptRalph({
+			task: chosenTask,
+			specFile: options.specFile,
+			targetBranch: getOrUndefined$2(options.targetBranch),
+			gitFlow
+		});
+		yield* log$1(`Agent exited with code: ${yield* agentWorker({
+			stallTimeout: options.stallTimeout,
+			preset,
+			prompt: instructions,
+			research: researchResult,
+			ralph: true
+		}).pipe(withSpan$1("Main.worker"))}`);
+		if (options.review) {
+			registry.update(currentWorker.state, (s) => s.transitionTo(WorkerStatus.Reviewing({ issueId: "ralph" })));
+			yield* agentReviewer({
+				specsDirectory: "",
+				stallTimeout: options.stallTimeout,
+				preset,
+				instructions,
+				ralph: true
+			}).pipe(withSpan$1("Main.review"));
+		}
+	}).pipe(timeout(options.runTimeout), tapErrorTag("TimeoutError", () => agentTimeout({
+		specsDirectory: "",
+		stallTimeout: options.stallTimeout,
+		preset,
+		task: {
+			_tag: "ralph",
+			task: chosenTask,
+			specFile: options.specFile
+		}
+	})));
+	yield* gitFlow.postWork({
+		worktree,
+		targetBranch: getOrUndefined$2(options.targetBranch),
+		issueId: ""
+	});
+}, scoped$1, provide$1(SemanticSearchLayer.pipe(provideMerge([Prd.layerNoop, Worktree.layer])), { local: true }));
 const runProject = fnUntraced(function* (options) {
 	const isFinite = Number.isFinite(options.iterations);
 	const iterationsDisplay = isFinite ? options.iterations : "unlimited";
@@ -240929,7 +241443,18 @@ const runProject = fnUntraced(function* (options) {
 		if (quit || isFinite && iteration >= iterations) break;
 		const currentIteration = iteration;
 		const startedDeferred = yield* make$85();
-		yield* checkForWork.pipe(andThen(run({
+		let ralphDone = false;
+		const gitFlow = options.project.gitFlow;
+		const isRalph = gitFlow === "ralph";
+		const gitFlowLayer = gitFlow === "commit" ? GitFlowCommit : gitFlow === "ralph" ? GitFlowRalph : GitFlowPR;
+		const fiber = yield* checkForWork(options.project).pipe(andThen(unify(isRalph ? runRalph({
+			targetBranch: options.project.targetBranch,
+			stallTimeout: options.stallTimeout,
+			runTimeout: options.runTimeout,
+			review: options.project.reviewAgent,
+			research: options.project.researchAgent,
+			specFile: options.project.ralphSpec
+		}) : run({
 			startedDeferred,
 			targetBranch: options.project.targetBranch,
 			specsDirectory: options.specsDirectory,
@@ -240937,7 +241462,14 @@ const runProject = fnUntraced(function* (options) {
 			runTimeout: options.runTimeout,
 			review: options.project.reviewAgent,
 			research: options.project.researchAgent
-		}).pipe(provide$1(options.project.gitFlow === "commit" ? GitFlowCommit : GitFlowPR, { local: true }), withWorkerState(options.project.id))), catchTags$1({
+		})).pipe(provide$1(gitFlowLayer, { local: true }), withWorkerState(options.project.id))), catchTags$1({
+			ChosenTaskNotFound(_error) {
+				if (isRalph) {
+					ralphDone = true;
+					return log$1(`No more work to process for Ralph, ending after ${currentIteration + 1} iteration(s).`);
+				}
+				return void_$2;
+			},
 			NoMoreWork(_error) {
 				if (isFinite) {
 					iterations = currentIteration;
@@ -240950,7 +241482,10 @@ const runProject = fnUntraced(function* (options) {
 				return void_$2;
 			}
 		}), catchCause$1((cause) => logWarning(cause).pipe(andThen(sleep(seconds(10))))), ensuring$2(semaphore.release(1)), ensuring$2(completeWith(startedDeferred, void_$2)), run$2(fibers));
-		yield* _await(startedDeferred);
+		if (isRalph) {
+			yield* await_(fiber);
+			if (ralphDone) break;
+		} else yield* _await(startedDeferred);
 		iteration++;
 	}
 	yield* awaitEmpty(fibers);
@@ -241027,7 +241562,7 @@ const agentPlanner = fnUntraced(function* (options) {
 	const spawner = yield* ChildProcessSpawner;
 	yield* pipe$1(options.preset.cliAgent.commandPlan({
 		prompt: promptGen.planPrompt(options),
-		prdFilePath: pathService.join(".lalph", "prd.yml"),
+		prdFilePath: options.ralph ? void 0 : pathService.join(".lalph", "prd.yml"),
 		dangerous: options.dangerous
 	}), setCwd(worktree.directory), options.preset.withCommandPrefix, spawner.exitCode);
 });
@@ -241144,7 +241679,7 @@ const commandPlan = make$58("plan", {
 		return pipe$1(editor.saveTemp(thePlan.value, { suffix: ".md" }), flatMap$4((file) => log$1(`Saved your plan to: ${file}`)), ignore$1);
 	});
 	yield* gen(function* () {
-		const project = withNewProject ? yield* addOrUpdateProject() : yield* selectProject;
+		const project = withNewProject ? yield* addOrUpdateProject(void 0, true) : yield* selectProject;
 		const { specsDirectory } = yield* commandRoot;
 		const preset = yield* selectCliAgentPreset;
 		yield* plan({
@@ -241152,7 +241687,8 @@ const commandPlan = make$58("plan", {
 			specsDirectory,
 			targetBranch: project.targetBranch,
 			dangerous,
-			preset
+			preset,
+			ralph: project.gitFlow === "ralph"
 		}).pipe(provideService$2(CurrentProjectId, project.id));
 	}).pipe(provide$1([
 		Settings.layer,
@@ -241164,27 +241700,32 @@ const plan = fnUntraced(function* (options) {
 	const fs = yield* FileSystem;
 	const pathService = yield* Path$1;
 	const worktree = yield* Worktree;
+	const projectId = yield* CurrentProjectId;
 	yield* agentPlanner({
 		plan: options.plan,
 		specsDirectory: options.specsDirectory,
 		dangerous: options.dangerous,
-		preset: options.preset
+		preset: options.preset,
+		ralph: options.ralph
 	});
 	const planDetails = yield* pipe$1(fs.readFileString(pathService.join(worktree.directory, ".lalph", "plan.json")), flatMap$4(decodeEffect(PlanDetails)), mapError$2(() => new SpecNotFound()));
+	if (options.ralph) yield* Settings.update(allProjects, map$16((projects) => projects.map((p) => p.id === projectId ? p.update({ ralphSpec: planDetails.specification }) : p)));
 	if (isSome(options.targetBranch)) yield* commitAndPushSpecification({
 		specsDirectory: options.specsDirectory,
 		targetBranch: options.targetBranch.value
 	});
-	yield* log$1("Converting specification into tasks");
-	yield* agentTasker({
-		specificationPath: planDetails.specification,
-		specsDirectory: options.specsDirectory,
-		preset: options.preset
-	});
+	if (!options.ralph) {
+		yield* log$1("Converting specification into tasks");
+		yield* agentTasker({
+			specificationPath: planDetails.specification,
+			specsDirectory: options.specsDirectory,
+			preset: options.preset
+		});
+	}
 	if (!worktree.inExisting) yield* pipe$1(fs.copy(pathService.join(worktree.directory, options.specsDirectory), options.specsDirectory, { overwrite: true }), ignore$1);
-}, scoped$1, provide$1([
+}, scoped$1, (effect, options) => provide$1(effect, [
 	PromptGen.layer,
-	Prd.layerProvided,
+	options.ralph ? Prd.layerNoop : Prd.layerProvided,
 	Worktree.layer,
 	Settings.layer,
 	CurrentIssueSource.layer
@@ -241289,7 +241830,7 @@ const commandEdit = make$58("edit").pipe(withDescription("Open the selected proj
 const commandSource = make$58("source").pipe(withDescription("Select the issue source to use (e.g. GitHub Issues or Linear). This applies to all projects."), withHandler(() => selectIssueSource), provide(Settings.layer));
 //#endregion
 //#region package.json
-var version = "0.3.85";
+var version = "0.3.86";
 //#endregion
 //#region src/commands/projects/ls.ts
 const commandProjectsLs = make$58("ls").pipe(withDescription("List configured projects and how they run (enabled state, concurrency, branch, git flow, review agent)."), withHandler(fnUntraced(function* () {