saeeol 1.4.1 → 1.4.3

package/src/session/prompt/prompt-title.ts

@@ -1,55 +0,0 @@
-import { Effect, Cause, Stream } from "effect"
-import * as Log from "@saeeol/core/util/log"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import * as Session from "../core/session"
-import { MessageV2 } from "../message/message-v2"
-import type { PromptDeps } from "./prompt-types"
-
-const elog = EffectLogger.create({ service: "session.prompt" })
-
-export const ensureTitle = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.ensureTitle")(function* (input: {
-    session: Session.Info
-    history: MessageV2.WithParts[]
-    providerID: any
-    modelID: any
-  }) {
-    if (input.session.parentID) return
-    if (!Session.isDefaultTitle(input.session.title)) return
-    const real = (m: MessageV2.WithParts) =>
-      m.info.role === "user" && !m.parts.every((p) => "synthetic" in p && p.synthetic)
-    const idx = input.history.findIndex(real)
-    if (idx === -1) return
-    if (input.history.filter(real).length !== 1) return
-    const context = input.history.slice(0, idx + 1)
-    const firstUser = context[idx]
-    if (!firstUser || firstUser.info.role !== "user") return
-    const firstInfo = firstUser.info
-    const subtasks = firstUser.parts.filter((p): p is MessageV2.SubtaskPart => p.type === "subtask")
-    const onlySubtasks = subtasks.length > 0 && firstUser.parts.every((p) => p.type === "subtask")
-    const ag = yield* deps.agents.get("title")
-    if (!ag) return
-    const mdl = ag.model
-      ? yield* deps.provider.getModel(ag.model.providerID, ag.model.modelID)
-      : ((yield* deps.provider.getSmallModel(input.providerID)) ??
-        (yield* deps.provider.getModel(input.providerID, input.modelID)))
-    const msgs = onlySubtasks
-      ? [{ role: "user" as const, content: subtasks.map((p) => p.prompt).join("\n") }]
-      : yield* MessageV2.toModelMessagesEffect(context, mdl)
-    const text = yield* deps.llm.stream({
-      agent: ag, user: firstInfo, system: [], small: true, tools: {}, model: mdl,
-      sessionID: input.session.id, retries: 2,
-      messages: [{ role: "user", content: "Generate a title for this conversation:\n" }, ...msgs],
-    }).pipe(
-      Stream.filter((e: any): e is Extract<any, { type: "text-delta" }> => e.type === "text-delta"),
-      Stream.map((e: any) => e.text),
-      Stream.mkString,
-      Effect.orDie,
-    )
-    const cleaned = text.replace(/<think[\s\S]*?<\/think>\s*/g, "")
-      .split("\n").map((l: string) => l.trim()).find((l: string) => l.length > 0)
-    if (!cleaned) return
-    const t = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned
-    yield* deps.sessions.setTitle({ sessionID: input.session.id, title: t })
-      .pipe(Effect.catchCause((cause) => elog.error("failed to generate title", { error: Cause.squash(cause) })))
-  })

package/src/session/prompt/prompt-types.ts

