@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/session/goal.ts

@@ -0,0 +1,232 @@
+import { Effect, Layer, Context, Option } from "effect"
+import { generateObject, streamObject, type ModelMessage } from "ai"
+import z from "zod"
+import * as OtelTracer from "@effect/opentelemetry/Tracer"
+import { InstanceState } from "@/effect"
+import { EffectLogger } from "@/effect"
+import { Provider, ProviderTransform } from "@/provider"
+import type { ProviderID, ModelID } from "@/provider/schema"
+import { Auth } from "@/auth"
+import { Config } from "@/config"
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { SessionID } from "./schema"
+import { MessageV2 } from "./message-v2"
+
+/**
+ * Per-session stop-condition goal. `/goal`: once a goal
+ * is set, the main runLoop refuses to stop until an independent judge model
+ * decides the condition is satisfied (or genuinely impossible). The judge is a
+ * separate model call that only reads the transcript — it does not do the work,
+ * so its verdict stays cold relative to the working agent's optimism.
+ *
+ * State lives in InstanceState (per project instance), keyed by sessionID, and
+ * is cleared on instance teardown. See run-state.ts for the sibling pattern.
+ */
+
+export type Goal = {
+  condition: string
+  /** Number of judge-driven re-entries so far; bounded by MAX_GOAL_REACT in prompt.ts. */
+  react: number
+}
+
+export const Verdict = z.object({
+  ok: z.boolean(),
+  impossible: z.boolean().optional(),
+  reason: z.string(),
+})
+export type Verdict = z.infer<typeof Verdict>
+
+/**
+ * Broadcast whenever a session's goal changes — set, judged, or cleared. The
+ * TUI mirrors this into its sync store to render the active-goal indicator and
+ * the latest judge verdict. `goal` undefined means there is no active goal
+ * (cleared / satisfied / impossible). Mirrors session/status.ts's Event.Status.
+ */
+export const Event = {
+  Updated: BusEvent.define(
+    "session.goal",
+    z.object({
+      sessionID: SessionID.zod,
+      goal: z.object({ condition: z.string() }).optional(),
+      lastVerdict: Verdict.extend({
+        attempt: z.number(),
+        /** The assistant message the judge evaluated — anchors the verdict to a turn. */
+        messageID: z.string().optional(),
+        error: z.boolean().optional(),
+      }).optional(),
+    }),
+  ),
+}
+
+// ---- Judge prompts  ----
+
+const JUDGE_SYSTEM = `You are evaluating a stop-condition hook in Sleepy Code. Read the conversation transcript carefully, then judge whether the user-provided condition is satisfied.
+
+Your response must be a JSON object with one of these shapes:
+- {"ok": true, "reason": "<quote evidence from the transcript that satisfies the condition>"}
+- {"ok": false, "reason": "<quote what is missing or what blocks the condition>"}
+- {"ok": false, "impossible": true, "reason": "<explain why the condition can never be satisfied>"}
+
+Always include a "reason" field, quoting specific text from the transcript whenever possible. If the transcript does not contain clear evidence that the condition is satisfied, return {"ok": false, "reason": "insufficient evidence in transcript"}.
+
+Only use {"ok": false, "impossible": true} when the condition is genuinely unachievable in this session — for example: the condition is self-contradictory, it depends on a resource or capability that is unavailable, or the assistant has explicitly tried, exhausted reasonable approaches, and stated it cannot be done. Apply your own judgment when deciding this — the assistant claiming the goal is impossible is evidence, not proof; independently confirm the condition is genuinely unachievable rather than deferring to the assistant's self-assessment. Do not use it just because the goal has not been reached yet or because progress is slow. When in doubt, return {"ok": false} without "impossible".`
+
+// The closing question appended after the full conversation.
+const judgeUser = (condition: string) =>
+  `Based on the conversation transcript above, has the following stopping condition been satisfied? Answer based on transcript evidence only.
+
+Condition: ${condition}`
+
+export interface Interface {
+  readonly set: (sessionID: SessionID, condition: string) => Effect.Effect<void>
+  readonly get: (sessionID: SessionID) => Effect.Effect<Goal | undefined>
+  readonly clear: (sessionID: SessionID) => Effect.Effect<void>
+  /** Increment the re-entry counter, returning the new count. */
+  readonly bumpReact: (sessionID: SessionID) => Effect.Effect<number>
+  /**
+   * Run the judge over the conversation against the active goal's condition.
+   * `msgs` is the main thread's message list; it is converted to native model
+   * messages (tool calls/results/images preserved) so the judge independently
+   * confirms the work rather than trusting the assistant's self-report.
+   */
+  readonly evaluate: (input: {
+    condition: string
+    msgs: MessageV2.WithParts[]
+    model: { providerID: ProviderID; modelID: ModelID }
+  }) => Effect.Effect<Verdict>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/SessionGoal") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const provider = yield* Provider.Service
+    const auth = yield* Auth.Service
+    const config = yield* Config.Service
+    const bus = yield* Bus.Service
+    const elog = EffectLogger.create({ service: "SessionGoal" })
+
+    const state = yield* InstanceState.make(
+      Effect.fn("SessionGoal.state")(function* () {
+        return { goals: new Map<string, Goal>() }
+      }),
+    )
+
+    const set = Effect.fn("SessionGoal.set")(function* (sessionID: SessionID, condition: string) {
+      const data = yield* InstanceState.get(state)
+      data.goals.set(sessionID, { condition, react: 0 })
+      yield* elog.info("goal set", { sessionID, condition })
+      yield* bus.publish(Event.Updated, { sessionID, goal: { condition } })
+    })
+
+    const get = Effect.fn("SessionGoal.get")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      return data.goals.get(sessionID)
+    })
+
+    const clear = Effect.fn("SessionGoal.clear")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      data.goals.delete(sessionID)
+      yield* elog.info("goal cleared", { sessionID })
+      yield* bus.publish(Event.Updated, { sessionID, goal: undefined })
+    })
+
+    const bumpReact = Effect.fn("SessionGoal.bumpReact")(function* (sessionID: SessionID) {
+      const data = yield* InstanceState.get(state)
+      const goal = data.goals.get(sessionID)
+      if (!goal) return 0
+      goal.react += 1
+      return goal.react
+    })
+
+    const evaluate = Effect.fn("SessionGoal.evaluate")(function* (input: {
+      condition: string
+      msgs: MessageV2.WithParts[]
+      model: { providerID: ProviderID; modelID: ModelID }
+    }) {
+      const cfg = yield* config.get()
+      const resolved = yield* provider.getModel(input.model.providerID, input.model.modelID)
+      const language = yield* provider.getLanguage(resolved)
+      const tracer = cfg.experimental?.openTelemetry
+        ? Option.getOrUndefined(yield* Effect.serviceOption(OtelTracer.OtelTracer))
+        : undefined
+
+      const authInfo = yield* auth.get(input.model.providerID).pipe(Effect.orDie)
+      const isOpenaiOauth = input.model.providerID === "openai" && authInfo?.type === "oauth"
+
+      // Convert the conversation to native model messages so the judge sees the
+      // real tool calls/results/images — same context the working agent had.
+      const conversation = yield* MessageV2.toModelMessagesEffect(input.msgs, resolved)
+
+      // Diagnostic: dump the FULL message array sent to the judge. Long strings
+      // (e.g. base64 image data) are clipped with a length marker so the log
+      // stays readable. Debug-level — it dumps the whole transcript on every
+      // judge call, so it stays out of production info logs.
+      const clip = (_key: string, value: unknown) =>
+        typeof value === "string" && value.length > 500
+          ? `«${value.length} chars: ${value.slice(0, 200)}…»`
+          : value
+      const fullMessages = [
+        ...(isOpenaiOauth ? [] : [{ role: "system", content: JUDGE_SYSTEM }]),
+        ...conversation,
+        { role: "user", content: judgeUser(input.condition) },
+      ]
+      yield* elog.debug("goal judge transcript", {
+        condition: input.condition,
+        messageCount: fullMessages.length,
+        messages: JSON.stringify(fullMessages, clip),
+      })
+
+      const params = {
+        experimental_telemetry: {
+          isEnabled: cfg.experimental?.openTelemetry,
+          tracer,
+          metadata: { userId: cfg.username ?? "unknown" },
+        },
+        temperature: 0,
+        messages: [
+          ...(isOpenaiOauth ? [] : [{ role: "system", content: JUDGE_SYSTEM } satisfies ModelMessage]),
+          ...conversation,
+          {
+            role: "user",
+            content: judgeUser(input.condition),
+          } satisfies ModelMessage,
+        ],
+        model: language,
+        schema: Verdict,
+      } satisfies Parameters<typeof generateObject>[0]
+
+      if (isOpenaiOauth) {
+        return yield* Effect.promise(async () => {
+          const result = streamObject({
+            ...params,
+            providerOptions: ProviderTransform.providerOptions(resolved, {
+              instructions: JUDGE_SYSTEM,
+              store: false,
+            }),
+            onError: () => {},
+          })
+          for await (const part of result.fullStream) {
+            if (part.type === "error") throw part.error
+          }
+          return Verdict.parse(await result.object)
+        })
+      }
+
+      return yield* Effect.promise(() => generateObject(params).then((r) => Verdict.parse(r.object)))
+    })
+
+    return Service.of({ set, get, clear, bumpReact, evaluate })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(Provider.defaultLayer),
+  Layer.provide(Auth.defaultLayer),
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(Bus.layer),
+)
+
+export * as Goal from "./goal"

