lalph 0.3.44 → 0.3.45

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.3.44",
+  "version": "0.3.45",
   "publishConfig": {
     "access": "public"
   },
@@ -22,18 +22,17 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.6.0",
     "@changesets/cli": "^2.30.0",
-    "@effect/ai-openai": "https://pkg.pr.new/Effect-TS/effect-smol/@effect/ai-openai@d440fd4",
     "@effect/language-service": "^0.79.0",
-    "@effect/platform-node": "4.0.0-beta.29",
-    "@linear/sdk": "^76.0.0",
+    "@effect/platform-node": "4.0.0-beta.30",
+    "@linear/sdk": "^77.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
     "@octokit/types": "^16.0.0",
-    "@typescript/native-preview": "7.0.0-dev.20260308.1",
-    "clanka": "^0.0.14",
+    "@typescript/native-preview": "7.0.0-dev.20260310.1",
+    "clanka": "^0.0.15",
     "concurrently": "^9.2.1",
-    "effect": "4.0.0-beta.29",
+    "effect": "4.0.0-beta.30",
     "husky": "^9.1.7",
-    "lint-staged": "^16.3.2",
+    "lint-staged": "^16.3.3",
     "octokit": "^5.0.5",
     "oxlint": "^1.52.0",
     "prettier": "^3.8.1",

package/src/Agents/chooser.ts

@@ -1,4 +1,13 @@
-import { Data, Duration, Effect, FileSystem, Path, pipe, Schema } from "effect"
+import {
+  Data,
+  Deferred,
+  Duration,
+  Effect,
+  FileSystem,
+  Path,
+  pipe,
+  Schema,
+} from "effect"
 import { PromptGen } from "../PromptGen.ts"
 import { Prd } from "../Prd.ts"
 import { ChildProcess } from "effect/unstable/process"
@@ -7,6 +16,8 @@ import { RunnerStalled } from "../domain/Errors.ts"
 import { makeWaitForFile } from "../shared/fs.ts"
 import { GitFlow } from "../GitFlow.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { runClanka } from "../Clanka.ts"