@@ -1,47 +0,0 @@
-import { Effect, Context, Types, Option, Scope, Exit, Cause, Latch, Layer } from "effect"
-import { SessionID, MessageID, PartID } from "../core/schema"
-import { MessageV2 } from "../message/message-v2"
-import type { PromptInput, ShellInput, CommandInput, LoopInput } from "./prompt-schemas"
-import type { ModelID, ProviderID } from "../../provider/schema"
-
-export interface Interface {
-  readonly cancel: (sessionID: SessionID) => Effect.Effect<void>
-  readonly prompt: (input: PromptInput) => Effect.Effect<MessageV2.WithParts>
-  readonly loop: (input: LoopInput) => Effect.Effect<MessageV2.WithParts>
-  readonly shell: (input: ShellInput) => Effect.Effect<MessageV2.WithParts>
-  readonly command: (input: CommandInput) => Effect.Effect<MessageV2.WithParts>
-  readonly resolvePromptParts: (template: string) => Effect.Effect<PromptInput["parts"]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionPrompt") {}
-
-export interface PromptDeps {
-  bus: any
-  status: any
-  sessions: any
-  agents: any
-  provider: any
-  processor: any
-  compaction: any
-  plugin: any
-  commands: any
-  config: any
-  permission: any
-  fsys: any
-  mcp: any
-  lsp: any
-  registry: any
-  truncate: any
-  spawner: any
-  scope: Scope.Scope
-  instruction: any
-  state: any
-  revert: any
-  summary: any
-  sys: any
-  llm: any
-  resolveToolsSvc: any
-  userPartSvc: any
-  subtaskSvc: any
-  shellSvc: any
-}

package/src/session/prompt/prompt-user-msg.ts

@@ -1,80 +0,0 @@
-import { Effect, Types } from "effect"
-import { MessageID, PartID } from "../core/schema"
-import { MessageV2 } from "../message/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 { PromptDeps } from "./prompt-types"
-import { getModel, lastModel } from "./prompt-model"
-
-const log = Log.create({ service: "session.prompt" })
-
-export const createUserMessage = (deps: PromptDeps) =>
-  Effect.fn("SessionPrompt.createUserMessage")(function* (input: PromptInput) {
-    const agentName = input.agent || (yield* deps.agents.defaultAgent())
-    const ag = yield* deps.agents.get(agentName)
-    if (!ag) {
-      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: "${agentName}".${hint}` })
-      yield* deps.bus.publish(deps.sessions.Event?.Error ?? { type: "session.error" }, { sessionID: input.sessionID, error: error.toObject() })
-      throw error
-    }
-    const model = input.model ?? ag.model ?? (yield* lastModel(deps)(input.sessionID))
-    const same = ag.model && model.providerID === ag.model.providerID && model.modelID === ag.model.modelID
-    const full = !input.variant && ag.variant && same
-      ? yield* deps.provider.getModel(model.providerID, model.modelID).pipe(Effect.catchDefect(() => Effect.void))
-      : undefined
-    const variant = input.variant ?? (ag.variant && full?.variants?.[ag.variant] ? ag.variant : undefined)
-    const info: MessageV2.User = {
-      id: input.messageID ?? MessageID.ascending(),
-      role: "user",
-      sessionID: input.sessionID,
-      time: { created: Date.now() },
-      tools: input.tools,
-      agent: ag.name,
-      model: { providerID: model.providerID, modelID: model.modelID, variant },
-      system: input.system,
-      format: input.format,
-      editorContext: input.editorContext,
-    }
-    yield* Effect.addFinalizer(() => deps.instruction.clear(info.id))
-    type Draft<T> = T extends MessageV2.Part ? Omit<T, "id"> & { id?: string } : never
-    const assign = (part: Draft<MessageV2.Part>): MessageV2.Part => ({
-      ...part,
-      id: part.id ? PartID.make(part.id) : PartID.ascending(),
-    })
-    const resolvePart = (part: PromptInput["parts"][number]) =>
-      deps.userPartSvc.resolve(part, {
-        sessionID: input.sessionID,
-        messageID: info.id,
-        agent: input.agent!,
-        agentPermission: ag.permission,
-        model: info.model,
-      })
-    const parts = yield* Effect.forEach(input.parts, resolvePart, { concurrency: "unbounded" }).pipe(
-      Effect.map((x: any) => x.flat().map(assign)),
-    )
-    yield* deps.plugin.trigger("chat.message", {
-      sessionID: input.sessionID, agent: input.agent, model: input.model,
-      messageID: input.messageID, variant: input.variant,
-    }, { message: info, parts })
-    const parsed = (MessageV2 as any).Info?.zod?.safeParse?.(info) ?? { success: true }
-    if (!parsed.success) {
-      log.error("invalid user message before save", {
-        sessionID: input.sessionID, messageID: info.id, agent: info.agent,
-        model: info.model, issues: parsed.error?.issues,
-      })
-    }
-    parts.forEach((part: any, index: number) => {
-      const p = (MessageV2 as any).Part?.zod?.safeParse?.(part) ?? { success: true }
-      if (p.success) return
-      log.error("invalid user part before save", {
-        sessionID: input.sessionID, messageID: info.id, partID: part.id,
-        partType: part.type, index, issues: p.error?.issues, part,
-      })
-    })
-    yield* deps.sessions.updateMessage(info)
-    for (const part of parts) yield* deps.sessions.updatePart(part)
-    return { info, parts }
-  }, Effect.scoped)

package/src/session/prompt/prompt.ts

@@ -1,210 +0,0 @@
-globalThis.AI_SDK_LOG_WARNINGS = false
-
-import { Effect, Layer, Scope, Latch, Context } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { SaeeolSessionPrompt } from "@/saeeol/session/prompt"
-import { SaeeolSessionPromptQueue } from "@/saeeol/session/prompt-queue"
-import { SaeeolSession } from "@/saeeol/session"
-import { SaeeolSessionProcessor } from "@/saeeol/session/processor"
-import { Suggestion } from "@/saeeol/suggestion"
-import { Question } from "@/question"
-import { SessionID, MessageID } from "../core/schema"
-import { MessageV2 } from "../message/message-v2"
-import { makeRuntime } from "@/effect/run-service"
-import { InstanceState } from "@/effect/instance-state"
-import { EffectBridge } from "@/effect/bridge"
-import { SessionRunState } from "../core/run-state"
-import { SessionStatus } from "../core/status"
-import { SessionCompaction } from "../core/compaction/compaction"
-import { SessionProcessor } from "../core/processor"
-import { Command } from "../../command"
-import { Permission } from "@/permission"
-import { MCP } from "../../mcp"
-import { LSP } from "@/lsp/lsp"
-import { ToolRegistry } from "@/tool/registry"
-import { Truncate } from "@/tool/truncate"
-import { Provider } from "@/provider/provider"
-import { Config } from "@/config/config"
-import { Instruction } from "../core/instruction"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Plugin } from "../../plugin"
-import { Session as SessionMod } from "../core/session"
-import { SessionRevert } from "../core/revert"
-import { SessionSummary } from "../core/summary"
-import { Agent } from "../../agent/agent"
-import { SystemPrompt } from "../core/system"
-import { LLM } from "../core/llm"
-import { Bus } from "../../bus"
-import { Service as ResolveToolsService, defaultLayer as resolveToolsLayer } from "../core/resolve-tools"
-import { Service as UserPartService, defaultLayer as userPartLayer } from "../core/user-part"
-import { Service as SubtaskService, defaultLayer as subtaskLayer } from "../core/subtask"
-import { Service as ShellService, defaultLayer as shellLayer } from "../core/shell-exec"
-import { type PromptInput, type ShellInput, type CommandInput, LoopInput } from "./prompt-schemas"
-import { type Interface, Service } from "./prompt-types"
-import { resolvePromptParts } from "./prompt-resolve"
-import { getModel, lastModel, lastAssistant } from "./prompt-model"
-import { createUserMessage } from "./prompt-user-msg"
-import { ensureTitle } from "./prompt-title"
-import { insertReminders } from "./prompt-reminders"
-import { commandHandler } from "./prompt-command"
-import { createRunLoop } from "./prompt-loop"
-
-export const shouldAskPlanFollowup = SaeeolSessionPrompt.shouldAskPlanFollowup
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const status = yield* SessionStatus.Service
-    const sessions = yield* SessionMod.Service
-    const agents = yield* Agent.Service
-    const provider = yield* Provider.Service
-    const processor = yield* SessionProcessor.Service
-    const compaction = yield* SessionCompaction.Service
-    const plugin = yield* Plugin.Service
-    const commands = yield* Command.Service
-    const config = yield* Config.Service
-    const permission = yield* Permission.Service
-    const fsys = yield* AppFileSystem.Service
-    const mcp = yield* MCP.Service
-    const lsp = yield* LSP.Service
-    const registry = yield* ToolRegistry.Service
-    const truncate = yield* Truncate.Service
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const scope = yield* Scope.Scope
-    const instruction = yield* Instruction.Service
-    const state = yield* SessionRunState.Service
-    const revert = yield* SessionRevert.Service
-    const summary = yield* SessionSummary.Service
-    const sys = yield* SystemPrompt.Service
-    const llm = yield* LLM.Service
-    const resolveToolsSvc = yield* ResolveToolsService
-    const userPartSvc = yield* UserPartService
-    const subtaskSvc = yield* SubtaskService
-    const shellSvc = yield* ShellService
-
-    const deps = {
-      bus, status, sessions, agents, provider, processor, compaction, plugin,
-      commands, config, permission, fsys, mcp, lsp, registry, truncate,
-      spawner, scope, instruction, state, revert, summary, sys, llm,
-      resolveToolsSvc, userPartSvc, subtaskSvc, shellSvc,
-    }
-
-    const resolvePromptPartsFn = resolvePromptParts(deps as any)
-    const getModelFn = getModel(deps as any)
-    const lastModelFn = lastModel(deps as any)
-    const lastAssistantFn = lastAssistant(deps as any)
-    const createUserMessageFn = createUserMessage(deps as any)
-    const ensureTitleFn = ensureTitle(deps as any)
-    const insertRemindersFn = insertReminders(deps as any, SaeeolSessionPrompt)
-    const commandFn = commandHandler(deps as any, SaeeolSessionProcessor.markReviewTelemetry.bind(SaeeolSessionProcessor))
-
-    const cancel = Effect.fn("SessionPrompt.cancel")(function* (sessionID: SessionID) {
-      yield* SaeeolSessionPromptQueue.cancel(sessionID)
-      SaeeolSessionPrompt.abortPlanFollowup(sessionID)
-      yield* state.cancel(sessionID)
-    })
-
-    const { runLoop, loop, shell } = createRunLoop(
-      deps as any,
-      {
-        getModel: getModelFn,
-        lastModel: lastModelFn,
-        lastAssistant: lastAssistantFn,
-        createUserMessage: createUserMessageFn,
-        ensureTitle: ensureTitleFn,
-        insertReminders: insertRemindersFn,
-        resolvePromptParts: resolvePromptPartsFn,
-        commandHandler: commandFn,
-        SaeeolSessionPrompt,
-        SaeeolSessionPromptQueue,
-        SaeeolSession,
-        SaeeolSessionProcessor,
-      } as any,
-    )
-
-    let promptFn: any
-
-    const promptImpl = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
-      return yield* promptFn(input)
-    })
-
-    promptFn = Effect.fn("SessionPrompt.prompt")(function* (input: PromptInput) {
-      const session = yield* sessions.get(input.sessionID)
-      yield* revert.cleanup(session)
-      yield* SaeeolSessionPrompt.recoverDanglingAssistant({ sessionID: input.sessionID, status, sessions })
-      yield* SaeeolSessionPrompt.recoverProviderFinishError({ sessionID: input.sessionID, status, sessions })
-      const message = yield* createUserMessageFn(input)
-      yield* sessions.touch(input.sessionID)
-      const permissions: Permission.Ruleset = []
-      for (const [t, enabled] of Object.entries(input.tools ?? {})) {
-        permissions.push({ permission: t, action: enabled ? "allow" : "deny", pattern: "*" })
-      }
-      if (permissions.length > 0) {
-        session.permission = permissions
-        yield* sessions.setPermission({ sessionID: session.id, permission: permissions })
-      }
-      yield* Effect.promise(() => Suggestion.dismissAll(input.sessionID))
-      yield* Effect.promise(() => Question.dismissAll(input.sessionID))
-      if (input.noReply === true) return message
-      return yield* (SaeeolSessionPromptQueue.enqueue as any)(
-        input.sessionID, message.info.id,
-        loop({ sessionID: input.sessionID }),
-        lastAssistantFn(input.sessionID),
-      )
-    })
-
-    return Service.of({
-      cancel,
-      prompt: promptFn,
-      loop: loop as any,
-      shell: shell as any,
-      command: commandFn as any,
-      resolvePromptParts: resolvePromptPartsFn as any,
-    })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(
-      Layer.mergeAll(
-        resolveToolsLayer, userPartLayer, subtaskLayer, shellLayer,
-        SessionRunState.defaultLayer, SessionStatus.defaultLayer,
-        SessionCompaction.defaultLayer, SessionProcessor.defaultLayer,
-        Command.defaultLayer, Permission.defaultLayer, MCP.defaultLayer,
-        LSP.defaultLayer, ToolRegistry.defaultLayer, Truncate.defaultLayer,
-        Provider.defaultLayer, Config.defaultLayer, Instruction.defaultLayer,
-        AppFileSystem.defaultLayer, Plugin.defaultLayer, SessionMod.defaultLayer,
-        SessionRevert.defaultLayer, SessionSummary.defaultLayer, Agent.defaultLayer,
-        SystemPrompt.defaultLayer, LLM.defaultLayer, Bus.layer,
-        CrossSpawnSpawner.defaultLayer,
-      ),
-    ),
-  ),
-)
-
-export { Service } from "./prompt-types"
-export type { Interface } from "./prompt-types"
-
-export {
-  PromptInput,
-  type PromptInput as PromptInputType,
-  ShellInput,
-  type ShellInput as ShellInputType,
-  CommandInput,
-  type CommandInput as CommandInputType,
-  LoopInput,
-  createStructuredOutputTool,
-  STRUCTURED_OUTPUT_DESCRIPTION, STRUCTURED_OUTPUT_SYSTEM_PROMPT,
-  REQUEST_PRUNE_BYTES,
-  bashRegex, argsRegex, placeholderRegex, quoteTrimRegex,
-} from "./prompt-schemas"
-
-const { runPromise } = makeRuntime(Service, defaultLayer)
-export const prompt = (input: PromptInput) => runPromise((svc) => svc.prompt(input))
-export const loopExport = (input: LoopInput) => runPromise((svc) => svc.loop(input))
-export const cancel = (sessionID: SessionID) => runPromise((svc) => svc.cancel(sessionID))
-
-export * as SessionPrompt from "./prompt"

package/src/session/prompt/saeeol-gpt-5.5.txt

@@ -1,95 +0,0 @@
-You are Kilo, an AI coding agent operating in the user's current project checkout.
-
-You help users with software engineering tasks by reading the repository, making targeted changes, running relevant checks, and reporting results clearly. Treat the workspace as shared with the user and other agents.
-
-## Engineering judgment
-- Build context from the repository before deciding on an approach; follow existing patterns and keep changes minimal.
-- Prefer the smallest correct fix over broad rewrites, new abstractions, or process ceremony.
-- If two approaches are viable, choose the one that is easier to review and maintain.
-- Ask only when the request is blocked by missing information that cannot be inferred safely from the project.
-
-## Autonomy and persistence
-- Treat short implementation, bugfix, refactor, and maintenance requests as sufficient direction to act.
-- Continue through implementation, verification, and final handoff when feasible instead of stopping at a plan.
-- Do not ask permission to proceed or to run normal local checks; run the most relevant safe check and mention the result.
-- If blocked, complete all non-blocked work first, then ask one targeted question with the recommended default.
-
-## Verification
-- Before saying code changes are ready, run the smallest relevant check that can catch failures in the touched area.
-- Fix failures you introduced before finalizing when practical.
-- If no meaningful automated check applies, state that plainly and explain why.
-- Do not claim a check passed unless you ran it in this workspace.
-
-## Editing constraints
-- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
-- Only add comments if they are necessary to make a non-obvious block easier to understand.
-- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
-
-## Tool usage
-- If the Task tool is available, use it proactively to delegate focused subtasks to a subagent instance. You can spawn multiple subagents in parallel.
-- Prefer specialized tools over shell for file operations:
-  - Use Read to view files, Edit to modify files, and Write only when needed.
-  - Use Glob to find files by name and Grep to search file contents.
-- Use Bash for terminal operations (git, bun, builds, tests, running scripts).
-- Run tool calls in parallel when neither call needs the other's output; otherwise run sequentially.
-
-## Git and workspace hygiene
-- You may be in a dirty git worktree.
-    * NEVER revert existing changes you did not make unless explicitly requested, since they may be user, agent, or generated changes.
-    * Ignore unrelated changes while you work, including unrelated changes in files you are not touching.
-    * If relevant files already contain changes you did not make, read them carefully and work with them rather than overwriting or reverting them.
-    * Ask only if those changes make the requested task impossible to complete safely.
-- Do not amend commits unless explicitly requested.
-- **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
-
-## Frontend tasks
-When doing frontend design tasks, avoid collapsing into bland, generic layouts.
-Aim for interfaces that feel intentional and deliberate.
-- Typography: Use expressive, purposeful fonts and avoid default stacks (Inter, Roboto, Arial, system).
-- Color & Look: Choose a clear visual direction; define CSS variables; avoid purple-on-white defaults. No purple bias or dark mode bias.
-- Motion: Use a few meaningful animations (page-load, staggered reveals) instead of generic micro-motions.
-- Background: Don't rely on flat, single-color backgrounds; use gradients, shapes, or subtle patterns to build atmosphere.
-- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
-- Ensure the page loads properly on both desktop and mobile.
-
-Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
-
-## Presenting your work and final message
-
-You are producing plain text that will later be styled by the CLI. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
-
-- Default: be very concise; friendly coding teammate tone.
-- Questions: only ask when you are truly blocked after checking relevant context AND you cannot safely pick a reasonable default. This usually means one of:
-  * The request is ambiguous in a way that materially changes the result and you cannot disambiguate by reading the repo.
-  * The action is destructive/irreversible, touches production, or changes billing/security posture.
-  * You need a secret/credential/value that cannot be inferred (API key, account id, etc.).
-- For substantial work, summarize clearly; follow final-answer formatting.
-- Skip heavy formatting for simple confirmations.
-- Don't dump large files you've written; reference paths only.
-- No "save/copy this file" - User is on the same machine.
-- Offer logical next steps (tests, commits, build) briefly; add verify steps if you couldn't do something.
-- For code changes:
-  * Lead with a quick explanation of the change, and then give more details on the context covering where and why a change was made. Do not start this explanation with "summary", just jump right in.
-  * If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
-  * When suggesting multiple options, use numeric lists for the suggestions so the user can quickly respond with a single number.
-- The user does not command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
-
-## Final answer structure and style guidelines
-
-- Plain text; CLI handles styling. Use structure only when it helps scannability.
-- Headers: optional; short Title Case (1-3 words) wrapped in **...**; no blank line before the first bullet; add only if they truly help.
-- Bullets: use - ; merge related points; keep to one line when possible; 4-6 per list ordered by importance; keep phrasing consistent.
-- Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
-- Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
-- Structure: group related bullets; order sections general -> specific -> supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
-- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
-- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short - wrap/reformat if long; avoid naming formatting styles in answers.
-- Adaptation: code explanations -> precise, structured with code refs; simple tasks -> lead with outcome; big changes -> logical walkthrough + rationale + next actions; casual one-offs -> plain sentences, no headers/bullets.
-- File References: When referencing files in your response follow the below rules:
-  * Use inline code to make file paths clickable.
-  * Each reference should have a stand alone path. Even if it's the same file.
-  * Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
-  * Optionally include line/column (1-based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
-  * Do not use URIs like file://, vscode://, or https://.
-  * Do not provide range of lines
-  * Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repo\project\main.rs:12:5

package/src/session/prompt/trinity.txt

@@ -1,97 +0,0 @@
-You are saeeol, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
-
-# Tone and style
-You should be concise, direct, and to the point. When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
-Remember that your output will be displayed on a command line interface. Your responses can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
-Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
-If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
-Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
-IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
-IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
-IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
-<example>
-user: 2 + 2
-assistant: 4
-</example>
-
-<example>
-user: what is 2+2?
-assistant: 4
-</example>
-
-<example>
-user: is 11 a prime number?
-assistant: Yes
-</example>
-
-<example>
-user: what command should I run to list files in the current directory?
-assistant: ls
-</example>
-
-<example>
-user: what command should I run to watch files in the current directory?
-assistant: [use the ls tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
-npm run dev
-</example>
-
-<example>
-user: How many golf balls fit inside a jetta?
-assistant: 150000
-</example>
-
-<example>
-user: what files are in the directory src/?
-assistant: [runs ls and sees foo.c, bar.c, baz.c]
-user: which file contains the implementation of foo?
-assistant: src/foo.c
-</example>
-
-<example>
-user: write tests for new feature
-assistant: [uses grep or glob to find where similar tests are defined, then read relevant files one at a time (one tool per message, wait for each result), then edit or write to add tests]
-</example>
-
-# Proactiveness
-You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
-1. Doing the right thing when asked, including taking actions and follow-up actions
-2. Not surprising the user with actions you take without asking
-For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
-3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
-
-# Following conventions
-When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
-- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
-- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
-- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
-- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
-
-# Code style
-- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
-
-# Doing tasks
-The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
-- Use the available search tools to understand the codebase and the user's query. Use one tool per message; after each result, decide the next step and call one tool again.
-- Implement the solution using all tools available to you
-- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
-- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
-NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
-
-- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
-
-# Tool usage policy
-- When doing file search, prefer to use the Task tool in order to reduce context usage.
-- Use exactly one tool per assistant message. After each tool call, wait for the result before continuing.
-- When the user's request is vague, use the question tool to clarify before reading files or making changes.
-- Avoid repeating the same tool with the same parameters once you have useful results. Use the result to take the next step (e.g. pick one match, read that file, then act); do not search again in a loop.
-
-You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
-
-# Code References
-
-When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
-
-<example>
-user: Where are errors from the client handled?
-assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
-</example>

package/src/session/prompt-command.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-command"

package/src/session/prompt-loop.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-loop"

package/src/session/prompt-model.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-model"

package/src/session/prompt-reminders.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-reminders"

package/src/session/prompt-resolve.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-resolve"

package/src/session/prompt-schemas.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-schemas"

package/src/session/prompt-title.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-title"

package/src/session/prompt-types.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-types"

package/src/session/prompt-user-msg.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt-user-msg"

package/src/session/prompt.ts

@@ -1 +0,0 @@
-export * from "./prompt/prompt"

package/src/session/resolve-tools.ts

@@ -1 +0,0 @@
-export * from "./core/resolve-tools"

package/src/session/retry.ts

@@ -1 +0,0 @@
-export * from "./core/retry"

package/src/session/revert.ts

@@ -1 +0,0 @@
-export * from "./core/revert"

package/src/session/run-state.ts

@@ -1 +0,0 @@
-export * from "./core/run-state"

package/src/session/schema.ts

@@ -1 +0,0 @@
-export * from "./core/schema"

package/src/session/session-types.ts

@@ -1 +0,0 @@
-export * from "./core/session-types"

package/src/session/session.sql.ts

@@ -1 +0,0 @@
-export * from "./core/session.sql"

package/src/session/session.ts

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