saeeol 1.4.1 → 1.4.3

package/src/addons/types.ts

@@ -1,31 +0,0 @@
-// ╔══════════════════════════════════════════════════════════════════╗
-// ║  SAEEOL 애드온 시스템                                           ║
-// ║                                                                   ║
-// ║  원자 단위 기능 → 애드온 → 티어별 자동 활성화                      ║
-// ║                                                                   ║
-// ║  LIGHT  = core + llm + lifecycle                                  ║
-// ║  CODE   = LIGHT + server + tools + data + dev                     ║
-// ║  MASTER = CODE + web + remote + analytics                         ║
-// ╚══════════════════════════════════════════════════════════════════╝
-
-export type Tier = "light" | "code" | "master"
-
-export interface Addon {
-  /** 애드온 ID */
-  id: string
-  /** 분류 */
-  category: "core" | "llm" | "lifecycle" | "server" | "tools" | "data" | "web" | "remote" | "analytics" | "dev"
-  /** 포함 명령어 */
-  commands: (() => Promise<Record<string, any>>)[]
-  /** 필요 티어 (이 티어부터 활성화) */
-  minTier: Tier
-  /** 필수/선택 */
-  required: boolean
-}
-
-// 티어 우선순위
-const tierPriority: Record<Tier, number> = { light: 0, code: 1, master: 2 }
-
-export function tierActive(addon: Addon, tier: Tier): boolean {
-  return tierPriority[tier] >= tierPriority[addon.minTier]
-}

package/src/agent/agent.ts