+import { ChosenTaskDeferred } from "../TaskTools.ts"
 
 export const agentChooser = Effect.fnUntraced(function* (options: {
   readonly stallTimeout: Duration.Duration
@@ -20,6 +31,29 @@ export const agentChooser = Effect.fnUntraced(function* (options: {
   const gitFlow = yield* GitFlow
   const waitForFile = yield* makeWaitForFile
 
+  // use clanka
+  if (!options.preset.cliAgent.command) {
+    const deferred = ChosenTaskDeferred.of(Deferred.makeUnsafe())
+    const result = yield* runClanka({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      prompt: promptGen.promptChooseClanka({ gitFlow }),
+      stallTimeout: options.stallTimeout,
+      withChoose: true,
+    }).pipe(
+      Effect.provideService(ChosenTaskDeferred, deferred),
+      Effect.flatMap(() => Effect.fail(new ChosenTaskNotFound())),
+      Effect.raceFirst(Deferred.await(deferred)),
+    )
+    const prdTask = yield* prd.findById(result.taskId)
+    if (!prdTask) throw new ChosenTaskNotFound()
+    return {
+      id: result.taskId,
+      githubPrNumber: result.githubPrNumber ?? null,
+      prd: prdTask,
+    }
+  }
+
   const taskJsonCreated = waitForFile(
     pathService.join(worktree.directory, ".lalph"),
     "task.json",

package/src/Agents/reviewer.ts

@@ -4,6 +4,8 @@ import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import { GitFlow } from "../GitFlow.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { ExitCode } from "effect/unstable/process/ChildProcessSpawner"
+import { runClanka } from "../Clanka.ts"
 
 export const agentReviewer = Effect.fnUntraced(function* (options: {
   readonly specsDirectory: string
@@ -22,6 +24,29 @@ export const agentReviewer = Effect.fnUntraced(function* (options: {
     Effect.option,
   )
 
+  // use clanka
+  if (!options.preset.cliAgent.command) {
+    yield* runClanka({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      system: promptGen.systemClanka(options),
+      prompt: Option.match(customInstructions, {
+        onNone: () =>
+          promptGen.promptReview({
+            prompt: options.instructions,
+            gitFlow,
+          }),
+        onSome: (prompt) =>
+          promptGen.promptReviewCustom({
+            prompt,
+            specsDirectory: options.specsDirectory,
+          }),
+      }),
+      stallTimeout: options.stallTimeout,
+    })
+    return ExitCode(0)
+  }
+
   const cliCommand = pipe(
     options.preset.cliAgent.command({
       prompt: Option.match(customInstructions, {

package/src/Agents/tasker.ts

@@ -3,6 +3,8 @@ import { PromptGen } from "../PromptGen.ts"
 import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { ExitCode } from "effect/unstable/process/ChildProcessSpawner"
+import { runClanka } from "../Clanka.ts"
 
 export const agentTasker = Effect.fnUntraced(function* (options: {
   readonly specsDirectory: string
@@ -13,6 +15,20 @@ export const agentTasker = Effect.fnUntraced(function* (options: {
   const worktree = yield* Worktree
   const promptGen = yield* PromptGen
 
+  // use clanka
+  if (!options.preset.cliAgent.command) {
+    yield* runClanka({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      system: promptGen.systemClanka(options),
+      prompt: promptGen.promptPlanTasksClanka({
+        specsDirectory: options.specsDirectory,
+        specificationPath: options.specificationPath,
+      }),
+    })
+    return ExitCode(0)
+  }
+
   return yield* pipe(
     options.preset.cliAgent.command({
       prompt: promptGen.promptPlanTasks({

package/src/Agents/timeout.ts

@@ -4,6 +4,8 @@ import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { PrdIssue } from "../domain/PrdIssue.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { ExitCode } from "effect/unstable/process/ChildProcessSpawner"
+import { runClanka } from "../Clanka.ts"
 
 export const agentTimeout = Effect.fnUntraced(function* (options: {
   readonly specsDirectory: string
@@ -15,6 +17,21 @@ export const agentTimeout = Effect.fnUntraced(function* (options: {
   const worktree = yield* Worktree
   const promptGen = yield* PromptGen
 
+  // use clanka
+  if (!options.preset.cliAgent.command) {
+    yield* runClanka({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      system: promptGen.systemClanka(options),
+      prompt: promptGen.promptTimeoutClanka({
+        taskId: options.task.id!,
+        specsDirectory: options.specsDirectory,
+      }),
+      stallTimeout: options.stallTimeout,
+    })
+    return ExitCode(0)
+  }
+
   const timeoutCommand = pipe(
     options.preset.cliAgent.command({
       prompt: promptGen.promptTimeout({

package/src/Agents/worker.ts

@@ -2,15 +2,30 @@ import { Duration, Effect, Path, pipe } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { Worktree } from "../Worktree.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { runClanka } from "../Clanka.ts"
+import { ExitCode } from "effect/unstable/process/ChildProcessSpawner"
 
 export const agentWorker = Effect.fnUntraced(function* (options: {
   readonly stallTimeout: Duration.Duration
   readonly preset: CliAgentPreset
+  readonly system?: string
   readonly prompt: string
 }) {
   const pathService = yield* Path.Path
   const worktree = yield* Worktree
 
+  // use clanka
+  if (!options.preset.cliAgent.command) {
+    yield* runClanka({
+      directory: worktree.directory,
+      model: options.preset.extraArgs.join(" "),
+      system: options.system,
+      prompt: options.prompt,
+      stallTimeout: options.stallTimeout,
+    })
+    return ExitCode(0)
+  }
+
   const cliCommand = pipe(
     options.preset.cliAgent.command({
       prompt: options.prompt,

package/src/Clanka.ts

@@ -5,7 +5,7 @@ import {
   TaskToolsHandlers,
   TaskToolsWithChoose,
 } from "./TaskTools.ts"
-import { clankaSubagent } from "./ClankaModels.ts"
+import { ClankaModels, clankaSubagent } from "./ClankaModels.ts"
 import { withStallTimeout } from "./shared/stream.ts"
 import type { AiError } from "effect/unstable/ai"
 import type { RunnerStalled } from "./domain/Errors.ts"
@@ -14,18 +14,21 @@ export const runClanka = Effect.fnUntraced(
   /** The working directory to run the agent in */
   function* (options: {
     readonly directory: string
+    readonly model: string
     readonly prompt: string
     readonly system?: string | undefined
     readonly stallTimeout?: Duration.Input | undefined
     readonly withChoose?: boolean | undefined
   }) {
+    const models = yield* ClankaModels
     const agent = yield* Agent.make({
       ...options,
       tools: options.withChoose
         ? TaskToolsWithChoose
         : (TaskTools as unknown as typeof TaskToolsWithChoose),
-      subagentModel: clankaSubagent,
-    })
+      subagentModel: clankaSubagent(models, options.model),
+    }).pipe(Effect.provide(models.get(options.model)))
+
     let stream = options.stallTimeout
       ? withStallTimeout(options.stallTimeout)(agent.output)
       : agent.output

package/src/ClankaModels.ts

@@ -1,53 +1,72 @@
+// oxlint-disable typescript/no-explicit-any
 import { NodeHttpClient } from "@effect/platform-node"
-import { Codex } from "clanka"
-import { Layer, LayerMap, PlatformError, Schema } from "effect"
+import { Codex, Copilot } from "clanka"
+import { Effect, flow, Layer, LayerMap, Schema } from "effect"
 import { layerKvs } from "./Kvs.ts"
-import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai"
 
-export const CodexLayer: Layer.Layer<
-  OpenAiClient.OpenAiClient,
-  PlatformError.PlatformError
-> = Codex.layer.pipe(
-  Layer.provide(NodeHttpClient.layerUndici),
-  Layer.provide(layerKvs),
+export const ModelServices = NodeHttpClient.layerUndici.pipe(
+  Layer.merge(layerKvs),
 )
 
-export const clankaModels = {
-  "gpt-5.4-xhigh": OpenAiLanguageModel.model("gpt-5.4", {
-    reasoning: {
-      effort: "xhigh",
-      summary: "auto",
-    },
-  }).pipe(Layer.provideMerge(CodexLayer)),
-  "gpt-5.4-high": OpenAiLanguageModel.model("gpt-5.4", {
-    reasoning: {
-      effort: "high",
-      summary: "auto",
-    },
-  }).pipe(Layer.provideMerge(CodexLayer)),
-  "gpt-5.4-medium": OpenAiLanguageModel.model("gpt-5.4", {
-    reasoning: {
-      effort: "high",
-      summary: "auto",
-    },
-  }).pipe(Layer.provideMerge(CodexLayer)),
-} as const
-
-export type ClankaModel = keyof typeof clankaModels
-export const ClankaModel = Schema.Literals(
-  Object.keys(clankaModels) as ClankaModel[],
+const Reasoning = Schema.Literals(["low", "medium", "high", "xhigh"])
+const parseInput = flow(
+  Schema.decodeUnknownEffect(
+    Schema.Tuple([
+      Schema.Literals(["openai", "copilot"]),
+      Schema.String,
+      Reasoning,
+    ]),
+  ),
+  Effect.orDie,
 )
 
-export const clankaSubagent = OpenAiLanguageModel.model("gpt-5.4", {
-  reasoning: {
-    effort: "low",
-    summary: "auto",
-  },
-}).pipe(Layer.provideMerge(CodexLayer))
+export const clankaSubagent = Effect.fnUntraced(function* (
+  models: ClankaModels["Service"],
+  input: string,
+) {
+  const [provider, model] = yield* parseInput(input.split("/"))
+  return models.get(`${provider}/${model}/low`)
+}, Layer.unwrap)
 
 export class ClankaModels extends LayerMap.Service<ClankaModels>()(
   "lalph/ClankaModels",
   {
-    layers: clankaModels,
+    dependencies: [ModelServices],
+    lookup: Effect.fnUntraced(function* (input: string) {
+      const [provider, model, reasoning] = yield* parseInput(input.split("/"))
+      switch (provider) {
+        case "openai": {
+          return Codex.model(model, {
+            reasoning: {
+              effort: reasoning,
+            },
+          })
+        }
+        case "copilot": {
+          return Copilot.model(model, {
+            ...reasoningToCopilotConfig(model, reasoning),
+          })
+        }
+      }
+    }, Layer.unwrap),
   },
 ) {}
+
+const reasoningToCopilotConfig = (
+  model: string,
+  reasoning: typeof Reasoning.Type,
+) => {
+  if (model.startsWith("claude")) {
+    switch (reasoning) {
+      case "low":
+        return {}
+      case "medium":
+        return { reasoningEffort: 4000 }
+      case "high":
+        return { thinking_budget: 16000 }
+      case "xhigh":
+        return { thinking_budget: 31999 }
+    }
+  }
+  return { reasoningEffort: reasoning }
+}

package/src/Presets.ts

@@ -5,7 +5,6 @@ import { Prompt } from "effect/unstable/cli"
 import { allCliAgents, type AnyCliAgent } from "./domain/CliAgent.ts"
 import { parseCommand } from "./shared/child-process.ts"
 import { IssueSource } from "./IssueSource.ts"
-import { ClankaModel, clankaModels } from "./ClankaModels.ts"
 
 export const allCliAgentPresets = new Setting(
   "cliAgentPresets",
@@ -120,29 +119,12 @@ export const addOrUpdatePreset = Effect.fnUntraced(function* (options?: {
     options?.existing?.commandPrefix,
   )
 
-  const clankaModel = yield* Prompt.select<ClankaModel | undefined>({
-    message: "clanka model?",
-    choices: [
-      {
-        title: "none",
-        value: undefined,
-        selected: options?.existing?.clankaModel === undefined,
-      },
-      ...(Object.keys(clankaModels) as Array<ClankaModel>).map((key) => ({
-        title: key,
-        value: key,
-        selected: options?.existing?.clankaModel === key,
-      })),
-    ],
-  })
-
   let preset = new CliAgentPreset({
     id,
     cliAgent,
     commandPrefix,
     extraArgs,
     sourceMetadata: {},
-    ...(clankaModel ? { clankaModel } : {}),
   })
 
   if (id !== CliAgentPreset.defaultId) {

package/src/PromptGen.ts

@@ -90,19 +90,17 @@ Set \`githubPrNumber\` to the PR number if one exists, otherwise use \`null\`.
 
       const promptChooseClanka = (options: {
         readonly gitFlow: GitFlow["Service"]
-      }) => `Your job is to choose the next task to work on from the current task list.
+      }) => `Your job is to choose the next task to work on using "listEligibleTasks".
 **DO NOT** implement the task yet.
 
 The following instructions should be done without interaction or asking for permission.
 
-- Decide which single task to work on next from the task list. This should
+- Decide which single task to work on next from "listEligibleTasks". This should
   be the task YOU decide as the most important to work on next, not just the
-  first task in the list.
-  - Only start tasks that are in a "todo" state.
-  - You **cannot** start tasks unless they have an empty \`blockedBy\` field.${
+  first task in the list.${
     options.gitFlow.requiresGithubPr
       ? `
-- Check if there is an open Github PR for the chosen task. If there is, note the PR number for inclusion in the task.json file.
+- Check if there is an open Github PR for the chosen task. If there is, note the PR number for inclusion when calling "chooseTask".
    - Only include "open" PRs that are not yet merged.
    - The pull request will contain the task id in the title or description.`
       : ""
@@ -227,16 +225,16 @@ ${keyInformation(options)}`
         readonly specsDirectory: string
         readonly githubPrNumber: number | undefined
         readonly gitFlow: GitFlow["Service"]
-      }) => `Your job is to implement this task:
+      }) => `# ${options.task.title}
 
-ID: ${options.task.id}
-Task: ${options.task.title}
-Description:
+Task ID: ${options.task.id}
 
 ${options.task.description}
 
 # Workflow
 
+All steps must be done before the task can be considered complete.
+
 1. Carefully study the current task list to understand the context of the task, and
    discover any key learnings from previous work.
    Also read the ${options.specsDirectory}/README.md file (if available), to see
@@ -324,11 +322,9 @@ 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. Mark the original task as "done" by updating its \`state\`.
-3. Break down the task into smaller tasks and add them to the prd.yml file.
+3. Break down the task into smaller tasks and add them to the task list.
    Read the "### Adding tasks" section below **extremely carefully** for guidelines on creating tasks.
-4. Setup task dependencies using the \`blockedBy\` field as needed. You will need
-   to wait 5 seconds after adding tasks to the prd.yml file to allow the system
-   to assign ids to the new tasks before you can setup dependencies.
+   - Make sure to setup task dependencies using the \`blockedBy\` field as needed.
 5. If any specifications need updating based on your new understanding, update them.`
 
       const planPrompt = (options: {
@@ -415,6 +411,23 @@ setup dependencies between the tasks using the \`blockedBy\` field.
  
 ${prdNotes(options)}`
 
+      const promptPlanTasksClanka = (options: {
+        readonly specsDirectory: string
+        readonly specificationPath: string
+      }) => `Your job is to convert the implementation plan in the specification file at
+\`${options.specificationPath}\` into tasks.
+
+Before starting, read the entire task list to understand the context of existing tasks
+and to ensure you do not create duplicate tasks.
+
+Make sure each task is small, atomic and independently shippable without failing
+validation checks (typechecks, linting, tests).
+Each task should include a reference to the specification file in its description.
+
+Make sure to setup dependencies between the tasks using the \`blockedBy\` field.
+
+**Important:** You are only creating or updating a plan, not implementing any tasks yet.`
+
       return {
         promptChoose,
         promptChooseClanka,
@@ -426,6 +439,7 @@ ${prdNotes(options)}`
         promptTimeoutClanka,
         planPrompt,
         promptPlanTasks,
+        promptPlanTasksClanka,
         systemClanka,
       } as const
     }),

package/src/commands/agents/ls.ts

@@ -30,7 +30,6 @@ export const commandAgentsLs = Command.make("ls").pipe(
         console.log(`Preset: ${preset.id}`)
         yield* source.cliAgentPresetInfo(preset)
         console.log(`  CLI agent: ${preset.cliAgent.name}`)
-        console.log(`  Clanka model: ${preset.clankaModel ?? "none"}`)
         if (preset.extraArgs.length > 0) {
           console.log(`  Extra args: ${preset.extraArgs.join(" ")}`)
         }

package/src/commands/plan/tasks.ts

@@ -10,6 +10,7 @@ import { commandRoot } from "../root.ts"
 import { selectCliAgentPreset } from "../../Presets.ts"
 import { CurrentIssueSource } from "../../CurrentIssueSource.ts"
 import type { CliAgentPreset } from "../../domain/CliAgentPreset.ts"
+import { ClankaModels } from "../../ClankaModels.ts"
 
 const specificationPath = Argument.path("spec", {
   pathType: "file",
@@ -70,8 +71,9 @@ const generateTasks = Effect.fnUntraced(
     })
   },
   Effect.provide([
+    ClankaModels.layer,
     Settings.layer,
     PromptGen.layer,
-    Prd.layerProvided.pipe(Layer.provide(layerProjectIdPrompt)),
+    Prd.layerProvided.pipe(Layer.provideMerge(layerProjectIdPrompt)),
   ]),
 )

package/src/commands/plan.ts

@@ -15,6 +15,7 @@ import { selectCliAgentPreset } from "../Presets.ts"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { parseBranch } from "../shared/git.ts"
 import type { CliAgentPreset } from "../domain/CliAgentPreset.ts"
+import { ClankaModels } from "../ClankaModels.ts"
 
 const dangerous = Flag.boolean("dangerous").pipe(
   Flag.withAlias("d"),
@@ -74,7 +75,13 @@ export const commandPlan = Command.make("plan", {
           dangerous,
           preset,
         }).pipe(Effect.provideService(CurrentProjectId, project.id))
-      }).pipe(Effect.provide([Settings.layer, CurrentIssueSource.layer]))
+      }).pipe(
+        Effect.provide([
+          Settings.layer,
+          CurrentIssueSource.layer,
+          ClankaModels.layer,
+        ]),
+      )
     }, Effect.provide(Editor.layer)),
   ),
   Command.withSubcommands([commandPlanTasks]),