package/src/session/index.ts

@@ -0,0 +1 @@
+export * as Session from "./session"

package/src/session/instruction.ts

@@ -0,0 +1,276 @@
+import os from "os"
+import path from "path"
+import { Effect, Layer, Context } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Config } from "@/config"
+import { InstanceState } from "@/effect"
+import { Flag } from "@/flag/flag"
+import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
+import { withTransientReadRetry } from "@/util/effect-http-client"
+import { Global } from "../global"
+import { Log } from "../util"
+import type { MessageV2 } from "./message-v2"
+import type { MessageID } from "./schema"
+
+const log = Log.create({ service: "instruction" })
+
+const FILES = [
+  "AGENTS.md",
+  ...(Flag.SLEEPYCODE_DISABLE_CLAUDE_CODE_PROMPT ? [] : ["CLAUDE.md"]),
+  "CONTEXT.md", // deprecated
+]
+
+// When the project AGENTS.md has fewer than this many (trimmed) characters, treat it as
+// sparse and also load CLAUDE.md so its guidance isn't dropped by the first-match-wins rule.
+const CLAUDE_FALLBACK_MAX_CHARS = 500
+
+function globalFiles() {
+  const files = []
+  if (Flag.SLEEPYCODE_CONFIG_DIR) {
+    files.push(path.join(Flag.SLEEPYCODE_CONFIG_DIR, "AGENTS.md"))
+  }
+  files.push(path.join(Global.Path.config, "AGENTS.md"))
+  if (!Flag.SLEEPYCODE_DISABLE_CLAUDE_CODE_PROMPT) {
+    files.push(path.join(os.homedir(), ".claude", "CLAUDE.md"))
+  }
+  return files
+}
+
+function extract(messages: MessageV2.WithParts[]) {
+  const paths = new Set<string>()
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.tool === "read" && part.state.status === "completed") {
+        if (part.state.time.compacted) continue
+        const loaded = part.state.metadata?.loaded
+        if (!loaded || !Array.isArray(loaded)) continue
+        for (const p of loaded) {
+          if (typeof p === "string") paths.add(p)
+        }
+      }
+    }
+  }
+  return paths
+}
+
+export interface Interface {
+  readonly clear: (messageID: MessageID) => Effect.Effect<void>
+  readonly systemPaths: () => Effect.Effect<Set<string>, AppFileSystem.Error>
+  readonly system: () => Effect.Effect<{ paths: Set<string>; content: string[] }, AppFileSystem.Error>
+  readonly find: (dir: string) => Effect.Effect<string | undefined, AppFileSystem.Error>
+  readonly resolve: (
+    messages: MessageV2.WithParts[],
+    filepath: string,
+    messageID: MessageID,
+  ) => Effect.Effect<{ filepath: string; content: string }[], AppFileSystem.Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Instruction") {}
+
+export const layer: Layer.Layer<Service, never, AppFileSystem.Service | Config.Service | HttpClient.HttpClient> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const cfg = yield* Config.Service
+      const fs = yield* AppFileSystem.Service
+      const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
+
+      const state = yield* InstanceState.make(
+        Effect.fn("Instruction.state")(() =>
+          Effect.succeed({
+            // Track which instruction files have already been attached for a given assistant message.
+            claims: new Map<MessageID, Set<string>>(),
+          }),
+        ),
+      )
+
+      const relative = Effect.fnUntraced(function* (instruction: string) {
+        const ctx = yield* InstanceState.context
+        if (!Flag.SLEEPYCODE_DISABLE_PROJECT_CONFIG) {
+          return yield* fs
+            .globUp(instruction, ctx.directory, ctx.worktree)
+            .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+        }
+        if (!Flag.SLEEPYCODE_CONFIG_DIR) {
+          log.warn(
+            `Skipping relative instruction "${instruction}" - no SLEEPYCODE_CONFIG_DIR set while project config is disabled`,
+          )
+          return []
+        }
+        return yield* fs
+          .globUp(instruction, Flag.SLEEPYCODE_CONFIG_DIR, Flag.SLEEPYCODE_CONFIG_DIR)
+          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      })
+
+      const read = Effect.fnUntraced(function* (filepath: string) {
+        return yield* fs.readFileString(filepath).pipe(Effect.catch(() => Effect.succeed("")))
+      })
+
+      const fetch = Effect.fnUntraced(function* (url: string) {
+        const res = yield* http.execute(HttpClientRequest.get(url)).pipe(
+          Effect.timeout(5000),
+          Effect.catch(() => Effect.succeed(null)),
+        )
+        if (!res) return ""
+        const body = yield* res.arrayBuffer.pipe(Effect.catch(() => Effect.succeed(new ArrayBuffer(0))))
+        return new TextDecoder().decode(body)
+      })
+
+      const clear = Effect.fn("Instruction.clear")(function* (messageID: MessageID) {
+        const s = yield* InstanceState.get(state)
+        s.claims.delete(messageID)
+      })
+
+      const systemPaths = Effect.fn("Instruction.systemPaths")(function* () {
+        const config = yield* cfg.get()
+        const ctx = yield* InstanceState.context
+        const paths = new Set<string>()
+
+        // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
+        if (!Flag.SLEEPYCODE_DISABLE_PROJECT_CONFIG) {
+          const agents = yield* fs.findUp("AGENTS.md", ctx.directory, ctx.worktree)
+          if (agents.length > 0) {
+            agents.forEach((item) => paths.add(path.resolve(item)))
+            // A sparse AGENTS.md likely doesn't carry the full project guidance, so pull in CLAUDE.md too.
+            if (!Flag.SLEEPYCODE_DISABLE_CLAUDE_CODE_PROMPT) {
+              const content = (yield* Effect.forEach(agents, read, { concurrency: 8 })).join("").trim()
+              if (content.length < CLAUDE_FALLBACK_MAX_CHARS) {
+                const claude = yield* fs.findUp("CLAUDE.md", ctx.directory, ctx.worktree)
+                claude.forEach((item) => paths.add(path.resolve(item)))
+              }
+            }
+          } else {
+            for (const file of FILES) {
+              if (file === "AGENTS.md") continue
+              const matches = yield* fs.findUp(file, ctx.directory, ctx.worktree)
+              if (matches.length > 0) {
+                matches.forEach((item) => paths.add(path.resolve(item)))
+                break
+              }
+            }
+          }
+        }
+
+        for (const file of globalFiles()) {
+          if (yield* fs.existsSafe(file)) {
+            paths.add(path.resolve(file))
+            break
+          }
+        }
+
+        if (config.instructions) {
+          for (const raw of config.instructions) {
+            if (raw.startsWith("https://") || raw.startsWith("http://")) continue
+            const instruction = raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw
+            const matches = yield* (
+              path.isAbsolute(instruction)
+                ? fs.glob(path.basename(instruction), {
+                    cwd: path.dirname(instruction),
+                    absolute: true,
+                    include: "file",
+                  })
+                : relative(instruction)
+            ).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+            matches.forEach((item) => paths.add(path.resolve(item)))
+          }
+        }
+
+        return paths
+      })
+
+      const system = Effect.fn("Instruction.system")(function* () {
+        const config = yield* cfg.get()
+        const paths = yield* systemPaths()
+        const urls = (config.instructions ?? []).filter(
+          (item) => item.startsWith("https://") || item.startsWith("http://"),
+        )
+
+        const files = yield* Effect.forEach(Array.from(paths), read, { concurrency: 8 })
+        const remote = yield* Effect.forEach(urls, fetch, { concurrency: 4 })
+
+        return {
+          paths,
+          content: [
+            ...Array.from(paths).flatMap((item, i) => (files[i] ? [`Instructions from: ${item}\n${files[i]}`] : [])),
+            ...urls.flatMap((item, i) => (remote[i] ? [`Instructions from: ${item}\n${remote[i]}`] : [])),
+          ],
+        }
+      })
+
+      const find = Effect.fn("Instruction.find")(function* (dir: string) {
+        for (const file of FILES) {
+          const filepath = path.resolve(path.join(dir, file))
+          if (yield* fs.existsSafe(filepath)) return filepath
+        }
+      })
+
+      const resolve = Effect.fn("Instruction.resolve")(function* (
+        messages: MessageV2.WithParts[],
+        filepath: string,
+        messageID: MessageID,
+      ) {
+        const sys = yield* systemPaths()
+        const already = extract(messages)
+        const results: { filepath: string; content: string }[] = []
+        const s = yield* InstanceState.get(state)
+        const root = path.resolve(yield* InstanceState.directory)
+
+        const target = path.resolve(filepath)
+        let current = path.dirname(target)
+
+        // Walk upward from the file being read and attach nearby instruction files once per message.
+        while (current.startsWith(root) && current !== root) {
+          const found = yield* find(current)
+          if (!found || found === target || sys.has(found) || already.has(found)) {
+            current = path.dirname(current)
+            continue
+          }
+
+          let set = s.claims.get(messageID)
+          if (!set) {
+            set = new Set()
+            s.claims.set(messageID, set)
+          }
+          if (set.has(found)) {
+            current = path.dirname(current)
+            continue
+          }
+
+          set.add(found)
+          const content = yield* read(found)
+          if (content) {
+            results.push({ filepath: found, content: `Instructions from: ${found}\n${content}` })
+          }
+
+          current = path.dirname(current)
+        }
+
+        return results
+      })
+
+      return Service.of({ clear, systemPaths, system, find, resolve })
+    }),
+  )
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(AppFileSystem.defaultLayer),
+  Layer.provide(FetchHttpClient.layer),
+)
+
+export function loaded(messages: MessageV2.WithParts[]) {
+  return extract(messages)
+}
+
+// Friendly label for an instruction file: worktree-relative when inside the project (so two
+// same-named ancestor AGENTS.md files stay distinguishable), `~`-prefixed under the home dir,
+// otherwise the absolute path.
+export function display(filepath: string, worktree: string) {
+  const rel = path.relative(worktree, filepath)
+  if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) return rel
+  const home = os.homedir()
+  if (filepath === home || filepath.startsWith(home + path.sep)) return path.join("~", path.relative(home, filepath))
+  return filepath
+}
+
+export * as Instruction from "./instruction"