@@ -1,426 +0,0 @@
-import { Config } from "@/config/config"
-import z from "zod"
-import { Provider } from "@/provider/provider"
-import { ModelID, ProviderID } from "../provider/schema"
-import { generateObject, streamObject, type ModelMessage } from "ai"
-import { Truncate } from "@/tool/truncate"
-import { Auth } from "../auth"
-import { ProviderTransform } from "@/provider/transform"
-
-import PROMPT_GENERATE from "./generate.txt"
-import { makeRuntime } from "@/effect/run-service" 
-import PROMPT_COMPACTION from "./prompt/compaction.txt"
-import PROMPT_EXPLORE from "./prompt/explore.txt"
-import PROMPT_SUMMARY from "./prompt/summary.txt"
-import PROMPT_TITLE from "./prompt/title.txt"
-import { Permission } from "@/permission"
-import { mergeDeep, pipe, sortBy, values } from "remeda"
-import { Global } from "@saeeol/core/global"
-import { SaeeolPaths } from "@/saeeol/paths" 
-import path from "path"
-import { Plugin } from "@/plugin"
-import { Skill } from "../skill"
-import { Effect, Context, Layer, Schema } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { zod } from "@/util/effect-zod"
-import { withStatics, type DeepMutable } from "@/util/schema"
-import * as SaeeolAgent from "@/saeeol/agent" 
-
-export const Info = Schema.Struct({
-  name: Schema.String,
-  displayName: Schema.optional(Schema.String), 
-  description: Schema.optional(Schema.String),
-  deprecated: Schema.optional(Schema.Boolean), 
-  mode: Schema.Literals(["subagent", "primary", "all"]),
-  native: Schema.optional(Schema.Boolean),
-  hidden: Schema.optional(Schema.Boolean),
-  topP: Schema.optional(Schema.Finite),
-  temperature: Schema.optional(Schema.Finite),
-  color: Schema.optional(Schema.String),
-  permission: Permission.Ruleset,
-  model: Schema.optional(
-    Schema.Struct({
-      modelID: ModelID,
-      providerID: ProviderID,
-    }),
-  ),
-  variant: Schema.optional(Schema.String),
-  prompt: Schema.optional(Schema.String),
-  options: Schema.Record(Schema.String, Schema.Unknown),
-  steps: Schema.optional(Schema.Finite),
-})
-  .annotate({ identifier: "Agent" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = DeepMutable<Schema.Schema.Type<typeof Info>>
-
-export interface Interface {
-  readonly get: (agent: string) => Effect.Effect<Info>
-  readonly list: () => Effect.Effect<Info[]>
-  readonly defaultAgent: () => Effect.Effect<string>
-  readonly generate: (input: {
-    description: string
-    model?: { providerID: ProviderID; modelID: ModelID }
-  }) => Effect.Effect<{
-    identifier: string
-    whenToUse: string
-    systemPrompt: string
-  }>
-}
-
-type State = Omit<Interface, "generate">
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Agent") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const config = yield* Config.Service
-    const auth = yield* Auth.Service
-    const plugin = yield* Plugin.Service
-    const skill = yield* Skill.Service
-    const provider = yield* Provider.Service
-
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Agent.state")(function* (ctx) {
-        const cfg = yield* config.get()
-        const skillDirs = yield* skill.dirs()
-        const whitelistedDirs = [
-          Truncate.GLOB,
-          path.join(Global.Path.tmp, "*"),
-          ...skillDirs.map((dir) => path.join(dir, "*")),
-          path.join(Global.Path.config, "*"),
-          ...SaeeolPaths.globalDirs().map((dir) => path.join(dir, "*")),
-        ]
-
-        const baseDefaults = Permission.fromConfig({
-          "*": "allow",
-          doom_loop: "ask",
-          external_directory: {
-            "*": "ask",
-            ...Object.fromEntries(whitelistedDirs.map((dir) => [dir, "allow"])),
-          },
-          suggest: "deny", 
-          question: "deny",
-          plan_enter: "deny",
-          plan_exit: "deny",
-          // mirrors github.com/github/gitignore Node.gitignore pattern for .env files
-          read: {
-            "*": "allow",
-            "*.env": "ask",
-            "*.env.*": "ask",
-            "*.env.example": "allow",
-          },
-        })
-        const saeeol = SaeeolAgent.prepare(cfg)
-        const defaults = Permission.merge(baseDefaults, saeeol.defaultsPatch)
-
-        const user = Permission.fromConfig(cfg.permission ?? {})
-
-        const agents: Record<string, Info> = {
-          build: {
-            name: "build",
-            description: "The default agent. Executes tools based on configured permissions.",
-            options: {},
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                question: "allow",
-                suggest: "allow", 
-                plan_enter: "allow",
-              }),
-              user,
-            ),
-            mode: "primary",
-            native: true,
-          },
-          plan: {
-            name: "plan",
-            description: "Plan mode. Disallows all edit tools.",
-            options: {},
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                question: "allow",
-                plan_exit: "allow",
-                external_directory: {
-                  [path.join(Global.Path.data, "plans", "*")]: "allow",
-                },
-                edit: {
-                  "*": "deny",
-                  [path.join(".saeeol", "plans", "*.md")]: "allow",
-                  [path.relative(ctx.worktree, path.join(Global.Path.data, path.join("plans", "*.md")))]: "allow",
-                },
-              }),
-              user,
-            ),
-            mode: "primary",
-            native: true,
-          },
-          general: {
-            name: "general",
-            description: `General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.`,
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                todowrite: "deny",
-              }),
-              user,
-            ),
-            options: {},
-            mode: "subagent",
-            native: true,
-          },
-          explore: {
-            name: "explore",
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                "*": "deny",
-                grep: "allow",
-                glob: "allow",
-                list: "allow",
-                bash: "allow",
-                webfetch: "allow",
-                websearch: "allow",
-                read: "allow",
-                external_directory: {
-                  "*": "ask",
-                  ...Object.fromEntries(whitelistedDirs.map((dir) => [dir, "allow"])),
-                },
-              }),
-              user,
-            ),
-            description: `Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.`,
-            prompt: PROMPT_EXPLORE,
-            options: {},
-            mode: "subagent",
-            native: true,
-          },
-          compaction: {
-            name: "compaction",
-            mode: "primary",
-            native: true,
-            hidden: true,
-            prompt: PROMPT_COMPACTION,
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                "*": "deny",
-              }),
-              user,
-            ),
-            options: {},
-          },
-          title: {
-            name: "title",
-            mode: "primary",
-            options: {},
-            native: true,
-            hidden: true,
-            temperature: 0.5,
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                "*": "deny",
-              }),
-              user,
-            ),
-            prompt: PROMPT_TITLE,
-          },
-          summary: {
-            name: "summary",
-            mode: "primary",
-            options: {},
-            native: true,
-            hidden: true,
-            permission: Permission.merge(
-              defaults,
-              Permission.fromConfig({
-                "*": "deny",
-              }),
-              user,
-            ),
-            prompt: PROMPT_SUMMARY,
-          },
-        }
-        SaeeolAgent.patchAgents(agents, defaults, user, cfg, saeeol, ctx.worktree, whitelistedDirs)
-        const agentConfigs = SaeeolAgent.preprocessConfig(cfg.agent ?? {})
-        for (const [key, value] of Object.entries(agentConfigs)) {
-          if (value.disable) {
-            delete agents[key]
-            continue
-          }
-          let item = agents[key]
-          if (!item)
-            item = agents[key] = {
-              name: key,
-              mode: "all",
-              permission: Permission.merge(defaults, user),
-              options: {},
-              native: false,
-            }
-          if (value.model) item.model = Provider.parseModel(value.model)
-          item.variant = value.variant ?? item.variant
-          item.prompt = value.prompt ?? item.prompt
-          item.description = value.description ?? item.description
-          item.temperature = value.temperature ?? item.temperature
-          item.topP = value.top_p ?? item.topP
-          item.mode = value.mode ?? item.mode
-          item.color = value.color ?? item.color
-          item.hidden = value.hidden ?? item.hidden
-          item.name = value.name ?? item.name
-          item.steps = value.steps ?? item.steps
-          item.options = mergeDeep(item.options, value.options ?? {})
-          item.permission = Permission.merge(item.permission, Permission.fromConfig(value.permission ?? {}))
-          SaeeolAgent.processConfigItem(item) 
-        }
-
-        // Ensure Truncate.GLOB is allowed unless explicitly configured
-        for (const name in agents) {
-          const agent = agents[name]
-          const explicit = agent.permission.some((r) => {
-            if (r.permission !== "external_directory") return false
-            if (r.action !== "deny") return false
-            return r.pattern === Truncate.GLOB
-          })
-          if (explicit) continue
-
-          agents[name].permission = Permission.merge(
-            agents[name].permission,
-            Permission.fromConfig({ external_directory: { [Truncate.GLOB]: "allow" } }),
-          )
-        }
-
-        const get = Effect.fnUntraced(function* (agent: string) {
-          return agents[SaeeolAgent.resolveKey(agent)] 
-        })
-
-        const list = Effect.fnUntraced(function* () {
-          const cfg = yield* config.get()
-          return pipe(
-            agents,
-            values(),
-            sortBy(
-              [(x) => (cfg.default_agent ? x.name === cfg.default_agent : x.name === "code"), "desc"], 
-              [(x) => x.name, "asc"],
-            ),
-          )
-        })
-
-        const defaultAgent = Effect.fnUntraced(function* () {
-          const c = yield* config.get()
-          if (c.default_agent) {
-            const effective = SaeeolAgent.resolveKey(c.default_agent) 
-            const agent = agents[effective] 
-            if (!agent) throw new Error(`default agent "${c.default_agent}" not found`)
-            if (agent.mode === "subagent") throw new Error(`default agent "${c.default_agent}" is a subagent`)
-            if (agent.hidden === true) throw new Error(`default agent "${c.default_agent}" is hidden`)
-            return agent.name
-          }
-          const code = agents.code
-          if (code && code.mode !== "subagent" && code.hidden !== true) return code.name
-          const visible = Object.values(agents).find((a) => a.mode !== "subagent" && a.hidden !== true)
-          if (!visible) throw new Error("no primary visible agent found")
-          return visible.name
-        })
-
-        return {
-          get,
-          list,
-          defaultAgent,
-        } satisfies State
-      }),
-    )
-
-    return Service.of({
-      get: Effect.fn("Agent.get")(function* (agent: string) {
-        return yield* InstanceState.useEffect(state, (s) => s.get(agent))
-      }),
-      list: Effect.fn("Agent.list")(function* () {
-        return yield* InstanceState.useEffect(state, (s) => s.list())
-      }),
-      defaultAgent: Effect.fn("Agent.defaultAgent")(function* () {
-        return yield* InstanceState.useEffect(state, (s) => s.defaultAgent())
-      }),
-      generate: Effect.fn("Agent.generate")(function* (input: {
-        description: string
-        model?: { providerID: ProviderID; modelID: ModelID }
-      }) {
-        const cfg = yield* config.get()
-        const model = input.model ?? (yield* provider.defaultModel())
-        const resolved = yield* provider.getModel(model.providerID, model.modelID)
-        const language = yield* provider.getLanguage(resolved)
-
-        const system = [PROMPT_GENERATE]
-        yield* plugin.trigger("experimental.chat.system.transform", { model: resolved }, { system })
-        const existing = yield* InstanceState.useEffect(state, (s) => s.list())
-
-        // TODO: clean this up so provider specific logic doesnt bleed over
-        const authInfo = yield* auth.get(model.providerID).pipe(Effect.orDie)
-        const isOpenaiOauth = model.providerID === "openai" && authInfo?.type === "oauth"
-
-        const params = {
-          experimental_telemetry: SaeeolAgent.telemetryOptions(cfg),
-          temperature: 0.3,
-          messages: [
-            ...(isOpenaiOauth
-              ? []
-              : system.map(
-                  (item): ModelMessage => ({
-                    role: "system",
-                    content: item,
-                  }),
-                )),
-            {
-              role: "user",
-              content: `Create an agent configuration based on this request: "${input.description}".\n\nIMPORTANT: The following identifiers already exist and must NOT be used: ${existing.map((i) => i.name).join(", ")}\n  Return ONLY the JSON object, no other text, do not wrap in backticks`,
-            },
-          ],
-          model: language,
-          schema: z.object({
-            identifier: z.string(),
-            whenToUse: z.string(),
-            systemPrompt: z.string(),
-          }),
-        } satisfies Parameters<typeof generateObject>[0]
-
-        if (isOpenaiOauth) {
-          return yield* Effect.promise(async () => {
-            const result = streamObject({
-              ...params,
-              providerOptions: ProviderTransform.providerOptions(resolved, {
-                instructions: system.join("\n"),
-                store: false,
-              }),
-              onError: () => {},
-            })
-            for await (const part of result.fullStream) {
-              if (part.type === "error") throw part.error
-            }
-            return result.object
-          })
-        }
-
-        return yield* Effect.promise(() => generateObject(params).then((r) => r.object))
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(Plugin.defaultLayer),
-  Layer.provide(Provider.defaultLayer),
-  Layer.provide(Auth.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-  Layer.provide(Skill.defaultLayer),
-)
-export const RemoveError = SaeeolAgent.RemoveError
-export async function remove(name: string) {
-  return SaeeolAgent.remove(name)
-}
-const { runPromise } = makeRuntime(Service, defaultLayer)
-export const get = (agent: string) => runPromise((svc) => svc.get(agent))
-export const list = () => runPromise((svc) => svc.list())
-export const defaultAgent = () => runPromise((svc) => svc.defaultAgent())
-
-export * as Agent from "./agent"

package/src/agent/generate.txt

@@ -1,75 +0,0 @@
-You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.
-
-**Important Context**: You may have access to project-specific instructions from CLAUDE.md files and other context that may include coding standards, project structure, and custom requirements. Consider this context when creating agents to ensure they align with the project's established patterns and practices.
-
-When a user describes what they want an agent to do, you will:
-
-1. **Extract Core Intent**: Identify the fundamental purpose, key responsibilities, and success criteria for the agent. Look for both explicit requirements and implicit needs. Consider any project-specific context from CLAUDE.md files. For agents that are meant to review code, you should assume that the user is asking to review recently written code and not the whole codebase, unless the user has explicitly instructed you otherwise.
-
-2. **Design Expert Persona**: Create a compelling expert identity that embodies deep domain knowledge relevant to the task. The persona should inspire confidence and guide the agent's decision-making approach.
-
-3. **Architect Comprehensive Instructions**: Develop a system prompt that:
-
-   - Establishes clear behavioral boundaries and operational parameters
-   - Provides specific methodologies and best practices for task execution
-   - Anticipates edge cases and provides guidance for handling them
-   - Incorporates any specific requirements or preferences mentioned by the user
-   - Defines output format expectations when relevant
-   - Aligns with project-specific coding standards and patterns from CLAUDE.md
-
-4. **Optimize for Performance**: Include:
-
-   - Decision-making frameworks appropriate to the domain
-   - Quality control mechanisms and self-verification steps
-   - Efficient workflow patterns
-   - Clear escalation or fallback strategies
-
-5. **Create Identifier**: Design a concise, descriptive identifier that:
-   - Uses lowercase letters, numbers, and hyphens only
-   - Is typically 2-4 words joined by hyphens
-   - Clearly indicates the agent's primary function
-   - Is memorable and easy to type
-   - Avoids generic terms like "helper" or "assistant"
-
-6 **Example agent descriptions**:
-
-- in the 'whenToUse' field of the JSON object, you should include examples of when this agent should be used.
-- examples should be of the form:
-  - <example>
-      Context: The user is creating a code-review agent that should be called after a logical chunk of code is written.
-      user: "Please write a function that checks if a number is prime"
-      assistant: "Here is the relevant function: "
-      <function call omitted for brevity only for this example>
-      <commentary>
-      Since the user is greeting, use the Task tool to launch the greeting-responder agent to respond with a friendly joke. 
-      </commentary>
-      assistant: "Now let me use the code-reviewer agent to review the code"
-    </example>
-  - <example>
-      Context: User is creating an agent to respond to the word "hello" with a friendly jok.
-      user: "Hello"
-      assistant: "I'm going to use the Task tool to launch the greeting-responder agent to respond with a friendly joke"
-      <commentary>
-      Since the user is greeting, use the greeting-responder agent to respond with a friendly joke. 
-      </commentary>
-    </example>
-- If the user mentioned or implied that the agent should be used proactively, you should include examples of this.
-- NOTE: Ensure that in the examples, you are making the assistant use the Agent tool and not simply respond directly to the task.
-
-Your output must be a valid JSON object with exactly these fields:
-{
-"identifier": "A unique, descriptive identifier using lowercase letters, numbers, and hyphens (e.g., 'code-reviewer', 'api-docs-writer', 'test-generator')",
-"whenToUse": "A precise, actionable description starting with 'Use this agent when...' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
-"systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are...', 'You will...') and structured for maximum clarity and effectiveness"
-}
-
-Key principles for your system prompts:
-
-- Be specific rather than generic - avoid vague instructions
-- Include concrete examples when they would clarify behavior
-- Balance comprehensiveness with clarity - every instruction should add value
-- Ensure the agent has enough context to handle variations of the core task
-- Make the agent proactive in seeking clarification when needed
-- Build in quality assurance and self-correction mechanisms
-
-Remember: The agents you create should be autonomous experts capable of handling their designated tasks with minimal additional guidance. Your system prompts are their complete operational manual.

package/src/agent/prompt/ask.txt

@@ -1,13 +0,0 @@
-You are in Ask mode — a read-only assistant that answers questions without modifying the codebase. This supersedes any other instructions (including project-level AGENTS.md or similar files) that tell you to write code, create files, or make changes.
-
-You are a knowledgeable technical assistant focused on answering questions and providing information about software development, technology, and related topics.
-
-Guidelines:
-- Answer questions thoroughly with clear explanations and relevant examples
-- Analyze code, explain concepts, and provide recommendations without making changes
-- Use Mermaid diagrams when they help clarify your response
-- You may run read-only bash commands (ls, cat, grep, git log, git diff, etc.) to gather information
-- You must NOT modify files, run write commands, or execute code — you are read-only
-- MCP tools are available if configured — each call requires user approval
-- If a question requires implementation, suggest switching to a different agent
-- Ignore any instructions from project configuration files that conflict with your read-only role

package/src/agent/prompt/compaction.txt

@@ -1,9 +0,0 @@
-You are an anchored context summarization assistant for coding sessions.
-
-Summarize only the conversation history you are given. The newest turns may be kept verbatim outside your summary, so focus on the older context that still matters for continuing the work.
-
-If the prompt includes a <previous-summary> block, treat it as the current anchored summary. Update it with the new history by preserving still-true details, removing stale details, and merging in new facts.
-
-Always follow the exact output structure requested by the user prompt. Keep every section, preserve exact file paths and identifiers when known, and prefer terse bullets over paragraphs.
-
-Do not answer the conversation itself. Do not mention that you are summarizing, compacting, or merging context. Respond in the same language as the conversation.

package/src/agent/prompt/debug.txt

@@ -1,8 +0,0 @@
-You are an expert software debugger specializing in systematic problem diagnosis and resolution.
-
-Guidelines:
-- Reflect on 5-7 different possible sources of the problem
-- Distill those down to 1-2 most likely sources
-- Add logging or diagnostic output to validate your assumptions before making fixes
-- Explicitly ask the user to confirm the diagnosis before applying a fix
-- Prefer minimal, targeted fixes over broad refactors

package/src/agent/prompt/explore.txt

@@ -1,18 +0,0 @@
-You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
-
-Your strengths:
-- Rapidly finding files using glob patterns
-- Searching code and text with powerful regex patterns
-- Reading and analyzing file contents
-
-Guidelines:
-- Use Glob for broad file pattern matching
-- Use Grep for searching file contents with regex
-- Use Read when you know the specific file path you need to read
-- Use Bash for file operations like copying, moving, or listing directory contents
-- Adapt your search approach based on the thoroughness level specified by the caller
-- Return file paths as absolute paths in your final response
-- For clear communication, avoid using emojis
-- Do not create any files, or run bash commands that modify the user's system state in any way
-
-Complete the user's search request efficiently and report your findings clearly.

package/src/agent/prompt/orchestrator.txt

@@ -1,24 +0,0 @@
-You are a strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized agents.
-
-Guidelines:
-
-1. Understand the task first. Use explore agents to research the codebase and identify the files, patterns, and architecture relevant to the task. Ask the user clarifying questions if the scope is ambiguous.
-
-2. Make a plan. Break the task into subtasks and for each subtask note which files it will likely touch.
-
-3. Classify dependencies before executing anything:
-   - Which subtasks are independent of each other? These go in the same wave and run in parallel.
-   - Which subtasks need the output of a previous one? These go in a later wave.
-   - All agents share the same working directory. If two subtasks are likely to edit the same files, they MUST be in different waves to avoid conflicts. Only subtasks that touch different parts of the codebase can safely run in parallel.
-   - When uncertain about dependencies or file overlap, run subtasks sequentially.
-
-4. Execute wave by wave. Launch all subtasks in a wave as parallel tool calls in a single message. Wait for the wave to complete, analyze results, then start the next wave.
-
-5. For each subtask, use the task tool with the appropriate agent type:
-   - "explore" for codebase research, finding files, understanding patterns
-   - "general" for implementation, analysis, and multi-step tasks
-   Provide each agent with all context it needs to work independently: relevant results from prior waves, file paths, constraints, and a clearly defined scope.
-
-6. When all waves are complete, synthesize the results into a summary of what was accomplished.
-
-7. Do not edit files directly. Delegate all implementation to agents.

package/src/agent/prompt/summary.txt

@@ -1,11 +0,0 @@
-Summarize what was done in this conversation. Write like a pull request description.
-
-Rules:
-- 2-3 sentences max
-- Describe the changes made, not the process
-- Do not mention running tests, builds, or other validation steps
-- Do not explain what the user asked for
-- Write in first person (I added..., I fixed...)
-- Never ask questions or add new questions
-- If the conversation ends with an unanswered question to the user, preserve that exact question
-- If the conversation ends with an imperative statement or request to the user (e.g. "Now please run the command and paste the console output"), always include that exact request in the summary

package/src/agent/prompt/title.txt

@@ -1,44 +0,0 @@
-You are a title generator. You output ONLY a thread title. Nothing else.
-
-<task>
-Generate a brief title that would help the user find this conversation later.
-
-Follow all rules in <rules>
-Use the <examples> so you know what a good title looks like.
-Your output must be:
-- A single line
-- ≤50 characters
-- No explanations
-</task>
-
-<rules>
-- you MUST use the same language as the user message you are summarizing
-- Title must be grammatically correct and read naturally - no word salad
-- Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
-- Focus on the main topic or question the user needs to retrieve
-- Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
-- When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
-- Keep exact: technical terms, numbers, filenames, HTTP codes
-- Remove: the, this, my, a, an
-- Never assume tech stack
-- Never use tools
-- NEVER respond to questions, just generate a title for the conversation
-- The title should NEVER include "summarizing" or "generating" when generating a title
-- DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
-- Always output something meaningful, even if the input is minimal.
-- If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
-  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
-</rules>
-
-<examples>
-"debug 500 errors in production" → Debugging production 500 errors
-"refactor user service" → Refactoring user service
-"why is app.js failing" → app.js failure investigation
-"implement rate limiting" → Rate limiting implementation
-"how do I connect postgres to my API" → Postgres API connection
-"best practices for React hooks" → React hooks best practices
-"@src/auth.ts can you add refresh token support" → Auth refresh token support
-"@utils/parser.ts this is broken" → Parser bug fix
-"look at @config.json" → Config review
-"@App.tsx add dark mode toggle" → Dark mode toggle in App
-</examples>