@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/session/goal.ts

@@ -1,232 +0,0 @@
-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

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

package/src/session/instruction.ts

@@ -1,276 +0,0 @@
-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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,82 +0,0 @@
-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 }
-})