package/src/session/last-message-info.ts

@@ -0,0 +1,32 @@
+/**
+ * Classifies the last message in a tail segment for checkpoint rebuild context.
+ * Used by renderRebuildContext to decide which system reminder addendum to emit.
+ */
+
+export type LastMessageInfo =
+  | { role: "assistant"; finish: "tool-calls" }
+  | { role: "assistant"; finish: "stop" }
+  | { role: "tool" }
+  | { role: "user" }
+
+/**
+ * Inspects the last element of a message array and returns a classification.
+ * Accepts any array of objects with at minimum `{ role: string; finish?: string }`.
+ *
+ * - assistant with finish="tool-calls" → mid-loop autonomous
+ * - assistant with any other finish     → completed naturally
+ * - tool                                → tool result pending
+ * - user                                → awaiting assistant response
+ *
+ * Returns undefined for an empty array.
+ */
+export function computeLastMessageInfo(
+  msgs: ReadonlyArray<{ role: string; finish?: string }>,
+): LastMessageInfo | undefined {
+  if (msgs.length === 0) return undefined
+  const last = msgs[msgs.length - 1]
+  if (last.role === "assistant")
+    return { role: "assistant", finish: last.finish === "tool-calls" ? "tool-calls" : "stop" }
+  if (last.role === "tool") return { role: "tool" }
+  return { role: "user" }
+}

