saeeol 1.1.0 → 1.1.1

package/src/session/prompt-loop.ts

@@ -0,0 +1,299 @@
+import { Effect, Latch, Option } from "effect"
+import * as EffectLogger from "@saeeol/core/effect/logger"
+import * as Log from "@saeeol/core/util/log"
+import { SessionID, MessageID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import * as Session from "./session"
+import { SaeeolSession } from "@/saeeol/session"
+import { SaeeolSessionPrompt } from "@/saeeol/session/prompt"
+import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
+import { SaeeolSessionProcessor } from "@/saeeol/session/processor"
+import { InstanceState } from "@/effect/instance-state"
+import { EffectBridge } from "@/effect/bridge"
+import { type TaskPromptOps } from "@/tool/task"
+import { NamedError } from "@saeeol/core/util/error"
+import MAX_STEPS from "./prompt/max-steps.txt"
+import { type PromptInput, type ShellInput, LoopInput, STRUCTURED_OUTPUT_SYSTEM_PROMPT, REQUEST_PRUNE_BYTES, createStructuredOutputTool } from "./prompt-schemas"
+import type { PromptDeps } from "./prompt-types"
+const elog = EffectLogger.create({ service: "session.prompt" })
+const log = Log.create({ service: "session.prompt" })
+
+export interface LoopHelpers {
+  getModel: (...args: any[]) => any
+  lastModel: (...args: any[]) => any
+  lastAssistant: (...args: any[]) => any
+  createUserMessage: (...args: any[]) => any
+  ensureTitle: (...args: any[]) => any
+  insertReminders: (...args: any[]) => any
+  resolvePromptParts: (...args: any[]) => any
+  commandHandler: (...args: any[]) => any
+  prompt: (...args: any[]) => any
+  cancel: (...args: any[]) => any
+}
+
+export function createRunLoop(deps: PromptDeps, helpers: LoopHelpers) {
+  const closeReasons = new Map<string, any>()
+  const resolveTools = (input: any) => deps.resolveToolsSvc.resolve(input)
+  const runner = Effect.fn("SessionPrompt.runner")(function* () { return yield* EffectBridge.make() })
+  const ops = Effect.fn("SessionPrompt.ops")(function* () {
+    const run = yield* runner()
+    return {
+      cancel: (id: SessionID) => run.fork(helpers.cancel(id)),
+      resolvePromptParts: (t: string) => helpers.resolvePromptParts(t),
+      prompt: (input: PromptInput) => helpers.prompt(input),
+    } satisfies TaskPromptOps
+  })
+  const handleSubtask = (input: any) => Effect.gen(function* () {
+    const ops_ = yield* ops()
+    return yield* deps.subtaskSvc.handle({ ...input, getModel: helpers.getModel, promptOps: ops_ })
+  })
+  const shellImpl = (input: ShellInput, ready?: Latch.Latch) =>
+    deps.shellSvc.exec(input, helpers.getModel, helpers.lastModel as any, ready)
+  const runLoop = Effect.fn("SessionPrompt.run")(function* (sessionID: SessionID) {
+    const envCache: SaeeolSessionPrompt.EnvCache = {}
+    closeReasons.delete(sessionID)
+    let compactionAttempts = 0
+    const ctx = yield* InstanceState.context
+    const slog = elog.with({ sessionID })
+    let structured: unknown | undefined
+    let step = 0
+    const session = yield* deps.sessions.get(sessionID)
+    while (true) {
+      yield* deps.status.set(sessionID, { type: "busy" })
+      yield* slog.info("loop", { step })
+      let msgs: MessageV2.WithParts[] = yield* MessageV2.filterCompactedEffect(sessionID)
+      msgs = SaeeolSessionPromptQueue.scope(sessionID, msgs)
+      msgs = SaeeolSessionPrompt.trimBeforeLastSummary(msgs)
+      let lastUser: MessageV2.User | undefined, lastAssistant: MessageV2.Assistant | undefined, lastFinished: MessageV2.Assistant | undefined
+      let tasks: (MessageV2.CompactionPart | MessageV2.SubtaskPart)[] = []
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        const msg = msgs[i]
+        if (!lastUser && msg.info.role === "user") lastUser = msg.info
+        if (!lastAssistant && msg.info.role === "assistant") lastAssistant = msg.info
+        if (!lastFinished && msg.info.role === "assistant" && msg.info.finish) lastFinished = msg.info
+        if (lastUser && lastFinished) break
+        const task = msg.parts.filter((part) => part.type === "compaction" || part.type === "subtask")
+        if (task && !lastFinished) tasks.push(...task)
+      }
+      if (!lastUser) throw new Error("No user message found in stream.")
+      const telemetry = SaeeolSessionProcessor.extractReviewTelemetry(
+        msgs.findLast((m) => m.info.role === "user" && m.info.id === lastUser.id)?.parts ?? [],
+      )
+      const lastAssistantMsg = msgs.findLast(
+        (msg) => msg.info.role === "assistant" && msg.info.id === lastAssistant?.id,
+      )
+      const hasToolCalls = lastAssistantMsg?.parts.some((part) => part.type === "tool" && !part.metadata?.providerExecuted) ?? false
+      if (lastAssistant?.finish && hasToolCalls && lastAssistant.parentID === lastUser.id &&
+        lastUser.id < lastAssistant.id &&
+        SaeeolSessionPrompt.shouldAskPlanFollowup({ messages: msgs, abort: AbortSignal.any([]) })
+      ) {
+        const action = yield* Effect.promise((signal) =>
+          SaeeolSessionPrompt.askPlanFollowup({ sessionID, messages: msgs, abort: signal }),
+        )
+        if (action === "continue") continue
+        yield* slog.info("exiting loop")
+        break
+      }
+      if (lastAssistant?.finish && !["tool-calls"].includes(lastAssistant.finish) &&
+        !hasToolCalls && lastAssistant.parentID === lastUser.id && lastUser.id < lastAssistant.id
+      ) {
+        const action = yield* Effect.promise((signal) =>
+          SaeeolSessionPrompt.askPlanFollowup({ sessionID, messages: msgs, abort: signal }),
+        )
+        if (action === "continue") continue
+        yield* slog.info("exiting loop")
+        break
+      }
+      step++
+      if (step === 1)
+        yield* helpers.ensureTitle({
+          session, modelID: lastUser.model.modelID, providerID: lastUser.model.providerID, history: msgs,
+        }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
+      const model = yield* helpers.getModel(lastUser.model.providerID, lastUser.model.modelID, sessionID)
+      const task = tasks.pop()
+      if (task?.type === "subtask") {
+        yield* handleSubtask({ task, model, lastUser, sessionID, session, msgs })
+        continue
+      }
+      if (task?.type === "compaction") {
+        const result = yield* deps.compaction.process({
+          messages: msgs, parentID: lastUser.id, sessionID, auto: task.auto, overflow: task.overflow,
+        })
+        if (result === "stop") { closeReasons.set(sessionID, "error"); break }
+        continue
+      }
+      if (lastFinished && lastFinished.summary !== true &&
+        (yield* deps.compaction.isOverflow({ tokens: lastFinished.tokens, model }))
+      ) {
+        const guard = SaeeolSessionPrompt.guardCompactionAttempt({
+          sessionID, attempts: compactionAttempts, closeReasons, message: lastFinished,
+        })
+        if (guard.exhausted) {
+          yield* deps.sessions.updateMessage(lastFinished)
+          yield* deps.bus.publish(Session.Event.Error, { sessionID, error: guard.error })
+          break
+        }
+        compactionAttempts++
+        yield* deps.compaction.create({ sessionID, agent: lastUser.agent, model: lastUser.model, auto: true })
+        continue
+      }
+      const agent = yield* deps.agents.get(lastUser.agent)
+      if (!agent) {
+        const available = (yield* deps.agents.list()).filter((a: any) => !a.hidden).map((a: any) => a.name)
+        const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
+        const error = new NamedError.Unknown({ message: `Agent not found: "${lastUser.agent}".${hint}` })
+        yield* deps.bus.publish(Session.Event.Error, { sessionID, error: error.toObject() })
+        throw error
+      }
+      const maxSteps = agent.steps ?? Infinity
+      const isLastStep = step >= maxSteps
+      msgs = yield* helpers.insertReminders({ messages: msgs, agent, session })
+      const msg: MessageV2.Assistant = {
+        id: MessageID.ascending(), parentID: lastUser.id, role: "assistant", mode: agent.name,
+        agent: agent.name, variant: lastUser.model.variant, path: { cwd: ctx.directory, root: ctx.worktree },
+        cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        modelID: model.id, providerID: model.providerID, time: { created: Date.now() }, sessionID,
+      }
+      yield* deps.sessions.updateMessage(msg)
+      const handle = yield* deps.processor.create({ assistantMessage: msg, sessionID, model, telemetry })
+      const outcome: "break" | "continue" = yield* Effect.gen(function* () {
+        const lastUserMsg = msgs.findLast((m) => m.info.role === "user")
+        const bypassAgentCheck = lastUserMsg?.parts.some((p) => p.type === "agent") ?? false
+        const tools = yield* resolveTools({
+          agent, session, model, tools: lastUser.tools, processor: handle,
+          bypassAgentCheck, messages: msgs,
+        })
+        if (lastUser.format?.type === "json_schema") {
+          tools["StructuredOutput"] = createStructuredOutputTool({
+            schema: lastUser.format.schema,
+            onSuccess(output: unknown) { structured = output },
+          })
+        }
+        if (step === 1)
+          yield* deps.summary.summarize({ sessionID, messageID: lastUser.id }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
+        if (step > 1 && lastFinished) {
+          for (const m of msgs) {
+            if (m.info.role !== "user" || m.info.id <= lastFinished.id) continue
+            for (const p of m.parts) {
+              if (p.type !== "text" || p.ignored || p.synthetic || !p.text.trim()) continue
+              p.text = ["<system-reminder>", "The user sent the following message:", p.text, "",
+                "Please address this message and continue with your tasks.", "</system-reminder>"].join("\n")
+            }
+          }
+        }
+        yield* deps.plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
+        SaeeolSessionPrompt.injectEditorContext({ msgs, lastUser, sessionID, cache: envCache })
+        msgs = SaeeolSessionPrompt.maybeStripHistoricalMedia(msgs)
+        const allResult: any = yield* Effect.all([
+          deps.sys.skills(agent), deps.sys.environment(model, lastUser.editorContext),
+          deps.instruction.system().pipe(Effect.orDie),
+        ])
+        const skills: any = allResult[0], env: any[] = allResult[1], instructions: any[] = allResult[2]
+        let modelMsgs = yield* MessageV2.toModelMessagesEffect(msgs, model)
+        const size = Buffer.byteLength(JSON.stringify(modelMsgs))
+        if (size > REQUEST_PRUNE_BYTES) {
+          yield* deps.compaction.prune({ sessionID, reason: "payload-limit" })
+          msgs = yield* MessageV2.filterCompactedEffect(sessionID)
+          msgs = SaeeolSessionPromptQueue.scope(sessionID, msgs)
+          msgs = SaeeolSessionPrompt.trimBeforeLastSummary(msgs)
+          yield* deps.plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
+          SaeeolSessionPrompt.injectEditorContext({ msgs, lastUser, sessionID, cache: envCache })
+          msgs = SaeeolSessionPrompt.maybeStripHistoricalMedia(msgs)
+          modelMsgs = yield* MessageV2.toModelMessagesEffect(msgs, model)
+          const nextSize = Buffer.byteLength(JSON.stringify(modelMsgs))
+          if (nextSize > REQUEST_PRUNE_BYTES) log.warn("payload still large after pruning", { size: nextSize })
+        }
+        const system = [...env, ...instructions, ...(skills ? [skills] : [])]
+        const format = lastUser.format ?? { type: "text" as const }
+        if (format.type === "json_schema") system.push(STRUCTURED_OUTPUT_SYSTEM_PROMPT)
+        const result = yield* handle.process({
+          user: lastUser, agent, permission: SaeeolSessionPrompt.guardPermissions({ agent, session }),
+          sessionID, parentSessionID: session.parentID, system,
+          messages: [...modelMsgs, ...(isLastStep ? [{ role: "assistant" as const, content: MAX_STEPS }] : [])],
+          tools, model, toolChoice: format.type === "json_schema" ? "required" : undefined,
+        })
+        if (structured !== undefined) {
+          handle.message.structured = structured
+          handle.message.finish = handle.message.finish ?? "stop"
+          yield* deps.sessions.updateMessage(handle.message)
+          return "break" as const
+        }
+        const finished = handle.message.finish && !["tool-calls", "unknown"].includes(handle.message.finish)
+        if (finished && !handle.message.error) {
+          if (format.type === "json_schema") {
+            handle.message.error = new MessageV2.StructuredOutputError({
+              message: "Model did not produce structured output", retries: 0,
+            }).toObject()
+            yield* deps.sessions.updateMessage(handle.message)
+            return "break" as const
+          }
+          if (handle.message.finish === "error") {
+            SaeeolSessionProcessor.providerFinishError(handle.message)
+            yield* deps.sessions.updateMessage(handle.message)
+            closeReasons.set(sessionID, "error")
+            return "break" as const
+          }
+        }
+        if (result === "stop") {
+          if (handle.message.error) closeReasons.set(sessionID, "error")
+          return "break" as const
+        }
+        if (result === "compact") {
+          const guard = SaeeolSessionPrompt.guardCompactionAttempt({
+            sessionID, attempts: compactionAttempts, closeReasons, message: handle.message,
+          })
+          if (guard.exhausted) {
+            yield* deps.sessions.updateMessage(handle.message)
+            yield* deps.bus.publish(Session.Event.Error, { sessionID, error: guard.error })
+            return "break" as const
+          }
+          compactionAttempts++
+          yield* deps.compaction.create({
+            sessionID, agent: lastUser.agent, model: lastUser.model, auto: true,
+            overflow: !handle.message.finish,
+          })
+        }
+        if (SaeeolSessionPromptQueue.hasFollowup(sessionID)) {
+          closeReasons.set(sessionID, "interrupted")
+          return "break" as const
+        }
+        if (result !== "compact" && !handle.message.finish) {
+          handle.message.finish = "unknown"
+          yield* deps.sessions.updateMessage(handle.message)
+        }
+        return "continue" as const
+      }).pipe(Effect.ensuring(deps.instruction.clear(handle.message.id)))
+      if (outcome === "break") break
+      continue
+    }
+    yield* deps.compaction.prune({ sessionID, reason: "normal" }).pipe(Effect.ignore, Effect.forkIn(deps.scope))
+    return yield* helpers.lastAssistant(sessionID)
+  })
+  const loop = Effect.fn("SessionPrompt.loop")(function* (input: LoopInput) {
+    yield* SaeeolSessionPrompt.recoverDanglingAssistant({
+      sessionID: input.sessionID, status: deps.status, sessions: deps.sessions,
+    })
+    yield* SaeeolSessionPrompt.recoverProviderFinishError({
+      sessionID: input.sessionID, status: deps.status, sessions: deps.sessions,
+    })
+    yield* deps.bus.publish(SaeeolSession.Event.TurnOpen, { sessionID: input.sessionID })
+    return yield* Effect.onExit(
+      deps.state.ensureRunning(input.sessionID, helpers.lastAssistant(input.sessionID), runLoop(input.sessionID)),
+      Effect.fnUntraced(function* (exit) {
+        yield* deps.bus.publish(SaeeolSession.Event.TurnClose, {
+          sessionID: input.sessionID,
+          reason: SaeeolSessionPrompt.resolveCloseReason({
+            sessionID: input.sessionID, closeReasons, exit,
+          }),
+        })
+      }),
+    )
+  })
+  const shell = Effect.fn("SessionPrompt.shell")(function* (input: ShellInput) {
+    const ready = yield* Latch.make()
+    return yield* deps.state.startShell(
+      input.sessionID, helpers.lastAssistant(input.sessionID), shellImpl(input, ready), ready,
+    )
+  })
+  return { runLoop, loop, shell, closeReasons }
+}

package/src/session/prompt-model.ts

@@ -0,0 +1,44 @@
+import { Effect, Exit, Cause, Option, Types } from "effect"
+import { SessionID, MessageID, PartID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import { NamedError } from "@saeeol/core/util/error"
+import * as Log from "@saeeol/core/util/log"
+import type { PromptInput } from "./prompt-schemas"
+import type { ModelID, ProviderID } from "../provider/schema"
+import type { PromptDeps } from "./prompt-types"
+
+const log = Log.create({ service: "session.prompt" })
+
+export const getModel = (deps: PromptDeps) =>
+  Effect.fn("SessionPrompt.getModel")(function* (providerID: ProviderID, modelID: ModelID, sessionID: SessionID) {
+    const exit = yield* deps.provider.getModel(providerID, modelID).pipe(Effect.exit)
+    if (Exit.isSuccess(exit)) return exit.value
+    const err = Cause.squash(exit.cause)
+    if (deps.provider.ModelNotFoundError?.isInstance?.(err) ?? (err as any).constructor?.name === "ModelNotFoundError") {
+      const hint = (err as any).data?.suggestions?.length ? ` Did you mean: ${(err as any).data.suggestions.join(", ")}?` : ""
+      yield* deps.bus.publish(deps.sessions.constructor?.Event?.Error ?? { type: "session.error" }, {
+        sessionID,
+        error: new NamedError.Unknown({ message: `Model not found: ${providerID}/${modelID}.${hint}` }).toObject(),
+      })
+    }
+    return yield* Effect.failCause(exit.cause)
+  })
+
+export const lastModel = (deps: PromptDeps) =>
+  Effect.fnUntraced(function* (sessionID: SessionID) {
+    const match = yield* deps.sessions.findMessage(sessionID, (m: any) => m.info.role === "user" && !!m.info.model) as any
+    if (Option.isSome(match) && (match.value as any).info.role === "user") return (match.value as any).info.model
+    return yield* deps.provider.defaultModel()
+  })
+
+export const lastAssistant = (deps: PromptDeps) =>
+  Effect.fnUntraced(function* (sessionID: SessionID) {
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const match = yield* deps.sessions.findMessage(sessionID, (m: any) => m.info.role !== "user")
+      if (Option.isSome(match)) return match.value
+      const msgs = yield* deps.sessions.messages({ sessionID, limit: 1 })
+      if (msgs.length > 0) return msgs[0]
+      yield* Effect.sleep("50 millis")
+    }
+    throw new Error("Impossible")
+  })

package/src/session/prompt-reminders.ts

@@ -0,0 +1,120 @@
+import { Effect } from "effect"
+import path from "path"
+import { Flag } from "@saeeol/core/flag/flag"
+import { PartID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import * as Session from "./session"
+import { InstanceState } from "@/effect/instance-state"
+import CODE_SWITCH from "./prompt/code-switch.txt"
+import type { PromptDeps } from "./prompt-types"
+import * as LTM from "@/ltm"
+
+const PLAN_REMINDER = `<system-reminder>
+Plan mode is active. The user indicated that they do not want you to execute yet -- you MUST NOT make any edits (with the exception of the plan file mentioned below), run any non-readonly tools (including changing configs or making commits), or otherwise make any changes to the system. This supersedes any other instructions you have received.
+
+## Plan File Info:
+{{PLAN_INFO}}
+You should build your plan incrementally by writing to or editing this file. NOTE that this is the only file you are allowed to edit -- you are only allowed to take READ-ONLY actions.
+
+## Plan Workflow
+
+### Phase 1: Initial Understanding
+Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical to In this phase you should only use the explore subagent type.
+
+1. Focus on understanding the user's request and the code associated with their request
+2. **Launch up to 3 explore agents IN PARALLEL** to efficiently explore the codebase.
+3. After exploring the code, use the question tool to clarify ambiguities in the user request up front.
+
+### Phase 2: Design
+Goal: Design an implementation approach. Launch general agent(s) based on exploration results.
+
+### Phase 3: Review
+Goal: Review the plan(s) and ensure alignment with the user's intentions.
+
+### Phase 4: Final Plan
+Goal: Write your final plan to the plan file. Include recommended approach, critical file paths, and verification steps.
+
+### Phase 5: Call plan_exit tool
+At the end, call plan_exit to indicate you are done planning. Do NOT stop unless asking a question or calling plan_exit.
+</system-reminder>`
+
+export const insertReminders = (deps: PromptDeps, SaeeolSessionPrompt: any) =>
+  Effect.fn("SessionPrompt.insertReminders")(function* (input: {
+    messages: MessageV2.WithParts[]
+    agent: any
+    session: Session.Info
+  }) {
+    const userMessage = input.messages.findLast((msg) => msg.info.role === "user")
+    if (!userMessage) return input.messages
+
+    if (!Flag.SAEEOL_EXPERIMENTAL_PLAN_MODE) {
+      yield* Effect.promise(() =>
+        SaeeolSessionPrompt.insertPlanReminders({ agent: input.agent, session: input.session, userMessage }),
+      )
+      const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
+      if (wasPlan && input.agent.name === "code") {
+        userMessage.parts.push({
+          id: PartID.ascending(), messageID: userMessage.info.id,
+          sessionID: userMessage.info.sessionID, type: "text", text: CODE_SWITCH, synthetic: true,
+        })
+      }
+
+      // LTM retrieval — inject relevant long-term memories into the prompt
+      const cfg = yield* deps.config.get()
+      if (cfg?.ltm?.enabled) {
+        const userText = userMessage.parts
+          .filter((p) => p.type === "text")
+          .map((p) => (p as any).text ?? "")
+          .join(" ")
+          .slice(0, 500)
+        if (userText.length > 10) {
+          const ltmCfg = {
+            ...LTM.Config.DEFAULT_LTM_CONFIG,
+            ...cfg.ltm,
+            episodic: { ...LTM.Config.DEFAULT_LTM_CONFIG.episodic, ...cfg.ltm.episodic },
+            semantic: { ...LTM.Config.DEFAULT_LTM_CONFIG.semantic, ...cfg.ltm.semantic },
+            procedural: { ...LTM.Config.DEFAULT_LTM_CONFIG.procedural, ...cfg.ltm.procedural },
+            retrieval: { ...LTM.Config.DEFAULT_LTM_CONFIG.retrieval, ...cfg.ltm.retrieval },
+          }
+          const context = yield* Effect.promise(() => LTM.Retrieval.inject(userText, ltmCfg))
+          if (context) {
+            userMessage.parts.push({
+              id: PartID.ascending(), messageID: userMessage.info.id,
+              sessionID: userMessage.info.sessionID, type: "text", text: `\n${context}`, synthetic: true,
+            })
+          }
+        }
+      }
+
+      return input.messages
+    }
+
+    const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
+    if (input.agent.name !== "plan" && assistantMessage?.info.agent === "plan") {
+      const ctx = yield* InstanceState.context
+      const plan = Session.plan(input.session, ctx)
+      if (!(yield* deps.fsys.existsSafe(plan))) return input.messages
+      const part = yield* deps.sessions.updatePart({
+        id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
+        type: "text", text: `${CODE_SWITCH}\n\nA plan file exists at ${plan}. You should execute on the plan defined within it`, synthetic: true,
+      })
+      userMessage.parts.push(part)
+      return input.messages
+    }
+
+    if (input.agent.name !== "plan" || assistantMessage?.info.agent === "plan") return input.messages
+
+    const ctx = yield* InstanceState.context
+    const plan = Session.plan(input.session, ctx)
+    const exists = yield* deps.fsys.existsSafe(plan)
+    if (!exists) yield* deps.fsys.ensureDir(path.dirname(plan)).pipe(Effect.catch(Effect.die))
+    const planInfo = exists
+      ? `A plan file already exists at ${plan}. You can read it and make incremental edits using the edit tool.`
+      : `No plan file exists yet. You should create your plan at ${plan} using the write tool.`
+    const part = yield* deps.sessions.updatePart({
+      id: PartID.ascending(), messageID: userMessage.info.id, sessionID: userMessage.info.sessionID,
+      type: "text", text: PLAN_REMINDER.replace("{{PLAN_INFO}}", planInfo), synthetic: true,
+    })
+    userMessage.parts.push(part)
+    return input.messages
+  })

package/src/session/prompt-resolve.ts

@@ -0,0 +1,42 @@
+import { Effect, Types, Option } from "effect"
+import path from "path"
+import os from "os"
+import { ConfigMarkdown } from "@/config/markdown"
+import { pathToFileURL } from "url"
+import { InstanceState } from "@/effect/instance-state"
+import type { PromptInput } from "./prompt-schemas"
+import type { PromptDeps } from "./prompt-types"
+
+export const resolvePromptParts = (deps: PromptDeps) =>
+  Effect.fn("SessionPrompt.resolvePromptParts")(function* (template: string) {
+    const ctx = yield* InstanceState.context
+    const parts: Types.DeepMutable<PromptInput["parts"]> = [{ type: "text", text: template }]
+    const files = ConfigMarkdown.files(template)
+    const seen = new Set<string>()
+    yield* Effect.forEach(
+      files,
+      Effect.fnUntraced(function* (match: RegExpExecArray) {
+        const name = match[1]
+        if (seen.has(name)) return
+        seen.add(name)
+        const filepath = name.startsWith("~/")
+          ? path.join(os.homedir(), name.slice(2))
+          : path.resolve(ctx.worktree, name)
+        const info = yield* deps.fsys.stat(filepath).pipe(Effect.option)
+        if (Option.isNone(info)) {
+          const found = yield* deps.agents.get(name)
+          if (found) parts.push({ type: "agent", name: found.name })
+          return
+        }
+        const stat = info.value
+        parts.push({
+          type: "file",
+          url: pathToFileURL(filepath).href,
+          filename: name,
+          mime: stat.type === "Directory" ? "application/x-directory" : "text/plain",
+        })
+      }),
+      { concurrency: "unbounded", discard: true },
+    )
+    return parts
+  })

package/src/session/prompt-schemas.ts

@@ -0,0 +1,128 @@
+import z from "zod"
+import { SessionID, MessageID, PartID } from "./schema"
+import { MessageV2 } from "./message-v2"
+import { ModelID, ProviderID } from "../provider/schema"
+import { type Tool as AITool, tool, jsonSchema } from "ai"
+import type { JSONSchema7 } from "@ai-sdk/provider"
+import { Schema } from "effect"
+import { zod } from "@/util/effect-zod"
+import { withStatics } from "@/util/schema"
+
+export const STRUCTURED_OUTPUT_DESCRIPTION = `Use this tool to return your final response in the requested structured format.
+
+IMPORTANT:
+- You MUST call this tool exactly once at the end of your response
+- The input must be valid JSON matching the required schema
+- Complete all necessary research and tool calls BEFORE calling this tool
+- This tool provides your final answer - no further actions are taken after calling it`
+
+export const STRUCTURED_OUTPUT_SYSTEM_PROMPT = `IMPORTANT: The user has requested structured output. You MUST use the StructuredOutput tool to provide your final response. Do NOT respond with plain text - you MUST call the StructuredOutput tool with your answer formatted according to the schema.`
+
+export const REQUEST_PRUNE_BYTES = 1_250_000
+
+const ModelRef = Schema.Struct({
+  providerID: ProviderID,
+  modelID: ModelID,
+})
+
+export const PromptInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: Schema.optional(MessageID),
+  model: Schema.optional(ModelRef),
+  agent: Schema.optional(Schema.String),
+  noReply: Schema.optional(Schema.Boolean),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description:
+      "@deprecated tools and permissions have been merged, you can set permissions on the session itself now",
+  }),
+  format: Schema.optional(MessageV2.Format),
+  system: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  editorContext: Schema.optional(MessageV2.EditorContext),
+  parts: Schema.Array(
+    Schema.Union([
+      MessageV2.TextPartInput,
+      MessageV2.FilePartInput,
+      MessageV2.AgentPartInput,
+      MessageV2.SubtaskPartInput,
+    ]).annotate({ discriminator: "type" }),
+  ),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+
+type PartInputUnion =
+  | MessageV2.TextPartInput
+  | MessageV2.FilePartInput
+  | MessageV2.AgentPartInput
+  | MessageV2.SubtaskPartInput
+export type PromptInput = Omit<Schema.Schema.Type<typeof PromptInput>, "parts" | "editorContext"> & {
+  parts: PartInputUnion[]
+  editorContext?: MessageV2.EditorContext
+}
+
+export class LoopInput extends Schema.Class<LoopInput>("SessionPrompt.LoopInput")({
+  sessionID: SessionID,
+}) {
+  static readonly zod = zod(this)
+}
+
+export const ShellInput = Schema.Struct({
+  sessionID: SessionID,
+  messageID: Schema.optional(MessageID),
+  agent: Schema.String,
+  model: Schema.optional(ModelRef),
+  command: Schema.String,
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type ShellInput = Schema.Schema.Type<typeof ShellInput>
+
+export const CommandInput = Schema.Struct({
+  messageID: Schema.optional(MessageID),
+  sessionID: SessionID,
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  arguments: Schema.String,
+  command: Schema.String,
+  variant: Schema.optional(Schema.String),
+  parts: Schema.optional(
+    Schema.Array(
+      Schema.Union([
+        Schema.Struct({
+          id: Schema.optional(PartID),
+          type: Schema.Literal("file"),
+          mime: Schema.String,
+          filename: Schema.optional(Schema.String),
+          url: Schema.String,
+          source: Schema.optional(MessageV2.FilePartSource),
+        }),
+      ]).annotate({ discriminator: "type" }),
+    ),
+  ),
+}).pipe(withStatics((s) => ({ zod: zod(s) })))
+export type CommandInput = Schema.Schema.Type<typeof CommandInput>
+
+export const bashRegex = /!`([^`]+)`/g
+export const argsRegex = /(?:\[Image\s+\d+\]|"[^"]*"|'[^']*'|[^\s"']+)/gi
+export const placeholderRegex = /\$(\d+)/g
+export const quoteTrimRegex = /^["']|["']$/g
+
+/** @internal Exported for testing */
+export function createStructuredOutputTool(input: {
+  schema: Record<string, any>
+  onSuccess: (output: unknown) => void
+}): AITool {
+  const { $schema: _, ...toolSchema } = input.schema
+  return tool({
+    description: STRUCTURED_OUTPUT_DESCRIPTION,
+    inputSchema: jsonSchema(toolSchema as JSONSchema7),
+    async execute(args) {
+      input.onSuccess(args)
+      return {
+        output: "Structured output captured successfully.",
+        title: "Structured Output",
+        metadata: { valid: true },
+      }
+    },
+    toModelOutput({ output }) {
+      return { type: "text", value: output.output }
+    },
+  })
+}