lalph 0.2.19 → 0.2.20

package/dist/cli.mjs

@@ -7235,7 +7235,7 @@ const getOption = /* @__PURE__ */ dual(2, (self, service) => {
 * @since 4.0.0
 * @category Utils
 */
-const merge$6 = /* @__PURE__ */ dual(2, (self, that) => {
+const merge$5 = /* @__PURE__ */ dual(2, (self, that) => {
 	if (self.mapUnsafe.size === 0) return that;
 	if (that.mapUnsafe.size === 0) return self;
 	const map = new Map(self.mapUnsafe);
@@ -9229,7 +9229,7 @@ const servicesWith$1 = (f) => withFiber$1((fiber) => f(fiber.services));
 /** @internal */
 const provideServices$1 = /* @__PURE__ */ dual(2, (self, services) => {
 	if (effectIsExit(self)) return self;
-	return updateServices$1(self, merge$6(services));
+	return updateServices$1(self, merge$5(services));
 });
 /** @internal */
 const provideService$1 = function() {
@@ -12030,38 +12030,6 @@ const mergeAllEffect = (layers, memoMap, scope) => {
 * @category zipping
 */
 const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEffect(layers, memoMap, scope));
-/**
-* Merges this layer with the specified layer concurrently, producing a new layer with combined input and output types.
-*
-* This is a binary version of `mergeAll` that merges exactly two layers or one layer with an array of layers.
-* The layers are built concurrently and their outputs are combined.
-*
-* @example
-* ```ts
-* import { Effect, Layer, ServiceMap } from "effect"
-*
-* class Database extends ServiceMap.Service<Database, {
-*   readonly query: (sql: string) => Effect.Effect<string>
-* }>()("Database") {}
-*
-* class Logger extends ServiceMap.Service<Logger, {
-*   readonly log: (msg: string) => Effect.Effect<void>
-* }>()("Logger") {}
-*
-* const dbLayer = Layer.succeed(Database)({
-*   query: (sql: string) => Effect.succeed("result")
-* })
-* const loggerLayer = Layer.succeed(Logger)({
-*   log: (msg: string) => Effect.sync(() => console.log(msg))
-* })
-*
-* const mergedLayer = Layer.merge(dbLayer, loggerLayer)
-* ```
-*
-* @since 2.0.0
-* @category zipping
-*/
-const merge$5 = /* @__PURE__ */ dual(2, (self, that) => mergeAll(self, ...Array.isArray(that) ? that : [that]));
 const provideWith = (self, that, f) => fromBuild((memoMap, scope) => flatMap$4(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideServices$1(context), map$11((merged) => f(merged, context)))));
 /**
 * Feeds the output services of this builder into the input of the specified
@@ -12204,7 +12172,7 @@ const provide$3 = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that
 * @since 2.0.0
 * @category utils
 */
-const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$6(that, self)));
+const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$5(that, self)));
 /**
 * Constructs a layer dynamically based on the output of this layer.
 *
@@ -51194,7 +51162,7 @@ const TypeId$29 = "~effect/Cache";
 */
 const makeWith$1 = (options) => servicesWith$1((services) => {
 	const self = Object.create(Proto$14);
-	self.lookup = (key) => updateServices$1(options.lookup(key), (input) => merge$6(services, input));
+	self.lookup = (key) => updateServices$1(options.lookup(key), (input) => merge$5(services, input));
 	self.map = make$45();
 	self.capacity = options.capacity;
 	self.timeToLive = options.timeToLive ? (exit, key) => fromDurationInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
@@ -59031,7 +58999,7 @@ const SpanNameGenerator$1 = /* @__PURE__ */ Reference("effect/http/HttpClient/Sp
 /**
 * @since 4.0.0
 */
-const layerMergedServices = (effect) => effect$1(HttpClient)(servicesWith((services) => map$8(effect, (client) => transformResponse(client, updateServices((input) => merge$6(services, input))))));
+const layerMergedServices = (effect) => effect$1(HttpClient)(servicesWith((services) => map$8(effect, (client) => transformResponse(client, updateServices((input) => merge$5(services, input))))));
 const responseRegistry = /* @__PURE__ */ (() => {
 	if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
 		const registry = /* @__PURE__ */ new FinalizationRegistry((controller) => {
@@ -60328,7 +60296,7 @@ const fromWebSocket = (acquire, options) => withFiber((fiber) => {
 		latch.openUnsafe();
 		if (opts?.onOpen) yield* opts.onOpen;
 		return yield* join(fiberSet).pipe(catchFilter(SocketCloseError.filterClean((_) => !closeCodeIsError(_)), (_) => void_$1));
-	})).pipe(updateServices((input) => merge$6(acquireContext, input)), ensuring$2(sync(() => {
+	})).pipe(updateServices((input) => merge$5(acquireContext, input)), ensuring$2(sync(() => {
 		latch.closeUnsafe();
 		currentWS = void 0;
 	})));
@@ -151063,8 +151031,13 @@ permission.
 5. If any specifications need updating based on your new understanding, update them.
 
 ${prdNotes(options)}`;
-	const planPrompt = (options) => `1. Ask the user for the idea / request, then your job is to create a detailed
-   specification to fulfill the request and save it as a file.
+	const planPrompt = (options) => `<request><![CDATA[
+${options.plan}
+]]></request>
+
+## Instructions
+
+1. Your job is to create a detailed specification to fulfill the request and save it as a file.
    First do some research to understand the request, then interview the user
    to gather all the necessary requirements and details for the specification.
    - If the user asks you to update an existing specification, find the relevant
@@ -152120,6 +152093,41 @@ const commandPlanTasks = make$35("tasks", { specificationPath }).pipe(withDescri
 	Worktree.layer.pipe(provide$3(layerProjectIdPrompt))
 ]))));
 
+//#endregion
+//#region src/shared/config.ts
+const configEditor = string$1("LALPH_EDITOR").pipe(orElse(() => string$1("EDITOR")), map$5(parseCommand), withDefault$3(() => ["nano"]));
+
+//#endregion
+//#region src/Editor.ts
+var Editor = class extends Service$1()("lalph/Editor", { make: gen(function* () {
+	const fs = yield* FileSystem;
+	const editor = yield* configEditor;
+	const spawner = yield* ChildProcessSpawner;
+	const edit = (path) => make$23(editor[0], [...editor.slice(1), path], {
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit"
+	}).pipe(exitCode, provideService(ChildProcessSpawner, spawner), orDie$2);
+	return {
+		edit,
+		editTemp: fnUntraced(function* (options) {
+			const initialContent = options.initialContent ?? "";
+			const file = yield* fs.makeTempFileScoped({ suffix: options.suffix ?? ".txt" });
+			if (initialContent) yield* fs.writeFileString(file, initialContent);
+			if ((yield* make$23(editor[0], [...editor.slice(1), file], {
+				stdin: "inherit",
+				stdout: "inherit",
+				stderr: "inherit"
+			}).pipe(exitCode)) !== 0) return yield* new NoSuchElementError();
+			const content = (yield* fs.readFileString(file)).trim();
+			if (content === initialContent) return yield* new NoSuchElementError();
+			return content;
+		}, scoped$1, provideService(ChildProcessSpawner, spawner), option$1)
+	};
+}) }) {
+	static layer = effect$1(this, this.make).pipe(provide$3(PlatformServices));
+};
+
 //#endregion
 //#region src/commands/plan.ts
 const dangerous = boolean("dangerous").pipe(withAlias("d"), withDescription$1("Enable dangerous mode (skip permission prompts) during plan generation"));
@@ -152128,30 +152136,39 @@ const commandPlan = make$35("plan", {
 	dangerous,
 	withNewProject
 }).pipe(withDescription("Iterate on an issue plan and create PRD tasks"), withHandler(fnUntraced(function* ({ dangerous, withNewProject }) {
+	const thePlan = yield* (yield* Editor).editTemp({ suffix: ".md" });
+	if (isNone(thePlan)) return;
 	const project = withNewProject ? yield* addOrUpdateProject() : yield* selectProject;
 	const { specsDirectory } = yield* commandRoot;
 	const commandPrefix = yield* getCommandPrefix;
 	yield* plan({
+		plan: thePlan.value,
 		specsDirectory,
 		targetBranch: project.targetBranch,
 		commandPrefix,
 		dangerous
 	}).pipe(provideService(CurrentProjectId, project.id));
-}, provide$1([Settings.layer, CurrentIssueSource.layer]))), withSubcommands([commandPlanTasks]));
+}, provide$1([
+	Settings.layer,
+	CurrentIssueSource.layer,
+	Editor.layer
+]))), withSubcommands([commandPlanTasks]));
 const plan = fnUntraced(function* (options) {
 	const fs = yield* FileSystem;
 	const pathService = yield* Path$1;
 	const worktree = yield* Worktree;
 	const cliAgent = yield* getOrSelectCliAgent;
 	yield* agentPlanner({
+		plan: options.plan,
 		specsDirectory: options.specsDirectory,
 		commandPrefix: options.commandPrefix,
 		dangerous: options.dangerous,
 		cliAgent
 	});
+	const planDetails = yield* pipe(fs.readFileString(pathService.join(worktree.directory, ".lalph", "plan.json")), flatMap$2(decodeEffect(PlanDetails)), mapError$2(() => new SpecNotFound()));
 	yield* log$1("Converting specification into tasks");
 	yield* agentTasker({
-		specificationPath: (yield* pipe(fs.readFileString(pathService.join(worktree.directory, ".lalph", "plan.json")), flatMap$2(decodeEffect(PlanDetails)))).specification,
+		specificationPath: planDetails.specification,
 		specsDirectory: options.specsDirectory,
 		commandPrefix: options.commandPrefix,
 		cliAgent
@@ -152160,16 +152177,15 @@ const plan = fnUntraced(function* (options) {
 }, scoped$1, provide$1([
 	PromptGen.layer,
 	Prd.layerProvided,
-	Worktree.layer.pipe(provide$3(layerProjectIdPrompt)),
+	Worktree.layer,
 	Settings.layer,
 	CurrentIssueSource.layer
 ]));
+var SpecNotFound = class extends TaggedError("SpecNotFound") {
+	message = "The AI agent failed to produce a specification.";
+};
 const PlanDetails = fromJsonString(Struct({ specification: String$1 }));
 
-//#endregion
-//#region src/shared/config.ts
-const configEditor = string$1("LALPH_EDITOR").pipe(orElse(() => string$1("EDITOR")), map$5(parseCommand), withDefault$3(() => ["nano"]));
-
 //#endregion
 //#region src/commands/issue.ts
 const issueTemplate = `---
@@ -152190,19 +152206,13 @@ const FrontMatterSchema = toCodecJson(Struct({
 }));
 const handler$1 = flow(withHandler(fnUntraced(function* () {
 	const source = yield* IssueSource;
-	const fs = yield* FileSystem;
 	const projectId = yield* CurrentProjectId;
-	const tempFile = yield* fs.makeTempFileScoped({ suffix: ".md" });
-	const editor = yield* configEditor;
-	yield* fs.writeFileString(tempFile, issueTemplate);
-	if ((yield* make$23(editor[0], [...editor.slice(1), tempFile], {
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit"
-	}).pipe(exitCode)) !== 0) return;
-	const content = yield* fs.readFileString(tempFile);
-	if (content.trim() === issueTemplate.trim()) return;
-	const lines = content.split("\n");
+	const content = yield* (yield* Editor).editTemp({
+		suffix: ".md",
+		initialContent: issueTemplate
+	});
+	if (isNone(content)) return;
+	const lines = content.value.split("\n");
 	const yamlLines = [];
 	let descriptionStartIndex = 0;
 	for (let i = 0; i < lines.length; i++) {
@@ -152225,7 +152235,7 @@ const handler$1 = flow(withHandler(fnUntraced(function* () {
 	}));
 	console.log(`Created issue with ID: ${created.id}`);
 	console.log(`URL: ${created.url}`);
-}, scoped$1)), provide(merge$5(layerProjectIdPrompt, CurrentIssueSource.layer)));
+}, scoped$1)), provide(mergeAll(layerProjectIdPrompt, CurrentIssueSource.layer, Editor.layer)));
 const commandIssue = make$35("issue").pipe(withDescription("Create a new issue in the selected issue source"), handler$1);
 const commandIssueAlias = make$35("i").pipe(withDescription("Alias for 'issue' command"), handler$1);
 
@@ -152233,14 +152243,8 @@ const commandIssueAlias = make$35("i").pipe(withDescription("Alias for 'issue' c
 //#region src/commands/edit.ts
 const handler = withHandler(fnUntraced(function* () {
 	const prd = yield* Prd;
-	const editor = yield* configEditor;
-	yield* make$23(editor[0], [...editor.slice(1), prd.path], {
-		extendEnv: true,
-		stdin: "inherit",
-		stdout: "inherit",
-		stderr: "inherit"
-	}).pipe(exitCode);
-}, scoped$1, provide$1(Prd.layerLocalProvided.pipe(provideMerge(layerProjectIdPrompt)))));
+	yield* (yield* Editor).edit(prd.path);
+}, provide$1([Prd.layerLocalProvided.pipe(provideMerge(layerProjectIdPrompt)), Editor.layer])));
 const commandEdit = make$35("edit").pipe(withDescription("Open the prd.yml file in your editor"), handler);
 const commandEditAlias = make$35("e").pipe(withDescription("Alias for 'edit' command"), handler);
 
@@ -152250,7 +152254,7 @@ const commandSource = make$35("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.2.19";
+var version = "0.2.20";
 
 //#endregion
 //#region src/commands/projects/ls.ts

package/package.json

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

package/src/Agents/planner.ts

@@ -5,6 +5,7 @@ import { Worktree } from "../Worktree.ts"
 import type { CliAgent } from "../domain/CliAgent.ts"
 
 export const agentPlanner = Effect.fnUntraced(function* (options: {
+  readonly plan: string
   readonly specsDirectory: string
   readonly commandPrefix: (
     command: ChildProcess.Command,

package/src/Editor.ts

@@ -0,0 +1,66 @@
+import { Cause, Effect, FileSystem, Layer, ServiceMap } from "effect"
+import { configEditor } from "./shared/config.ts"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { PlatformServices } from "./shared/platform.ts"
+
+export class Editor extends ServiceMap.Service<Editor>()("lalph/Editor", {
+  make: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const editor = yield* configEditor
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+
+    const edit = (path: string) =>
+      ChildProcess.make(editor[0]!, [...editor.slice(1), path], {
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      }).pipe(
+        ChildProcess.exitCode,
+        Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+        Effect.orDie,
+      )
+
+    const editTemp = Effect.fnUntraced(
+      function* (options: {
+        readonly initialContent?: string
+        readonly suffix?: string
+      }) {
+        const initialContent = options.initialContent ?? ""
+        const file = yield* fs.makeTempFileScoped({
+          suffix: options.suffix ?? ".txt",
+        })
+        if (initialContent) {
+          yield* fs.writeFileString(file, initialContent)
+        }
+
+        const exitCode = yield* ChildProcess.make(
+          editor[0]!,
+          [...editor.slice(1), file],
+          {
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+          },
+        ).pipe(ChildProcess.exitCode)
+
+        if (exitCode !== 0) {
+          return yield* new Cause.NoSuchElementError()
+        }
+        const content = (yield* fs.readFileString(file)).trim()
+        if (content === initialContent) {
+          return yield* new Cause.NoSuchElementError()
+        }
+        return content
+      },
+      Effect.scoped,
+      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+      Effect.option,
+    )
+
+    return { edit, editTemp } as const
+  }),
+}) {
+  static layer = Layer.effect(this, this.make).pipe(
+    Layer.provide(PlatformServices),
+  )
+}

package/src/PromptGen.ts

@@ -233,9 +233,15 @@ permission.
 ${prdNotes(options)}`
 
       const planPrompt = (options: {
+        readonly plan: string
         readonly specsDirectory: string
-      }) => `1. Ask the user for the idea / request, then your job is to create a detailed
-   specification to fulfill the request and save it as a file.
+      }) => `<request><![CDATA[
+${options.plan}
+]]></request>
+
+## Instructions
+
+1. Your job is to create a detailed specification to fulfill the request and save it as a file.
    First do some research to understand the request, then interview the user
    to gather all the necessary requirements and details for the specification.
    - If the user asks you to update an existing specification, find the relevant

package/src/commands/edit.ts

@@ -1,27 +1,20 @@
 import { Command } from "effect/unstable/cli"
 import { Effect, Layer } from "effect"
-import { ChildProcess } from "effect/unstable/process"
 import { Prd } from "../Prd.ts"
-import { configEditor } from "../shared/config.ts"
 import { layerProjectIdPrompt } from "../Projects.ts"
+import { Editor } from "../Editor.ts"
 
 const handler = Command.withHandler(
   Effect.fnUntraced(
     function* () {
       const prd = yield* Prd
-      const editor = yield* configEditor
-
-      yield* ChildProcess.make(editor[0]!, [...editor.slice(1), prd.path], {
-        extendEnv: true,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-      }).pipe(ChildProcess.exitCode)
+      const editor = yield* Editor
+      yield* editor.edit(prd.path)
     },
-    Effect.scoped,
-    Effect.provide(
+    Effect.provide([
       Prd.layerLocalProvided.pipe(Layer.provideMerge(layerProjectIdPrompt)),
-    ),
+      Editor.layer,
+    ]),
   ),
 )
 

package/src/commands/issue.ts

@@ -1,13 +1,12 @@
 import { Command } from "effect/unstable/cli"
 import { CurrentIssueSource } from "../CurrentIssueSource.ts"
-import { Effect, FileSystem, flow, Layer, Schema } from "effect"
+import { Effect, flow, Layer, Option, Schema } from "effect"
 import { IssueSource } from "../IssueSource.ts"
-import { ChildProcess } from "effect/unstable/process"
 import { PrdIssue } from "../domain/PrdIssue.ts"
 import * as Yaml from "yaml"
-import { configEditor } from "../shared/config.ts"
 import { CurrentProjectId } from "../Settings.ts"
 import { layerProjectIdPrompt } from "../Projects.ts"
+import { Editor } from "../Editor.ts"
 
 const issueTemplate = `---
 title: Issue Title
@@ -33,31 +32,18 @@ const handler = flow(
   Command.withHandler(
     Effect.fnUntraced(function* () {
       const source = yield* IssueSource
-      const fs = yield* FileSystem.FileSystem
       const projectId = yield* CurrentProjectId
-      const tempFile = yield* fs.makeTempFileScoped({
+      const editor = yield* Editor
+
+      const content = yield* editor.editTemp({
         suffix: ".md",
+        initialContent: issueTemplate,
       })
-      const editor = yield* configEditor
-      yield* fs.writeFileString(tempFile, issueTemplate)
-
-      const exitCode = yield* ChildProcess.make(
-        editor[0]!,
-        [...editor.slice(1), tempFile],
-        {
-          stdin: "inherit",
-          stdout: "inherit",
-          stderr: "inherit",
-        },
-      ).pipe(ChildProcess.exitCode)
-      if (exitCode !== 0) return
-
-      const content = yield* fs.readFileString(tempFile)
-      if (content.trim() === issueTemplate.trim()) {
+      if (Option.isNone(content)) {
         return
       }
 
-      const lines = content.split("\n")
+      const lines = content.value.split("\n")
       const yamlLines: string[] = []
       let descriptionStartIndex = 0
       for (let i = 0; i < lines.length; i++) {
@@ -93,7 +79,13 @@ const handler = flow(
       console.log(`URL: ${created.url}`)
     }, Effect.scoped),
   ),
-  Command.provide(Layer.merge(layerProjectIdPrompt, CurrentIssueSource.layer)),
+  Command.provide(
+    Layer.mergeAll(
+      layerProjectIdPrompt,
+      CurrentIssueSource.layer,
+      Editor.layer,
+    ),
+  ),
 )
 
 export const commandIssue = Command.make("issue").pipe(

package/src/commands/plan.ts

@@ -1,13 +1,4 @@
-import {
-  Data,
-  Effect,
-  FileSystem,
-  Layer,
-  Option,
-  Path,
-  pipe,
-  Schema,
-} from "effect"
+import { Data, Effect, FileSystem, Option, Path, pipe, Schema } from "effect"
 import { PromptGen } from "../PromptGen.ts"
 import { Prd } from "../Prd.ts"
 import { Worktree } from "../Worktree.ts"
@@ -17,14 +8,11 @@ import { Command, Flag } from "effect/unstable/cli"
 import { CurrentIssueSource } from "../CurrentIssueSource.ts"
 import { commandRoot } from "./root.ts"
 import { CurrentProjectId, Settings } from "../Settings.ts"
-import {
-  addOrUpdateProject,
-  layerProjectIdPrompt,
-  selectProject,
-} from "../Projects.ts"
+import { addOrUpdateProject, selectProject } from "../Projects.ts"
 import { agentPlanner } from "../Agents/planner.ts"
 import { agentTasker } from "../Agents/tasker.ts"
 import { commandPlanTasks } from "./plan/tasks.ts"
+import { Editor } from "../Editor.ts"
 
 const dangerous = Flag.boolean("dangerous").pipe(
   Flag.withAlias("d"),
@@ -46,25 +34,36 @@ export const commandPlan = Command.make("plan", {
   Command.withHandler(
     Effect.fnUntraced(
       function* ({ dangerous, withNewProject }) {
+        const editor = yield* Editor
+
+        const thePlan = yield* editor.editTemp({
+          suffix: ".md",
+        })
+        if (Option.isNone(thePlan)) return
+
         const project = withNewProject
           ? yield* addOrUpdateProject()
           : yield* selectProject
         const { specsDirectory } = yield* commandRoot
         const commandPrefix = yield* getCommandPrefix
+
         yield* plan({
+          plan: thePlan.value,
           specsDirectory,
           targetBranch: project.targetBranch,
           commandPrefix,
           dangerous,
         }).pipe(Effect.provideService(CurrentProjectId, project.id))
       },
-      Effect.provide([Settings.layer, CurrentIssueSource.layer]),
+      Effect.provide([Settings.layer, CurrentIssueSource.layer, Editor.layer]),
     ),
   ),
   Command.withSubcommands([commandPlanTasks]),
 )
+
 const plan = Effect.fnUntraced(
   function* (options: {
+    readonly plan: string
     readonly specsDirectory: string
     readonly targetBranch: Option.Option<string>
     readonly commandPrefix: (
@@ -75,23 +74,27 @@ const plan = Effect.fnUntraced(
     const fs = yield* FileSystem.FileSystem
     const pathService = yield* Path.Path
     const worktree = yield* Worktree
+
     const cliAgent = yield* getOrSelectCliAgent
 
     yield* agentPlanner({
+      plan: options.plan,
       specsDirectory: options.specsDirectory,
       commandPrefix: options.commandPrefix,
       dangerous: options.dangerous,
       cliAgent,
     })
 
-    yield* Effect.log("Converting specification into tasks")
     const planDetails = yield* pipe(
       fs.readFileString(
         pathService.join(worktree.directory, ".lalph", "plan.json"),
       ),
       Effect.flatMap(Schema.decodeEffect(PlanDetails)),
+      Effect.mapError(() => new SpecNotFound()),
     )
 
+    yield* Effect.log("Converting specification into tasks")
+
     yield* agentTasker({
       specificationPath: planDetails.specification,
       specsDirectory: options.specsDirectory,
@@ -114,7 +117,7 @@ const plan = Effect.fnUntraced(
   Effect.provide([
     PromptGen.layer,
     Prd.layerProvided,
-    Worktree.layer.pipe(Layer.provide(layerProjectIdPrompt)),
+    Worktree.layer,
     Settings.layer,
     CurrentIssueSource.layer,
   ]),