package/src/session/llm-request-prefix.ts

@@ -0,0 +1,82 @@
+import { Effect } from "effect"
+import { tool, jsonSchema, type Tool as AITool } from "ai"
+import z from "zod"
+import { MessageV2 } from "./message-v2"
+import type { SessionID } from "./schema"
+import { ModelID } from "../provider/schema"
+import type { Agent } from "../agent/agent"
+import type { Provider } from "../provider"
+import { LLM } from "./llm"
+import { ToolRegistry } from "../tool"
+import { ProviderTransform } from "../provider"
+
+/**
+ * Build the LLM request prefix (system + tools + inheritedMessages) from the
+ * given msgs array. Given identical inputs this returns deep-equal output
+ * (modulo plugin trigger determinism, which is the only external non-determinism
+ * source).
+ *
+ * Used by:
+ *   - parent runLoop, to construct its own request
+ *   - tryStartCheckpointWriter, to capture a frozen ForkContext at spawn time
+ *
+ * Both call sites must use this same function — the byte-equal invariant
+ * across parent and fork is a structural consequence, not a separate assertion.
+ *
+ * Slicing (e.g. for fork capture at a watermark) is a caller concern; callers
+ * pass the already-sliced msgs. ForkContext.watermarkMsgID is a boundary marker
+ * on the fork context, not a parameter here.
+ */
+export const buildLLMRequestPrefix = Effect.fn("Session.buildLLMRequestPrefix")(function* (input: {
+  sessionID: SessionID
+  agent: Agent.Info
+  model: Provider.Model
+  msgs: MessageV2.WithParts[]
+  /**
+   * Caller-built system parts to splice into the system array (after agent.prompt
+   * and before memory instructions). Currently env, skills, instructions in that
+   * order. Caller is responsible for the ordering and content.
+   */
+  additions: string[]
+}) {
+  const llm = yield* LLM.Service
+  const toolRegistry = yield* ToolRegistry.Service
+
+  // Always use full msgs — slicing is a fork-capture concern that lives at the
+  // caller (ForkContext.watermarkMsgID is a boundary marker, not a slice arg).
+  // See spec changelog at docs/superpowers/specs/2026-05-26-fork-agent-prefix-cache-design.md
+  const inheritedMessages = yield* MessageV2.toModelMessagesEffect(input.msgs, input.model)
+
+  // Find the last user message; required for system "user.system" pass-through
+  const lastUserMsg = input.msgs.findLast((m) => m.info.role === "user")
+  if (!lastUserMsg)
+    return yield* Effect.die(new Error("buildLLMRequestPrefix: no user message in msgs"))
+  const lastUser = lastUserMsg.info as MessageV2.User
+
+  // Build system using LLM.buildSystemArray (single source of truth shared with stream())
+  const system = yield* llm.buildSystemArray({
+    agent: input.agent,
+    model: input.model,
+    system: input.additions,
+    user: lastUser,
+    sessionID: input.sessionID as string,
+    agentID: lastUser.agentID,
+  })
+
+  // Resolve tools using parent agent's permission and toolAllowlist
+  const toolDefs = yield* toolRegistry.tools({
+    modelID: ModelID.make(input.model.api.id),
+    providerID: input.model.providerID,
+    agent: input.agent,
+  })
+  const tools: Record<string, AITool> = {}
+  for (const item of toolDefs) {
+    const schema = ProviderTransform.schema(input.model, z.toJSONSchema(item.parameters))
+    tools[item.id] = tool({
+      description: item.description,
+      inputSchema: jsonSchema(schema),
+    })
+  }
+
+  return { system, tools, inheritedMessages }
+})