wip: sync

wip: drop
handle uploaded text/plain
2025-07-25 15:52:27 -04:00 · 2025-07-25 15:51:02 -04:00 · 2025-07-25 15:48:42 -04:00 · 2025-07-25 15:26:49 -04:00 · 2025-07-25 13:45:04 -04:00 · 2025-07-25 13:29:44 -04:00
58 changed files with 1921 additions and 538 deletions
@@ -1,8 +1,8 @@
 .DS_Store
 node_modules
-.opencode
 .sst
 .env
 .idea
 .vscode
 openapi.json
+scratch
@@ -0,0 +1,44 @@
+---
+description: >-
+  Use this agent when you need to create or improve documentation that requires
+  concrete examples to illustrate every concept. Examples include:
+  <example>Context: User has written a new API endpoint and needs documentation.
+  user: 'I just created a POST /users endpoint that accepts name and email
+  fields. Can you document this?' assistant: 'I'll use the
+  example-driven-docs-writer agent to create documentation with practical
+  examples for your API endpoint.' <commentary>Since the user needs
+  documentation with examples, use the example-driven-docs-writer agent to
+  create comprehensive docs with code samples.</commentary></example>
+  <example>Context: User has a complex configuration file that needs
+  documentation. user: 'This config file has multiple sections and I need docs
+  that show how each option works' assistant: 'Let me use the
+  example-driven-docs-writer agent to create documentation that breaks down each
+  configuration option with practical examples.' <commentary>The user needs
+  documentation that demonstrates configuration options, perfect for the
+  example-driven-docs-writer agent.</commentary></example>
+---
+You are an expert technical documentation writer who specializes in creating clear, example-rich documentation that never leaves readers guessing. Your core principle is that every concept must be immediately illustrated with concrete examples, code samples, or practical demonstrations.
+
+Your documentation approach:
+- Never write more than one sentence in any section without providing an example, code snippet, diagram, or practical illustration
+- Break up longer explanations with multiple examples showing different scenarios or use cases
+- Use concrete, realistic examples rather than abstract or placeholder content
+- Include both basic and advanced examples when covering complex topics
+- Show expected inputs, outputs, and results for all examples
+- Use code blocks, bullet points, tables, or other formatting to visually separate examples from explanatory text
+
+Structural requirements:
+- Start each section with a brief one-sentence explanation followed immediately by an example
+- For multi-step processes, provide an example after each step
+- Include error examples and edge cases alongside success scenarios
+- Use consistent formatting and naming conventions throughout examples
+- Ensure examples are copy-pasteable and functional when applicable
+
+Quality standards:
+- Verify that no paragraph exceeds one sentence without an accompanying example
+- Test that examples are accurate and would work in real scenarios
+- Ensure examples progress logically from simple to complex
+- Include context for when and why to use different approaches shown in examples
+- Provide troubleshooting examples for common issues
+
+When you receive a documentation request, immediately identify what needs examples and plan to illustrate every single concept, feature, or instruction with concrete demonstrations. Ask for clarification if you need more context to create realistic, useful examples.
@@ -26,3 +26,4 @@
 | 2025-07-22 | 84,251 (+4,054)  | 118,073 (+4,536) | 202,324 (+8,590)  |
 | 2025-07-23 | 88,589 (+4,338)  | 121,436 (+3,363) | 210,025 (+7,701)  |
 | 2025-07-24 | 92,469 (+3,880)  | 124,091 (+2,655) | 216,560 (+6,535)  |
+| 2025-07-25 | 96,417 (+3,948)  | 126,985 (+2,894) | 223,402 (+6,842)  |
@@ -33,9 +33,12 @@
        "@hono/zod-validator": "0.4.2",
        "@modelcontextprotocol/sdk": "1.15.1",
        "@openauthjs/openauth": "0.4.3",
+        "@standard-schema/spec": "1.0.0",
+        "@zip.js/zip.js": "2.7.62",
        "ai": "catalog:",
        "decimal.js": "10.5.0",
        "diff": "8.0.2",
+        "gray-matter": "4.0.3",
        "hono": "4.7.10",
        "hono-openapi": "0.4.8",
        "isomorphic-git": "1.32.1",
@@ -749,6 +752,8 @@

    "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],

+    "@zip.js/zip.js": ["@zip.js/zip.js@2.7.62", "", {}, "sha512-OaLvZ8j4gCkLn048ypkZu29KX30r8/OfFF2w4Jo5WXFr+J04J+lzJ5TKZBVgFXhlvSkqNFQdfnY1Q8TMTCyBVA=="],
+
    "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="],

    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
@@ -1151,6 +1156,8 @@

    "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],

+    "extend-shallow": ["extend-shallow@2.0.1", "", { "dependencies": { "is-extendable": "^0.1.0" } }, "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug=="],
+
    "fast-content-type-parse": ["fast-content-type-parse@3.0.0", "", {}, "sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg=="],

    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
@@ -1241,6 +1248,8 @@

    "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="],

+    "gray-matter": ["gray-matter@4.0.3", "", { "dependencies": { "js-yaml": "^3.13.1", "kind-of": "^6.0.2", "section-matter": "^1.0.0", "strip-bom-string": "^1.0.0" } }, "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q=="],
+
    "h3": ["h3@1.15.3", "", { "dependencies": { "cookie-es": "^1.2.2", "crossws": "^0.3.4", "defu": "^6.1.4", "destr": "^2.0.5", "iron-webcrypto": "^1.2.1", "node-mock-http": "^1.0.0", "radix3": "^1.1.2", "ufo": "^1.6.1", "uncrypto": "^0.1.3" } }, "sha512-z6GknHqyX0h9aQaTx22VZDf6QyZn+0Nh+Ym8O/u0SGSkyF5cuTJYKlc8MkzW3Nzf9LE1ivcpmYC3FUGpywhuUQ=="],

    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
@@ -1363,6 +1372,8 @@

    "is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],

+    "is-extendable": ["is-extendable@0.1.1", "", {}, "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw=="],
+
    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],

    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
@@ -1493,6 +1504,8 @@

    "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],

+    "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
+
    "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],

    "klona": ["klona@2.0.6", "", {}, "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA=="],
@@ -1965,6 +1978,8 @@

    "sax": ["sax@1.2.1", "", {}, "sha512-8I2a3LovHTOpm7NV5yOyO8IHqgVsfK4+UuySrXU8YXkSRX7k6hCV9b3HrkKCr3nMpgj+0bmocaJJWpvp1oc7ZA=="],

+    "section-matter": ["section-matter@1.0.0", "", { "dependencies": { "extend-shallow": "^2.0.1", "kind-of": "^6.0.0" } }, "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA=="],
+
    "secure-json-parse": ["secure-json-parse@2.7.0", "", {}, "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw=="],

    "semver": ["semver@7.7.2", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="],
@@ -2073,6 +2088,8 @@

    "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="],

+    "strip-bom-string": ["strip-bom-string@1.0.0", "", {}, "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g=="],
+
    "strip-final-newline": ["strip-final-newline@2.0.0", "", {}, "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA=="],

    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
@@ -2445,6 +2462,8 @@

    "glob/minimatch": ["minimatch@5.1.6", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g=="],

+    "gray-matter/js-yaml": ["js-yaml@3.14.1", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g=="],
+
    "hast-util-to-parse5/property-information": ["property-information@6.5.0", "", {}, "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig=="],

    "http-errors/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="],
@@ -2645,6 +2664,8 @@

    "glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],

+    "gray-matter/js-yaml/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="],
+
    "ignore-walk/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],

    "jest-changed-files/p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
@@ -288,6 +288,56 @@ export default {
      })
    }

+    /**
+     * Used by the GitHub action to get GitHub installation access token given user PAT token (used when testing `opencode github run` locally)
+     */
+    if (request.method === "POST" && method === "exchange_github_app_token_with_pat") {
+      const body = await request.json<any>()
+      const owner = body.owner
+      const repo = body.repo
+
+      try {
+        // get Authorization header
+        const authHeader = request.headers.get("Authorization")
+        const token = authHeader?.replace(/^Bearer /, "")
+        if (!token) throw new Error("Authorization header is required")
+
+        // Verify permissions
+        const userClient = new Octokit({ auth: token })
+        const { data: repoData } = await userClient.repos.get({ owner, repo })
+        if (!repoData.permissions.admin && !repoData.permissions.push && !repoData.permissions.maintain)
+          throw new Error("User does not have write permissions")
+
+        // Get installation token
+        const auth = createAppAuth({
+          appId: Resource.GITHUB_APP_ID.value,
+          privateKey: Resource.GITHUB_APP_PRIVATE_KEY.value,
+        })
+        const appAuth = await auth({ type: "app" })
+
+        // Lookup installation
+        const appClient = new Octokit({ auth: appAuth.token })
+        const { data: installation } = await appClient.apps.getRepoInstallation({ owner, repo })
+
+        // Get installation token
+        const installationAuth = await auth({ type: "installation", installationId: installation.id })
+
+        return new Response(JSON.stringify({ token: installationAuth.token }), {
+          headers: { "Content-Type": "application/json" },
+        })
+      } catch (e: any) {
+        let error = e
+        if (e instanceof Error) {
+          error = e.message
+        }
+
+        return new Response(JSON.stringify({ error }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" },
+        })
+      }
+    }
+
    /**
     * Used by the opencode CLI to check if the GitHub app is installed
     */
@@ -31,9 +31,12 @@
    "@hono/zod-validator": "0.4.2",
    "@modelcontextprotocol/sdk": "1.15.1",
    "@openauthjs/openauth": "0.4.3",
+    "@standard-schema/spec": "1.0.0",
+    "@zip.js/zip.js": "2.7.62",
    "ai": "catalog:",
    "decimal.js": "10.5.0",
    "diff": "8.0.2",
+    "gray-matter": "4.0.3",
    "hono": "4.7.10",
    "hono-openapi": "0.4.8",
    "isomorphic-git": "1.32.1",
@@ -0,0 +1,102 @@
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import z from "zod"
+import { Provider } from "../provider/provider"
+import { generateObject, type ModelMessage } from "ai"
+import PROMPT_GENERATE from "./generate.txt"
+import { SystemPrompt } from "../session/system"
+
+export namespace Agent {
+  export const Info = z
+    .object({
+      name: z.string(),
+      model: z
+        .object({
+          modelID: z.string(),
+          providerID: z.string(),
+        })
+        .optional(),
+      description: z.string(),
+      prompt: z.string().optional(),
+      tools: z.record(z.boolean()),
+    })
+    .openapi({
+      ref: "Agent",
+    })
+  export type Info = z.infer<typeof Info>
+  const state = App.state("agent", async () => {
+    const cfg = await Config.get()
+    const result: Record<string, Info> = {
+      general: {
+        name: "general",
+        description:
+          "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.",
+        tools: {
+          todoread: false,
+          todowrite: false,
+        },
+      },
+    }
+    for (const [key, value] of Object.entries(cfg.agent ?? {})) {
+      if (value.disable) continue
+      let item = result[key]
+      if (!item)
+        item = result[key] = {
+          name: key,
+          description: "",
+          tools: {
+            todowrite: false,
+            todoread: false,
+          },
+        }
+      const model = value.model ?? cfg.model
+      if (model) item.model = Provider.parseModel(model)
+      if (value.prompt) item.prompt = value.prompt
+      if (value.tools)
+        item.tools = {
+          ...item.tools,
+          ...value.tools,
+        }
+      if (value.description) item.description = value.description
+    }
+    return result
+  })
+
+  export async function get(agent: string) {
+    return state().then((x) => x[agent])
+  }
+
+  export async function list() {
+    return state().then((x) => Object.values(x))
+  }
+
+  export async function generate(input: { description: string }) {
+    const defaultModel = await Provider.defaultModel()
+    const model = await Provider.getModel(defaultModel.providerID, defaultModel.modelID)
+    const system = SystemPrompt.header(defaultModel.providerID)
+    system.push(PROMPT_GENERATE)
+    const existing = await list()
+    const result = await generateObject({
+      temperature: 0.3,
+      prompt: [
+        ...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: model.language,
+      schema: z.object({
+        identifier: z.string(),
+        whenToUse: z.string(),
+        systemPrompt: z.string(),
+      }),
+    })
+    return result.object
+  }
+}
@@ -0,0 +1,75 @@
+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.
@@ -0,0 +1,110 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "../../global"
+import { Agent } from "../../agent/agent"
+import path from "path"
+import matter from "gray-matter"
+import { App } from "../../app/app"
+
+const AgentCreateCommand = cmd({
+  command: "create",
+  describe: "create a new agent",
+  async handler() {
+    await App.provide({ cwd: process.cwd() }, async (app) => {
+      UI.empty()
+      prompts.intro("Create agent")
+
+      let scope: "global" | "project" = "global"
+      if (app.git) {
+        const scopeResult = await prompts.select({
+          message: "Location",
+          options: [
+            {
+              label: "Current project",
+              value: "project" as const,
+              hint: app.path.root,
+            },
+            {
+              label: "Global",
+              value: "global" as const,
+              hint: Global.Path.config,
+            },
+          ],
+        })
+        if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
+        scope = scopeResult
+      }
+
+      const query = await prompts.text({
+        message: "Description",
+        placeholder: "What should this agent do?",
+        validate: (x) => (x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(query)) throw new UI.CancelledError()
+
+      const spinner = prompts.spinner()
+
+      spinner.start("Generating agent configuration...")
+      const generated = await Agent.generate({ description: query })
+      spinner.stop(`Agent ${generated.identifier} generated`)
+
+      const availableTools = [
+        "bash",
+        "read",
+        "write",
+        "edit",
+        "list",
+        "glob",
+        "grep",
+        "webfetch",
+        "task",
+        "todowrite",
+        "todoread",
+      ]
+
+      const selectedTools = await prompts.multiselect({
+        message: "Select tools to enable",
+        options: availableTools.map((tool) => ({
+          label: tool,
+          value: tool,
+        })),
+        initialValues: availableTools,
+      })
+      if (prompts.isCancel(selectedTools)) throw new UI.CancelledError()
+
+      const tools: Record<string, boolean> = {}
+      for (const tool of availableTools) {
+        if (!selectedTools.includes(tool)) {
+          tools[tool] = false
+        }
+      }
+
+      const frontmatter: any = {
+        description: generated.whenToUse,
+      }
+      if (Object.keys(tools).length > 0) {
+        frontmatter.tools = tools
+      }
+
+      const content = matter.stringify(generated.systemPrompt, frontmatter)
+      const filePath = path.join(
+        scope === "global" ? Global.Path.config : path.join(app.path.root, ".opencode"),
+        `agent`,
+        `${generated.identifier}.md`,
+      )
+
+      await Bun.write(filePath, content)
+
+      prompts.log.success(`Agent created: ${filePath}`)
+      prompts.outro("Done")
+    })
+  },
+})
+
+export const AgentCommand = cmd({
+  command: "agent",
+  describe: "manage agents",
+  builder: (yargs) => yargs.command(AgentCreateCommand).demandCommand(),
+  async handler() {},
+})
@@ -1,80 +1,33 @@
-import { Session } from "../../../session"
 import { Snapshot } from "../../../snapshot"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"

 export const SnapshotCommand = cmd({
  command: "snapshot",
-  builder: (yargs) =>
-    yargs.command(CreateCommand).command(RestoreCommand).command(DiffCommand).command(RevertCommand).demandCommand(),
+  builder: (yargs) => yargs.command(TrackCommand).command(PatchCommand).demandCommand(),
  async handler() {},
 })

-const CreateCommand = cmd({
-  command: "create",
+const TrackCommand = cmd({
+  command: "track",
  async handler() {
    await bootstrap({ cwd: process.cwd() }, async () => {
-      const result = await Snapshot.create()
-      console.log(result)
+      console.log(await Snapshot.track())
    })
  },
 })

-const RestoreCommand = cmd({
-  command: "restore <commit>",
+const PatchCommand = cmd({
+  command: "patch <hash>",
  builder: (yargs) =>
-    yargs.positional("commit", {
+    yargs.positional("hash", {
      type: "string",
-      description: "commit",
+      description: "hash",
      demandOption: true,
    }),
  async handler(args) {
    await bootstrap({ cwd: process.cwd() }, async () => {
-      await Snapshot.restore(args.commit)
-      console.log("restored")
-    })
-  },
-})
-
-export const DiffCommand = cmd({
-  command: "diff <commit>",
-  describe: "diff",
-  builder: (yargs) =>
-    yargs.positional("commit", {
-      type: "string",
-      description: "commit",
-      demandOption: true,
-    }),
-  async handler(args) {
-    await bootstrap({ cwd: process.cwd() }, async () => {
-      const diff = await Snapshot.diff(args.commit)
-      console.log(diff)
-    })
-  },
-})
-
-export const RevertCommand = cmd({
-  command: "revert <sessionID> <messageID>",
-  describe: "revert",
-  builder: (yargs) =>
-    yargs
-      .positional("sessionID", {
-        type: "string",
-        description: "sessionID",
-        demandOption: true,
-      })
-      .positional("messageID", {
-        type: "string",
-        description: "messageID",
-        demandOption: true,
-      }),
-  async handler(args) {
-    await bootstrap({ cwd: process.cwd() }, async () => {
-      const session = await Session.revert({
-        sessionID: args.sessionID,
-        messageID: args.messageID,
-      })
-      console.log(session?.revert)
+      console.log(await Snapshot.patch(args.hash))
    })
  },
 })
@@ -9,6 +9,7 @@ import { Global } from "../global"
 import fs from "fs/promises"
 import { lazy } from "../util/lazy"
 import { NamedError } from "../util/error"
+import matter from "gray-matter"

 export namespace Config {
  const log = Log.create({ service: "config" })
@@ -22,6 +23,31 @@ export namespace Config {
      }
    }

+    result.agent = result.agent || {}
+    const markdownAgents = [
+      ...(await Filesystem.globUp("agent/*.md", Global.Path.config, Global.Path.config)),
+      ...(await Filesystem.globUp(".opencode/agent/*.md", app.path.cwd, app.path.root)),
+    ]
+    for (const item of markdownAgents) {
+      const content = await Bun.file(item).text()
+      const md = matter(content)
+      if (!md.data) continue
+
+      const config = {
+        name: path.basename(item, ".md"),
+        ...md.data,
+        prompt: md.content.trim(),
+      }
+      const parsed = Agent.safeParse(config)
+      if (parsed.success) {
+        result.agent = mergeDeep(result.agent, {
+          [config.name]: parsed.data,
+        })
+        continue
+      }
+      throw new InvalidError({ path: item }, { cause: parsed.error })
+    }
+
    // Handle migration from autoshare to share field
    if (result.autoshare === true && !result.share) {
      result.share = "auto"
@@ -73,14 +99,22 @@ export namespace Config {
  export const Mode = z
    .object({
      model: z.string().optional(),
+      temperature: z.number().optional(),
      prompt: z.string().optional(),
      tools: z.record(z.string(), z.boolean()).optional(),
+      disable: z.boolean().optional(),
    })
    .openapi({
      ref: "ModeConfig",
    })
  export type Mode = z.infer<typeof Mode>

+  export const Agent = Mode.extend({
+    description: z.string(),
+  }).openapi({
+    ref: "AgentConfig",
+  })
+
  export const Keybinds = z
    .object({
      leader: z.string().optional().default("ctrl+x").describe("Leader key for keybind combinations"),
@@ -172,6 +206,13 @@ export namespace Config {
        .catchall(Mode)
        .optional()
        .describe("Modes configuration, see https://opencode.ai/docs/modes"),
+      agent: z
+        .object({
+          general: Agent.optional(),
+        })
+        .catchall(Agent)
+        .optional()
+        .describe("Modes configuration, see https://opencode.ai/docs/modes"),
      provider: z
        .record(
          ModelsDev.Provider.partial()
@@ -5,6 +5,7 @@ import { z } from "zod"
 import { NamedError } from "../util/error"
 import { lazy } from "../util/lazy"
 import { Log } from "../util/log"
+import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"

 export namespace Fzf {
  const log = Log.create({ service: "fzf" })
@@ -45,7 +46,10 @@ export namespace Fzf {
      log.info("found", { filepath })
      return { filepath }
    }
-    filepath = path.join(Global.Path.bin, "fzf" + (process.platform === "win32" ? ".exe" : ""))
+    filepath = path.join(
+      Global.Path.bin,
+      "fzf" + (process.platform === "win32" ? ".exe" : ""),
+    )

    const file = Bun.file(filepath)
    if (!(await file.exists())) {
@@ -53,15 +57,18 @@ export namespace Fzf {
      const arch = archMap[process.arch as keyof typeof archMap] ?? "amd64"

      const config = PLATFORM[process.platform as keyof typeof PLATFORM]
-      if (!config) throw new UnsupportedPlatformError({ platform: process.platform })
+      if (!config)
+        throw new UnsupportedPlatformError({ platform: process.platform })

      const version = VERSION
-      const platformName = process.platform === "win32" ? "windows" : process.platform
+      const platformName =
+        process.platform === "win32" ? "windows" : process.platform
      const filename = `fzf-${version}-${platformName}_${arch}.${config.extension}`
      const url = `https://github.com/junegunn/fzf/releases/download/v${version}/${filename}`

      const response = await fetch(url)
-      if (!response.ok) throw new DownloadFailedError({ url, status: response.status })
+      if (!response.ok)
+        throw new DownloadFailedError({ url, status: response.status })

      const buffer = await response.arrayBuffer()
      const archivePath = path.join(Global.Path.bin, filename)
@@ -80,17 +87,32 @@ export namespace Fzf {
          })
      }
      if (config.extension === "zip") {
-        const proc = Bun.spawn(["unzip", "-j", archivePath, "fzf.exe", "-d", Global.Path.bin], {
-          cwd: Global.Path.bin,
-          stderr: "pipe",
-          stdout: "ignore",
-        })
-        await proc.exited
-        if (proc.exitCode !== 0)
+        const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])));
+        const entries = await zipFileReader.getEntries();
+        let fzfEntry: any;
+        for (const entry of entries) {
+          if (entry.filename === "fzf.exe") {
+            fzfEntry = entry;
+            break;
+          }
+        }
+
+        if (!fzfEntry) {
          throw new ExtractionFailedError({
            filepath: archivePath,
-            stderr: await Bun.readableStreamToText(proc.stderr),
-          })
+            stderr: "fzf.exe not found in zip archive",
+          });
+        }
+
+        const fzfBlob = await fzfEntry.getData(new BlobWriter());
+        if (!fzfBlob) {
+          throw new ExtractionFailedError({
+            filepath: archivePath,
+            stderr: "Failed to extract fzf.exe from zip archive",
+          });
+        }
+        await Bun.write(filepath, await fzfBlob.arrayBuffer());
+        await zipFileReader.close();
      }
      await fs.unlink(archivePath)
      if (process.platform !== "win32") await fs.chmod(filepath, 0o755)
@@ -105,4 +127,4 @@ export namespace Fzf {
    const { filepath } = await state()
    return filepath
  }
-}
+}
@@ -7,6 +7,7 @@ import { NamedError } from "../util/error"
 import { lazy } from "../util/lazy"
 import { $ } from "bun"
 import { Fzf } from "./fzf"
+import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"

 export namespace Ripgrep {
  const Stats = z.object({
@@ -34,27 +35,25 @@ export namespace Ripgrep {

  export const Match = z.object({
    type: z.literal("match"),
-    data: z
-      .object({
-        path: z.object({
-          text: z.string(),
-        }),
-        lines: z.object({
-          text: z.string(),
-        }),
-        line_number: z.number(),
-        absolute_offset: z.number(),
-        submatches: z.array(
-          z.object({
-            match: z.object({
-              text: z.string(),
-            }),
-            start: z.number(),
-            end: z.number(),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+      lines: z.object({
+        text: z.string(),
+      }),
+      line_number: z.number(),
+      absolute_offset: z.number(),
+      submatches: z.array(
+        z.object({
+          match: z.object({
+            text: z.string(),
          }),
-        ),
-      })
-      .openapi({ ref: "Match" }),
+          start: z.number(),
+          end: z.number(),
+        }),
+      ),
+    }),
  })

  const End = z.object({
@@ -161,17 +160,34 @@ export namespace Ripgrep {
          })
      }
      if (config.extension === "zip") {
-        const proc = Bun.spawn(["unzip", "-j", archivePath, "*/rg.exe", "-d", Global.Path.bin], {
-          cwd: Global.Path.bin,
-          stderr: "pipe",
-          stdout: "ignore",
-        })
-        await proc.exited
-        if (proc.exitCode !== 0)
-          throw new ExtractionFailedError({
-            filepath: archivePath,
-            stderr: await Bun.readableStreamToText(proc.stderr),
-          })
+        if (config.extension === "zip") {
+          const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])))
+          const entries = await zipFileReader.getEntries()
+          let rgEntry: any
+          for (const entry of entries) {
+            if (entry.filename.endsWith("rg.exe")) {
+              rgEntry = entry
+              break
+            }
+          }
+
+          if (!rgEntry) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "rg.exe not found in zip archive",
+            })
+          }
+
+          const rgBlob = await rgEntry.getData(new BlobWriter())
+          if (!rgBlob) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "Failed to extract rg.exe from zip archive",
+            })
+          }
+          await Bun.write(filepath, await rgBlob.arrayBuffer())
+          await zipFileReader.close()
+        }
      }
      await fs.unlink(archivePath)
      if (!platformKey.endsWith("-win32")) await fs.chmod(filepath, 0o755)
@@ -233,6 +249,7 @@ export namespace Ripgrep {
      children: [],
    }
    for (const file of files) {
+      if (file.includes(".opencode")) continue
      const parts = file.split(path.sep)
      getPath(root, parts, true)
    }
@@ -5,6 +5,7 @@ import { RunCommand } from "./cli/cmd/run"
 import { GenerateCommand } from "./cli/cmd/generate"
 import { Log } from "./util/log"
 import { AuthCommand } from "./cli/cmd/auth"
+import { AgentCommand } from "./cli/cmd/agent"
 import { UpgradeCommand } from "./cli/cmd/upgrade"
 import { ModelsCommand } from "./cli/cmd/models"
 import { UI } from "./cli/ui"
@@ -72,6 +73,7 @@ const cli = yargs(hideBin(process.argv))
  .command(GenerateCommand)
  .command(DebugCommand)
  .command(AuthCommand)
+  .command(AgentCommand)
  .command(UpgradeCommand)
  .command(ServeCommand)
  .command(ModelsCommand)
@@ -322,4 +322,43 @@ export namespace LSPServer {
      }
    },
  }
+
+  export const CSharp: Info = {
+    id: "csharp",
+    root: NearestRoot([".sln", ".csproj", "global.json"]),
+    extensions: [".cs"],
+    async spawn(_, root) {
+      let bin = Bun.which("csharp-ls", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+      if (!bin) {
+        if (!Bun.which("dotnet")) {
+          log.error(".NET SDK is required to install csharp-ls")
+          return
+        }
+
+        log.info("installing csharp-ls via dotnet tool")
+        const proc = Bun.spawn({
+          cmd: ["dotnet", "tool", "install", "csharp-ls", "--tool-path", Global.Path.bin],
+          stdout: "pipe",
+          stderr: "pipe",
+          stdin: "pipe",
+        })
+        const exit = await proc.exited
+        if (exit !== 0) {
+          log.error("Failed to install csharp-ls")
+          return
+        }
+
+        bin = path.join(Global.Path.bin, "csharp-ls" + (process.platform === "win32" ? ".exe" : ""))
+        log.info(`installed csharp-ls`, { bin })
+      }
+
+      return {
+        process: spawn(bin, {
+          cwd: root,
+        }),
+      }
+    },
+  }
 }
@@ -5,23 +5,11 @@ import { mergeDeep, sortBy } from "remeda"
 import { NoSuchModelError, type LanguageModel, type Provider as SDK } from "ai"
 import { Log } from "../util/log"
 import { BunProc } from "../bun"
-import { BashTool } from "../tool/bash"
-import { EditTool } from "../tool/edit"
-import { WebFetchTool } from "../tool/webfetch"
-import { GlobTool } from "../tool/glob"
-import { GrepTool } from "../tool/grep"
-import { ListTool } from "../tool/ls"
-import { PatchTool } from "../tool/patch"
-import { ReadTool } from "../tool/read"
-import type { Tool } from "../tool/tool"
-import { WriteTool } from "../tool/write"
-import { TodoReadTool, TodoWriteTool } from "../tool/todo"
 import { AuthAnthropic } from "../auth/anthropic"
 import { AuthCopilot } from "../auth/copilot"
 import { ModelsDev } from "./models"
 import { NamedError } from "../util/error"
 import { Auth } from "../auth"
-import { TaskTool } from "../tool/task"

 export namespace Provider {
  const log = Log.create({ service: "provider" })
@@ -469,139 +457,6 @@ export namespace Provider {
    }
  }

-  const TOOLS = [
-    BashTool,
-    EditTool,
-    WebFetchTool,
-    GlobTool,
-    GrepTool,
-    ListTool,
-    // LspDiagnosticTool,
-    // LspHoverTool,
-    PatchTool,
-    ReadTool,
-    // MultiEditTool,
-    WriteTool,
-    TodoWriteTool,
-    TodoReadTool,
-    TaskTool,
-  ]
-
-  const TOOL_MAPPING: Record<string, Tool.Info[]> = {
-    anthropic: TOOLS.filter((t) => t.id !== "patch"),
-    openai: TOOLS.map((t) => ({
-      ...t,
-      parameters: optionalToNullable(t.parameters),
-    })),
-    azure: TOOLS.map((t) => ({
-      ...t,
-      parameters: optionalToNullable(t.parameters),
-    })),
-    google: TOOLS.map((t) => ({
-      ...t,
-      parameters: sanitizeGeminiParameters(t.parameters),
-    })),
-  }
-
-  export async function tools(providerID: string) {
-    /*
-    const cfg = await Config.get()
-    if (cfg.tool?.provider?.[providerID])
-      return cfg.tool.provider[providerID].map(
-        (id) => TOOLS.find((t) => t.id === id)!,
-      )
-        */
-    return TOOL_MAPPING[providerID] ?? TOOLS
-  }
-
-  function sanitizeGeminiParameters(schema: z.ZodTypeAny, visited = new Set()): z.ZodTypeAny {
-    if (!schema || visited.has(schema)) {
-      return schema
-    }
-    visited.add(schema)
-
-    if (schema instanceof z.ZodDefault) {
-      const innerSchema = schema.removeDefault()
-      // Handle Gemini's incompatibility with `default` on `anyOf` (unions).
-      if (innerSchema instanceof z.ZodUnion) {
-        // The schema was `z.union(...).default(...)`, which is not allowed.
-        // We strip the default and return the sanitized union.
-        return sanitizeGeminiParameters(innerSchema, visited)
-      }
-      // Otherwise, the default is on a regular type, which is allowed.
-      // We recurse on the inner type and then re-apply the default.
-      return sanitizeGeminiParameters(innerSchema, visited).default(schema._def.defaultValue())
-    }
-
-    if (schema instanceof z.ZodOptional) {
-      return z.optional(sanitizeGeminiParameters(schema.unwrap(), visited))
-    }
-
-    if (schema instanceof z.ZodObject) {
-      const newShape: Record<string, z.ZodTypeAny> = {}
-      for (const [key, value] of Object.entries(schema.shape)) {
-        newShape[key] = sanitizeGeminiParameters(value as z.ZodTypeAny, visited)
-      }
-      return z.object(newShape)
-    }
-
-    if (schema instanceof z.ZodArray) {
-      return z.array(sanitizeGeminiParameters(schema.element, visited))
-    }
-
-    if (schema instanceof z.ZodUnion) {
-      // This schema corresponds to `anyOf` in JSON Schema.
-      // We recursively sanitize each option in the union.
-      const sanitizedOptions = schema.options.map((option: z.ZodTypeAny) => sanitizeGeminiParameters(option, visited))
-      return z.union(sanitizedOptions as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]])
-    }
-
-    if (schema instanceof z.ZodString) {
-      const newSchema = z.string({ description: schema.description })
-      const safeChecks = ["min", "max", "length", "regex", "startsWith", "endsWith", "includes", "trim"]
-      // rome-ignore lint/suspicious/noExplicitAny: <explanation>
-      ;(newSchema._def as any).checks = (schema._def as z.ZodStringDef).checks.filter((check) =>
-        safeChecks.includes(check.kind),
-      )
-      return newSchema
-    }
-
-    return schema
-  }
-  function optionalToNullable(schema: z.ZodTypeAny): z.ZodTypeAny {
-    if (schema instanceof z.ZodObject) {
-      const shape = schema.shape
-      const newShape: Record<string, z.ZodTypeAny> = {}
-
-      for (const [key, value] of Object.entries(shape)) {
-        const zodValue = value as z.ZodTypeAny
-        if (zodValue instanceof z.ZodOptional) {
-          newShape[key] = zodValue.unwrap().nullable()
-        } else {
-          newShape[key] = optionalToNullable(zodValue)
-        }
-      }
-
-      return z.object(newShape)
-    }
-
-    if (schema instanceof z.ZodArray) {
-      return z.array(optionalToNullable(schema.element))
-    }
-
-    if (schema instanceof z.ZodUnion) {
-      return z.union(
-        schema.options.map((option: z.ZodTypeAny) => optionalToNullable(option)) as [
-          z.ZodTypeAny,
-          z.ZodTypeAny,
-          ...z.ZodTypeAny[],
-        ],
-      )
-    }
-
-    return schema
-  }
-
  export const ModelNotFoundError = NamedError.create(
    "ProviderModelNotFoundError",
    z.object({
@@ -7,24 +7,46 @@ export namespace ProviderTransform {
      const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)
      const final = msgs.filter((msg) => msg.role !== "system").slice(-2)

+      const providerOptions = {
+        anthropic: {
+          cacheControl: { type: "ephemeral" },
+        },
+        openrouter: {
+          cache_control: { type: "ephemeral" },
+        },
+        bedrock: {
+          cachePoint: { type: "ephemeral" },
+        },
+        openaiCompatible: {
+          cache_control: { type: "ephemeral" },
+        },
+      }
+
      for (const msg of unique([...system, ...final])) {
+        const shouldUseContentOptions = providerID !== "anthropic" && Array.isArray(msg.content) && msg.content.length > 0
+        
+        if (shouldUseContentOptions) {
+          const lastContent = msg.content[msg.content.length - 1]
+          if (lastContent && typeof lastContent === "object") {
+            lastContent.providerOptions = {
+              ...lastContent.providerOptions,
+              ...providerOptions,
+            }
+            continue
+          }
+        }
+        
        msg.providerOptions = {
          ...msg.providerOptions,
-          anthropic: {
-            cacheControl: { type: "ephemeral" },
-          },
-          openrouter: {
-            cache_control: { type: "ephemeral" },
-          },
-          bedrock: {
-            cachePoint: { type: "ephemeral" },
-          },
-          openaiCompatible: {
-            cache_control: { type: "ephemeral" },
-          },
+          ...providerOptions,
        }
      }
    }
    return msgs
  }
+
+  export function temperature(_providerID: string, modelID: string) {
+    if (modelID.includes("qwen")) return 0.55
+    return 0
+  }
 }
@@ -17,7 +17,6 @@ import {

 import PROMPT_INITIALIZE from "../session/prompt/initialize.txt"
 import PROMPT_PLAN from "../session/prompt/plan.txt"
-import PROMPT_ANTHROPIC_SPOOF from "../session/prompt/anthropic_spoof.txt"

 import { App } from "../app/app"
 import { Bus } from "../bus"
@@ -40,7 +39,8 @@ import { MessageV2 } from "./message-v2"
 import { Mode } from "./mode"
 import { LSP } from "../lsp"
 import { ReadTool } from "../tool/read"
-import { splitWhen } from "remeda"
+import { mergeDeep, pipe, splitWhen } from "remeda"
+import { ToolRegistry } from "../tool/registry"

 export namespace Session {
  const log = Log.create({ service: "session" })
@@ -337,6 +337,7 @@ export namespace Session {
    providerID: z.string(),
    modelID: z.string(),
    mode: z.string().optional(),
+    system: z.string().optional(),
    tools: z.record(z.boolean()).optional(),
    parts: z.array(
      z.discriminatedUnion("type", [
@@ -387,6 +388,34 @@ export namespace Session {
        if (part.type === "file") {
          const url = new URL(part.url)
          switch (url.protocol) {
+            case "data:":
+              if (part.mime === "text/plain") {
+                return [
+                  {
+                    id: Identifier.ascending("part"),
+                    messageID: userMsg.id,
+                    sessionID: input.sessionID,
+                    type: "text",
+                    synthetic: true,
+                    text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: part.filename })}`,
+                  },
+                  {
+                    id: Identifier.ascending("part"),
+                    messageID: userMsg.id,
+                    sessionID: input.sessionID,
+                    type: "text",
+                    synthetic: true,
+                    text: Buffer.from(part.url, "base64url").toString(),
+                  },
+                  {
+                    ...part,
+                    id: part.id ?? Identifier.ascending("part"),
+                    messageID: userMsg.id,
+                    sessionID: input.sessionID,
+                  },
+                ]
+              }
+              break
            case "file:":
              // have to normalize, symbol search returns absolute paths
              // Decode the pathname since URL constructor doesn't automatically decode it
@@ -430,12 +459,14 @@ export namespace Session {
                  }
                }
                const args = { filePath, offset, limit }
-                const result = await ReadTool.execute(args, {
-                  sessionID: input.sessionID,
-                  abort: new AbortController().signal,
-                  messageID: userMsg.id,
-                  metadata: async () => {},
-                })
+                const result = await ReadTool.init().then((t) =>
+                  t.execute(args, {
+                    sessionID: input.sessionID,
+                    abort: new AbortController().signal,
+                    messageID: userMsg.id,
+                    metadata: async () => {},
+                  }),
+                )
                return [
                  {
                    id: Identifier.ascending("part"),
@@ -616,8 +647,14 @@ export namespace Session {
    }

    const mode = await Mode.get(inputMode)
-    let system = input.providerID === "anthropic" ? [PROMPT_ANTHROPIC_SPOOF.trim()] : []
-    system.push(...(mode.prompt ? [mode.prompt] : SystemPrompt.provider(input.modelID)))
+    let system = SystemPrompt.header(input.providerID)
+    system.push(
+      ...(() => {
+        if (input.system) return [input.system]
+        if (mode.prompt) return [mode.prompt]
+        return SystemPrompt.provider(input.modelID)
+      })(),
+    )
    system.push(...(await SystemPrompt.environment()))
    system.push(...(await SystemPrompt.custom()))
    // max 2 system prompt messages for caching purposes
@@ -652,15 +689,19 @@ export namespace Session {

    const processor = createProcessor(assistantMsg, model.info)

-    for (const item of await Provider.tools(input.providerID)) {
-      if (mode.tools[item.id] === false) continue
-      if (input.tools?.[item.id] === false) continue
-      if (session.parentID && item.id === "task") continue
+    const enabledTools = pipe(
+      mode.tools,
+      mergeDeep(ToolRegistry.enabled(input.providerID, input.modelID)),
+      mergeDeep(input.tools ?? {}),
+    )
+    for (const item of await ToolRegistry.tools(input.providerID, input.modelID)) {
+      if (enabledTools[item.id] === false) continue
      tools[item.id] = tool({
        id: item.id as any,
        description: item.description,
        inputSchema: item.parameters as ZodSchema,
        async execute(args, options) {
+          await processor.track(options.toolCallId)
          const result = await item.execute(args, {
            sessionID: input.sessionID,
            abort: abort.signal,
@@ -699,6 +740,7 @@ export namespace Session {
      const execute = item.execute
      if (!execute) continue
      item.execute = async (args, opts) => {
+        await processor.track(opts.toolCallId)
        const result = await execute(args, opts)
        const output = result.content
          .filter((x: any) => x.type === "text")
@@ -754,6 +796,7 @@ export namespace Session {
            },
            modelID: input.modelID,
            providerID: input.providerID,
+            mode: inputMode,
            time: {
              created: Date.now(),
            },
@@ -781,7 +824,9 @@ export namespace Session {
        ),
        ...MessageV2.toModelMessage(msgs),
      ],
-      temperature: model.info.temperature ? 0 : undefined,
+      temperature: model.info.temperature
+        ? (mode.temperature ?? ProviderTransform.temperature(input.providerID, input.modelID))
+        : undefined,
      tools: model.info.tool_call === false ? undefined : tools,
      model: wrapLanguageModel({
        model: model.language,
@@ -814,7 +859,12 @@ export namespace Session {

  function createProcessor(assistantMsg: MessageV2.Assistant, model: ModelsDev.Model) {
    const toolCalls: Record<string, MessageV2.ToolPart> = {}
+    const snapshots: Record<string, string> = {}
    return {
+      async track(toolCallID: string) {
+        const hash = await Snapshot.track()
+        if (hash) snapshots[toolCallID] = hash
+      },
      partFromToolCall(toolCallID: string) {
        return toolCalls[toolCallID]
      },
@@ -828,15 +878,6 @@ export namespace Session {
            })
            switch (value.type) {
              case "start":
-                const snapshot = await Snapshot.create()
-                if (snapshot)
-                  await updatePart({
-                    id: Identifier.ascending("part"),
-                    messageID: assistantMsg.id,
-                    sessionID: assistantMsg.sessionID,
-                    type: "snapshot",
-                    snapshot,
-                  })
                break

              case "tool-input-start":
@@ -857,6 +898,9 @@ export namespace Session {
              case "tool-input-delta":
                break

+              case "tool-input-end":
+                break
+
              case "tool-call": {
                const match = toolCalls[value.toolCallId]
                if (match) {
@@ -892,15 +936,20 @@ export namespace Session {
                    },
                  })
                  delete toolCalls[value.toolCallId]
-                  const snapshot = await Snapshot.create()
-                  if (snapshot)
-                    await updatePart({
-                      id: Identifier.ascending("part"),
-                      messageID: assistantMsg.id,
-                      sessionID: assistantMsg.sessionID,
-                      type: "snapshot",
-                      snapshot,
-                    })
+                  const snapshot = snapshots[value.toolCallId]
+                  if (snapshot) {
+                    const patch = await Snapshot.patch(snapshot)
+                    if (patch.files.length) {
+                      await updatePart({
+                        id: Identifier.ascending("part"),
+                        messageID: assistantMsg.id,
+                        sessionID: assistantMsg.sessionID,
+                        type: "patch",
+                        hash: patch.hash,
+                        files: patch.files,
+                      })
+                    }
+                  }
                }
                break
              }
@@ -921,15 +970,18 @@ export namespace Session {
                    },
                  })
                  delete toolCalls[value.toolCallId]
-                  const snapshot = await Snapshot.create()
-                  if (snapshot)
+                  const snapshot = snapshots[value.toolCallId]
+                  if (snapshot) {
+                    const patch = await Snapshot.patch(snapshot)
                    await updatePart({
                      id: Identifier.ascending("part"),
                      messageID: assistantMsg.id,
                      sessionID: assistantMsg.sessionID,
-                      type: "snapshot",
-                      snapshot,
+                      type: "patch",
+                      hash: patch.hash,
+                      files: patch.files,
                    })
+                  }
                }
                break
              }
@@ -987,6 +1039,7 @@ export namespace Session {
                    start: Date.now(),
                    end: Date.now(),
                  }
+                  currentText.text = currentText.text.trimEnd()
                  await updatePart(currentText)
                }
                currentText = undefined
@@ -1073,33 +1126,45 @@ export namespace Session {

  export async function revert(input: RevertInput) {
    const all = await messages(input.sessionID)
-    const session = await get(input.sessionID)
    let lastUser: MessageV2.User | undefined
-    let lastSnapshot: MessageV2.SnapshotPart | undefined
+    const session = await get(input.sessionID)
+
+    let revert: Info["revert"]
+    const patches: Snapshot.Patch[] = []
    for (const msg of all) {
      if (msg.info.role === "user") lastUser = msg.info
      const remaining = []
      for (const part of msg.parts) {
-        if (part.type === "snapshot") lastSnapshot = part
-        if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
-          // if no useful parts left in message, same as reverting whole message
-          const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
-          const snapshot = session.revert?.snapshot ?? (await Snapshot.create())
-          log.info("revert snapshot", { snapshot })
-          if (lastSnapshot) await Snapshot.restore(lastSnapshot.snapshot)
-          const next = await update(input.sessionID, (draft) => {
-            draft.revert = {
-              // if not part id jump to the last user message
+        if (revert) {
+          if (part.type === "patch") {
+            patches.push(part)
+          }
+          continue
+        }
+
+        if (!revert) {
+          if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+            // if no useful parts left in message, same as reverting whole message
+            const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+            revert = {
              messageID: !partID && lastUser ? lastUser.id : msg.info.id,
              partID,
-              snapshot,
            }
-          })
-          return next
+          }
+          remaining.push(part)
        }
-        remaining.push(part)
      }
    }
+
+    if (revert) {
+      const session = await get(input.sessionID)
+      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
+      await Snapshot.revert(patches)
+      return update(input.sessionID, (draft) => {
+        draft.revert = revert
+      })
+    }
+    return session
  }

  export async function unrevert(input: { sessionID: string }) {
@@ -1120,7 +1185,11 @@ export namespace Session {
    const filtered = msgs.filter((msg) => !lastSummary || msg.info.id >= lastSummary.info.id)
    const model = await Provider.getModel(input.providerID, input.modelID)
    const app = App.info()
-    const system = SystemPrompt.summarize(input.providerID)
+    const system = [
+      ...SystemPrompt.summarize(input.providerID),
+      ...(await SystemPrompt.environment()),
+      ...(await SystemPrompt.custom()),
+    ]

    const next: MessageV2.Info = {
      id: Identifier.ascending("message"),
@@ -94,6 +94,15 @@ export namespace MessageV2 {
  })
  export type SnapshotPart = z.infer<typeof SnapshotPart>

+  export const PatchPart = PartBase.extend({
+    type: z.literal("patch"),
+    hash: z.string(),
+    files: z.string().array(),
+  }).openapi({
+    ref: "PatchPart",
+  })
+  export type PatchPart = z.infer<typeof PatchPart>
+
  export const TextPart = PartBase.extend({
    type: z.literal("text"),
    text: z.string(),
@@ -203,7 +212,7 @@ export namespace MessageV2 {
  export type User = z.infer<typeof User>

  export const Part = z
-    .discriminatedUnion("type", [TextPart, FilePart, ToolPart, StepStartPart, StepFinishPart, SnapshotPart])
+    .discriminatedUnion("type", [TextPart, FilePart, ToolPart, StepStartPart, StepFinishPart, SnapshotPart, PatchPart])
    .openapi({
      ref: "Part",
    })
@@ -1,12 +1,13 @@
-import { mergeDeep } from "remeda"
 import { App } from "../app/app"
 import { Config } from "../config/config"
 import z from "zod"
+import { Provider } from "../provider/provider"

 export namespace Mode {
  export const Info = z
    .object({
      name: z.string(),
+      temperature: z.number().optional(),
      model: z
        .object({
          modelID: z.string(),
@@ -22,38 +23,40 @@ export namespace Mode {
  export type Info = z.infer<typeof Info>
  const state = App.state("mode", async () => {
    const cfg = await Config.get()
-    const mode = mergeDeep(
-      {
-        build: {},
-        plan: {
-          tools: {
-            write: false,
-            edit: false,
-            patch: false,
-          },
+    const model = cfg.model ? Provider.parseModel(cfg.model) : undefined
+    const result: Record<string, Info> = {
+      build: {
+        model,
+        name: "build",
+        tools: {},
+      },
+      plan: {
+        name: "plan",
+        model,
+        tools: {
+          write: false,
+          edit: false,
+          patch: false,
        },
      },
-      cfg.mode ?? {},
-    )
-    const result: Record<string, Info> = {}
-    for (const [key, value] of Object.entries(mode)) {
+    }
+    for (const [key, value] of Object.entries(cfg.mode ?? {})) {
+      if (value.disable) continue
      let item = result[key]
      if (!item)
        item = result[key] = {
          name: key,
          tools: {},
        }
-      const model = value.model ?? cfg.model
-      if (model) {
-        const [providerID, ...rest] = model.split("/")
-        const modelID = rest.join("/")
-        item.model = {
-          modelID,
-          providerID,
-        }
-      }
+      item.name = key
+      if (value.model) item.model = Provider.parseModel(value.model)
      if (value.prompt) item.prompt = value.prompt
-      if (value.tools) item.tools = value.tools
+      if (value.temperature) item.temperature = value.temperature
+      if (value.tools)
+        item.tools = {
+          ...value.tools,
+          ...item.tools,
+        }
    }

    return result
@@ -14,6 +14,10 @@ import PROMPT_SUMMARIZE from "./prompt/summarize.txt"
 import PROMPT_TITLE from "./prompt/title.txt"

 export namespace SystemPrompt {
+  export function header(providerID: string) {
+    if (providerID.includes("anthropic")) return [PROMPT_ANTHROPIC_SPOOF.trim()]
+    return []
+  }
  export function provider(modelID: string) {
    if (modelID.includes("gpt-") || modelID.includes("o1") || modelID.includes("o3")) return [PROMPT_BEAST]
    if (modelID.includes("gemini-")) return [PROMPT_GEMINI]
@@ -2,10 +2,9 @@ import { App } from "../app/app"
 import { $ } from "bun"
 import path from "path"
 import fs from "fs/promises"
-import { Ripgrep } from "../file/ripgrep"
 import { Log } from "../util/log"
 import { Global } from "../global"
-import { Installation } from "../installation"
+import { z } from "zod"

 export namespace Snapshot {
  const log = Log.create({ service: "snapshot" })
@@ -24,21 +23,9 @@ export namespace Snapshot {
    })
  }

-  export async function create() {
-    log.info("creating snapshot")
+  export async function track() {
    const app = App.info()
-
-    // not a git repo, check if too big to snapshot
-    if (!app.git || !Installation.isDev()) {
-      return
-      const files = await Ripgrep.files({
-        cwd: app.path.cwd,
-        limit: 1000,
-      })
-      log.info("found files", { count: files.length })
-      if (files.length >= 1000) return
-    }
-
+    if (!app.git) return
    const git = gitdir()
    if (await fs.mkdir(git, { recursive: true })) {
      await $`git init`
@@ -51,33 +38,60 @@ export namespace Snapshot {
        .nothrow()
      log.info("initialized")
    }
-
    await $`git --git-dir ${git} add .`.quiet().cwd(app.path.cwd).nothrow()
-    log.info("added files")
+    const hash = await $`git --git-dir ${git} write-tree`.quiet().cwd(app.path.cwd).text()
+    return hash.trim()
+  }

-    const result =
-      await $`git --git-dir ${git} commit --allow-empty -m "snapshot" --no-gpg-sign --author="opencode <mail@opencode.ai>"`
-        .quiet()
-        .cwd(app.path.cwd)
-        .nothrow()
+  export const Patch = z.object({
+    hash: z.string(),
+    files: z.string().array(),
+  })
+  export type Patch = z.infer<typeof Patch>

-    const match = result.stdout.toString().match(/\[.+ ([a-f0-9]+)\]/)
-    if (!match) return
-    return match![1]
+  export async function patch(hash: string): Promise<Patch> {
+    const app = App.info()
+    const git = gitdir()
+    await $`git --git-dir ${git} add .`.quiet().cwd(app.path.cwd).nothrow()
+    const files = await $`git --git-dir ${git} diff --name-only ${hash} -- .`.cwd(app.path.cwd).text()
+    return {
+      hash,
+      files: files
+        .trim()
+        .split("\n")
+        .map((x) => x.trim())
+        .filter(Boolean)
+        .map((x) => path.join(app.path.cwd, x)),
+    }
  }

  export async function restore(snapshot: string) {
    log.info("restore", { commit: snapshot })
    const app = App.info()
    const git = gitdir()
-    await $`git --git-dir=${git} reset --hard ${snapshot}`.quiet().cwd(app.path.root)
+    await $`git --git-dir=${git} read-tree ${snapshot} && git --git-dir=${git} checkout-index -a -f`
+      .quiet()
+      .cwd(app.path.root)
  }

-  export async function diff(commit: string) {
+  export async function revert(patches: Patch[]) {
+    const files = new Set<string>()
    const git = gitdir()
-    const result = await $`git --git-dir=${git} diff -R ${commit}`.quiet().cwd(App.info().path.root)
-    const text = result.stdout.toString("utf8")
-    return text
+    for (const item of patches) {
+      for (const file of item.files) {
+        if (files.has(file)) continue
+        log.info("reverting", { file, hash: item.hash })
+        const result = await $`git --git-dir=${git} checkout ${item.hash} -- ${file}`
+          .quiet()
+          .cwd(App.info().path.root)
+          .nothrow()
+        if (result.exitCode !== 0) {
+          log.info("file not found in history, deleting", { file })
+          await fs.unlink(file).catch(() => {})
+        }
+        files.add(file)
+      }
+    }
  }

  function gitdir() {
@@ -7,8 +7,7 @@ const MAX_OUTPUT_LENGTH = 30000
 const DEFAULT_TIMEOUT = 1 * 60 * 1000
 const MAX_TIMEOUT = 10 * 60 * 1000

-export const BashTool = Tool.define({
-  id: "bash",
+export const BashTool = Tool.define("bash", {
  description: DESCRIPTION,
  parameters: z.object({
    command: z.string().describe("The command to execute"),
@@ -1,7 +1,7 @@
 // the approaches in this edit tool are sourced from
 // https://github.com/cline/cline/blob/main/evals/diff-edits/diff-apply/diff-06-23-25.ts
 // https://github.com/google-gemini/gemini-cli/blob/main/packages/core/src/utils/editCorrector.ts
-
+// https://github.com/cline/cline/blob/main/evals/diff-edits/diff-apply/diff-06-26-25.ts
 import { z } from "zod"
 import * as path from "path"
 import { Tool } from "./tool"
@@ -14,8 +14,7 @@ import { File } from "../file"
 import { Bus } from "../bus"
 import { FileTime } from "../file/time"

-export const EditTool = Tool.define({
-  id: "edit",
+export const EditTool = Tool.define("edit", {
  description: DESCRIPTION,
  parameters: z.object({
    filePath: z.string().describe("The absolute path to the file to modify"),
@@ -105,6 +104,31 @@ export const EditTool = Tool.define({

 export type Replacer = (content: string, find: string) => Generator<string, void, unknown>

+// Similarity thresholds for block anchor fallback matching
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3
+
+/**
+ * Levenshtein distance algorithm implementation
+ */
+function levenshtein(a: string, b: string): number {
+  // Handle empty strings
+  if (a === "" || b === "") {
+    return Math.max(a.length, b.length)
+  }
+  const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+    Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+  )
+
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+    }
+  }
+  return matrix[a.length][b.length]
+}
+
 export const SimpleReplacer: Replacer = function* (_content, find) {
  yield find
 }
@@ -160,8 +184,10 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {

  const firstLineSearch = searchLines[0].trim()
  const lastLineSearch = searchLines[searchLines.length - 1].trim()
+  const searchBlockSize = searchLines.length

-  // Find blocks where first line matches the search first line
+  // Collect all candidate positions where both anchors match
+  const candidates: Array<{ startLine: number; endLine: number }> = []
  for (let i = 0; i < originalLines.length; i++) {
    if (originalLines[i].trim() !== firstLineSearch) {
      continue
@@ -170,25 +196,113 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
    // Look for the matching last line after this first line
    for (let j = i + 2; j < originalLines.length; j++) {
      if (originalLines[j].trim() === lastLineSearch) {
-        // Found a potential block from i to j
-        let matchStartIndex = 0
-        for (let k = 0; k < i; k++) {
-          matchStartIndex += originalLines[k].length + 1
-        }
-
-        let matchEndIndex = matchStartIndex
-        for (let k = 0; k <= j - i; k++) {
-          matchEndIndex += originalLines[i + k].length
-          if (k < j - i) {
-            matchEndIndex += 1 // Add newline character except for the last line
-          }
-        }
-
-        yield content.substring(matchStartIndex, matchEndIndex)
+        candidates.push({ startLine: i, endLine: j })
        break // Only match the first occurrence of the last line
      }
    }
  }
+
+  // Return immediately if no candidates
+  if (candidates.length === 0) {
+    return
+  }
+
+  // Handle single candidate scenario (using relaxed threshold)
+  if (candidates.length === 1) {
+    const { startLine, endLine } = candidates[0]
+    const actualBlockSize = endLine - startLine + 1
+
+    let similarity = 0
+    let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2) // Middle lines only
+
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim()
+        const searchLine = searchLines[j].trim()
+        const maxLen = Math.max(originalLine.length, searchLine.length)
+        if (maxLen === 0) {
+          continue
+        }
+        const distance = levenshtein(originalLine, searchLine)
+        similarity += (1 - distance / maxLen) / linesToCheck
+
+        // Exit early when threshold is reached
+        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+          break
+        }
+      }
+    } else {
+      // No middle lines to compare, just accept based on anchors
+      similarity = 1.0
+    }
+
+    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+      let matchStartIndex = 0
+      for (let k = 0; k < startLine; k++) {
+        matchStartIndex += originalLines[k].length + 1
+      }
+      let matchEndIndex = matchStartIndex
+      for (let k = startLine; k <= endLine; k++) {
+        matchEndIndex += originalLines[k].length
+        if (k < endLine) {
+          matchEndIndex += 1 // Add newline character except for the last line
+        }
+      }
+      yield content.substring(matchStartIndex, matchEndIndex)
+    }
+    return
+  }
+
+  // Calculate similarity for multiple candidates
+  let bestMatch: { startLine: number; endLine: number } | null = null
+  let maxSimilarity = -1
+
+  for (const candidate of candidates) {
+    const { startLine, endLine } = candidate
+    const actualBlockSize = endLine - startLine + 1
+
+    let similarity = 0
+    let linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2) // Middle lines only
+
+    if (linesToCheck > 0) {
+      for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+        const originalLine = originalLines[startLine + j].trim()
+        const searchLine = searchLines[j].trim()
+        const maxLen = Math.max(originalLine.length, searchLine.length)
+        if (maxLen === 0) {
+          continue
+        }
+        const distance = levenshtein(originalLine, searchLine)
+        similarity += 1 - distance / maxLen
+      }
+      similarity /= linesToCheck // Average similarity
+    } else {
+      // No middle lines to compare, just accept based on anchors
+      similarity = 1.0
+    }
+
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity
+      bestMatch = candidate
+    }
+  }
+
+  // Threshold judgment
+  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+    const { startLine, endLine } = bestMatch
+    let matchStartIndex = 0
+    for (let k = 0; k < startLine; k++) {
+      matchStartIndex += originalLines[k].length + 1
+    }
+    let matchEndIndex = matchStartIndex
+    for (let k = startLine; k <= endLine; k++) {
+      matchEndIndex += originalLines[k].length
+      if (k < endLine) {
+        matchEndIndex += 1
+      }
+    }
+    yield content.substring(matchStartIndex, matchEndIndex)
+  }
 }

 export const WhitespaceNormalizedReplacer: Replacer = function* (content, find) {
@@ -201,23 +315,23 @@ export const WhitespaceNormalizedReplacer: Replacer = function* (content, find)
    const line = lines[i]
    if (normalizeWhitespace(line) === normalizedFind) {
      yield line
-    }
-
-    // Also check for substring matches within lines
-    const normalizedLine = normalizeWhitespace(line)
-    if (normalizedLine.includes(normalizedFind)) {
-      // Find the actual substring in the original line that matches
-      const words = find.trim().split(/\s+/)
-      if (words.length > 0) {
-        const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+")
-        try {
-          const regex = new RegExp(pattern)
-          const match = line.match(regex)
-          if (match) {
-            yield match[0]
+    } else {
+      // Only check for substring matches if the full line doesn't match
+      const normalizedLine = normalizeWhitespace(line)
+      if (normalizedLine.includes(normalizedFind)) {
+        // Find the actual substring in the original line that matches
+        const words = find.trim().split(/\s+/)
+        if (words.length > 0) {
+          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+")
+          try {
+            const regex = new RegExp(pattern)
+            const match = line.match(regex)
+            if (match) {
+              yield match[0]
+            }
+          } catch (e) {
+            // Invalid regex pattern, skip
          }
-        } catch (e) {
-          // Invalid regex pattern, skip
        }
      }
    }
@@ -457,7 +571,7 @@ export function replace(content: string, oldString: string, newString: string, r
    BlockAnchorReplacer,
    WhitespaceNormalizedReplacer,
    IndentationFlexibleReplacer,
-    // EscapeNormalizedReplacer,
+    EscapeNormalizedReplacer,
    // TrimmedBoundaryReplacer,
    // ContextAwareReplacer,
    // MultiOccurrenceReplacer,
@@ -5,8 +5,7 @@ import { App } from "../app/app"
 import DESCRIPTION from "./glob.txt"
 import { Ripgrep } from "../file/ripgrep"

-export const GlobTool = Tool.define({
-  id: "glob",
+export const GlobTool = Tool.define("glob", {
  description: DESCRIPTION,
  parameters: z.object({
    pattern: z.string().describe("The glob pattern to match files against"),
@@ -5,8 +5,7 @@ import { Ripgrep } from "../file/ripgrep"

 import DESCRIPTION from "./grep.txt"

-export const GrepTool = Tool.define({
-  id: "grep",
+export const GrepTool = Tool.define("grep", {
  description: DESCRIPTION,
  parameters: z.object({
    pattern: z.string().describe("The regex pattern to search for in file contents"),
@@ -33,8 +33,7 @@ export const IGNORE_PATTERNS = [

 const LIMIT = 100

-export const ListTool = Tool.define({
-  id: "list",
+export const ListTool = Tool.define("list", {
  description: DESCRIPTION,
  parameters: z.object({
    path: z.string().describe("The absolute path to the directory to list (must be absolute, not relative)").optional(),
@@ -5,8 +5,7 @@ import { LSP } from "../lsp"
 import { App } from "../app/app"
 import DESCRIPTION from "./lsp-diagnostics.txt"

-export const LspDiagnosticTool = Tool.define({
-  id: "lsp_diagnostics",
+export const LspDiagnosticTool = Tool.define("lsp_diagnostics", {
  description: DESCRIPTION,
  parameters: z.object({
    path: z.string().describe("The path to the file to get diagnostics."),
@@ -5,8 +5,7 @@ import { LSP } from "../lsp"
 import { App } from "../app/app"
 import DESCRIPTION from "./lsp-hover.txt"

-export const LspHoverTool = Tool.define({
-  id: "lsp_hover",
+export const LspHoverTool = Tool.define("lsp_hover", {
  description: DESCRIPTION,
  parameters: z.object({
    file: z.string().describe("The path to the file to get diagnostics."),
@@ -5,17 +5,26 @@ import DESCRIPTION from "./multiedit.txt"
 import path from "path"
 import { App } from "../app/app"

-export const MultiEditTool = Tool.define({
-  id: "multiedit",
+export const MultiEditTool = Tool.define("multiedit", {
  description: DESCRIPTION,
  parameters: z.object({
    filePath: z.string().describe("The absolute path to the file to modify"),
-    edits: z.array(EditTool.parameters).describe("Array of edit operations to perform sequentially on the file"),
+    edits: z
+      .array(
+        z.object({
+          filePath: z.string().describe("The absolute path to the file to modify"),
+          oldString: z.string().describe("The text to replace"),
+          newString: z.string().describe("The text to replace it with (must be different from oldString)"),
+          replaceAll: z.boolean().optional().describe("Replace all occurrences of oldString (default false)"),
+        }),
+      )
+      .describe("Array of edit operations to perform sequentially on the file"),
  }),
  async execute(params, ctx) {
+    const tool = await EditTool.init()
    const results = []
    for (const [, edit] of params.edits.entries()) {
-      const result = await EditTool.execute(
+      const result = await tool.execute(
        {
          filePath: params.filePath,
          oldString: edit.oldString,
@@ -210,8 +210,7 @@ async function applyCommit(
  }
 }

-export const PatchTool = Tool.define({
-  id: "patch",
+export const PatchTool = Tool.define("patch", {
  description: DESCRIPTION,
  parameters: PatchParams,
  execute: async (params, ctx) => {
@@ -10,8 +10,7 @@ import { App } from "../app/app"
 const DEFAULT_READ_LIMIT = 2000
 const MAX_LINE_LENGTH = 2000

-export const ReadTool = Tool.define({
-  id: "read",
+export const ReadTool = Tool.define("read", {
  description: DESCRIPTION,
  parameters: z.object({
    filePath: z.string().describe("The path to the file to read"),
@@ -0,0 +1,170 @@
+import z from "zod"
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { ListTool } from "./ls"
+import { PatchTool } from "./patch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { TodoWriteTool, TodoReadTool } from "./todo"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+
+export namespace ToolRegistry {
+  const ALL = [
+    BashTool,
+    EditTool,
+    WebFetchTool,
+    GlobTool,
+    GrepTool,
+    ListTool,
+    PatchTool,
+    ReadTool,
+    WriteTool,
+    TodoWriteTool,
+    TodoReadTool,
+    TaskTool,
+  ]
+
+  export function ids() {
+    return ALL.map((t) => t.id)
+  }
+
+  export async function tools(providerID: string, _modelID: string) {
+    const result = await Promise.all(
+      ALL.map(async (t) => ({
+        id: t.id,
+        ...(await t.init()),
+      })),
+    )
+
+    if (providerID === "openai") {
+      return result.map((t) => ({
+        ...t,
+        parameters: optionalToNullable(t.parameters),
+      }))
+    }
+
+    if (providerID === "azure") {
+      return result.map((t) => ({
+        ...t,
+        parameters: optionalToNullable(t.parameters),
+      }))
+    }
+
+    if (providerID === "google") {
+      return result.map((t) => ({
+        ...t,
+        parameters: sanitizeGeminiParameters(t.parameters),
+      }))
+    }
+
+    return result
+  }
+
+  export function enabled(_providerID: string, modelID: string): Record<string, boolean> {
+    if (modelID.includes("claude")) {
+      return {
+        patch: false,
+      }
+    }
+    if (modelID.includes("qwen")) {
+      return {
+        patch: false,
+        todowrite: false,
+        todoread: false,
+      }
+    }
+    return {}
+  }
+
+  function sanitizeGeminiParameters(schema: z.ZodTypeAny, visited = new Set()): z.ZodTypeAny {
+    if (!schema || visited.has(schema)) {
+      return schema
+    }
+    visited.add(schema)
+
+    if (schema instanceof z.ZodDefault) {
+      const innerSchema = schema.removeDefault()
+      // Handle Gemini's incompatibility with `default` on `anyOf` (unions).
+      if (innerSchema instanceof z.ZodUnion) {
+        // The schema was `z.union(...).default(...)`, which is not allowed.
+        // We strip the default and return the sanitized union.
+        return sanitizeGeminiParameters(innerSchema, visited)
+      }
+      // Otherwise, the default is on a regular type, which is allowed.
+      // We recurse on the inner type and then re-apply the default.
+      return sanitizeGeminiParameters(innerSchema, visited).default(schema._def.defaultValue())
+    }
+
+    if (schema instanceof z.ZodOptional) {
+      return z.optional(sanitizeGeminiParameters(schema.unwrap(), visited))
+    }
+
+    if (schema instanceof z.ZodObject) {
+      const newShape: Record<string, z.ZodTypeAny> = {}
+      for (const [key, value] of Object.entries(schema.shape)) {
+        newShape[key] = sanitizeGeminiParameters(value as z.ZodTypeAny, visited)
+      }
+      return z.object(newShape)
+    }
+
+    if (schema instanceof z.ZodArray) {
+      return z.array(sanitizeGeminiParameters(schema.element, visited))
+    }
+
+    if (schema instanceof z.ZodUnion) {
+      // This schema corresponds to `anyOf` in JSON Schema.
+      // We recursively sanitize each option in the union.
+      const sanitizedOptions = schema.options.map((option: z.ZodTypeAny) => sanitizeGeminiParameters(option, visited))
+      return z.union(sanitizedOptions as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]])
+    }
+
+    if (schema instanceof z.ZodString) {
+      const newSchema = z.string({ description: schema.description })
+      const safeChecks = ["min", "max", "length", "regex", "startsWith", "endsWith", "includes", "trim"]
+      // rome-ignore lint/suspicious/noExplicitAny: <explanation>
+      ;(newSchema._def as any).checks = (schema._def as z.ZodStringDef).checks.filter((check) =>
+        safeChecks.includes(check.kind),
+      )
+      return newSchema
+    }
+
+    return schema
+  }
+
+  function optionalToNullable(schema: z.ZodTypeAny): z.ZodTypeAny {
+    if (schema instanceof z.ZodObject) {
+      const shape = schema.shape
+      const newShape: Record<string, z.ZodTypeAny> = {}
+
+      for (const [key, value] of Object.entries(shape)) {
+        const zodValue = value as z.ZodTypeAny
+        if (zodValue instanceof z.ZodOptional) {
+          newShape[key] = zodValue.unwrap().nullable()
+        } else {
+          newShape[key] = optionalToNullable(zodValue)
+        }
+      }
+
+      return z.object(newShape)
+    }
+
+    if (schema instanceof z.ZodArray) {
+      return z.array(optionalToNullable(schema.element))
+    }
+
+    if (schema instanceof z.ZodUnion) {
+      return z.union(
+        schema.options.map((option: z.ZodTypeAny) => optionalToNullable(option)) as [
+          z.ZodTypeAny,
+          z.ZodTypeAny,
+          ...z.ZodTypeAny[],
+        ],
+      )
+    }
+
+    return schema
+  }
+}
@@ -5,62 +5,73 @@ import { Session } from "../session"
 import { Bus } from "../bus"
 import { MessageV2 } from "../session/message-v2"
 import { Identifier } from "../id/id"
+import { Agent } from "../agent/agent"

-export const TaskTool = Tool.define({
-  id: "task",
-  description: DESCRIPTION,
-  parameters: z.object({
-    description: z.string().describe("A short (3-5 words) description of the task"),
-    prompt: z.string().describe("The task for the agent to perform"),
-  }),
-  async execute(params, ctx) {
-    const session = await Session.create(ctx.sessionID)
-    const msg = await Session.getMessage(ctx.sessionID, ctx.messageID)
-    if (msg.role !== "assistant") throw new Error("Not an assistant message")
+export const TaskTool = Tool.define("task", async () => {
+  const agents = await Agent.list()
+  const description = DESCRIPTION.replace("{agents}", agents.map((a) => `- ${a.name}: ${a.description}`).join("\n"))
+  return {
+    description,
+    parameters: z.object({
+      description: z.string().describe("A short (3-5 words) description of the task"),
+      prompt: z.string().describe("The task for the agent to perform"),
+      subagent_type: z.string().describe("The type of specialized agent to use for this task"),
+    }),
+    async execute(params, ctx) {
+      const session = await Session.create(ctx.sessionID)
+      const msg = await Session.getMessage(ctx.sessionID, ctx.messageID)
+      if (msg.role !== "assistant") throw new Error("Not an assistant message")
+      const agent = await Agent.get(params.subagent_type)
+      const messageID = Identifier.ascending("message")
+      const parts: Record<string, MessageV2.ToolPart> = {}
+      const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+        if (evt.properties.part.sessionID !== session.id) return
+        if (evt.properties.part.messageID === messageID) return
+        if (evt.properties.part.type !== "tool") return
+        parts[evt.properties.part.id] = evt.properties.part
+        ctx.metadata({
+          title: params.description,
+          metadata: {
+            summary: Object.values(parts).sort((a, b) => a.id?.localeCompare(b.id)),
+          },
+        })
+      })

-    const messageID = Identifier.ascending("message")
-    const parts: Record<string, MessageV2.ToolPart> = {}
-    const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-      if (evt.properties.part.sessionID !== session.id) return
-      if (evt.properties.part.messageID === messageID) return
-      if (evt.properties.part.type !== "tool") return
-      parts[evt.properties.part.id] = evt.properties.part
-      ctx.metadata({
+      const model = agent.model ?? {
+        modelID: msg.modelID,
+        providerID: msg.providerID,
+      }
+
+      ctx.abort.addEventListener("abort", () => {
+        Session.abort(session.id)
+      })
+      const result = await Session.chat({
+        messageID,
+        sessionID: session.id,
+        modelID: model.modelID,
+        providerID: model.providerID,
+        mode: msg.mode,
+        system: agent.prompt,
+        tools: {
+          ...agent.tools,
+          task: false,
+        },
+        parts: [
+          {
+            id: Identifier.ascending("part"),
+            type: "text",
+            text: params.prompt,
+          },
+        ],
+      })
+      unsub()
+      return {
        title: params.description,
        metadata: {
-          summary: Object.values(parts).sort((a, b) => a.id?.localeCompare(b.id)),
+          summary: result.parts.filter((x) => x.type === "tool"),
        },
-      })
-    })
-
-    ctx.abort.addEventListener("abort", () => {
-      Session.abort(session.id)
-    })
-    const result = await Session.chat({
-      messageID,
-      sessionID: session.id,
-      modelID: msg.modelID,
-      providerID: msg.providerID,
-      mode: msg.mode,
-      tools: {
-        todoread: false,
-        todowrite: false,
-      },
-      parts: [
-        {
-          id: Identifier.ascending("part"),
-          type: "text",
-          text: params.prompt,
-        },
-      ],
-    })
-    unsub()
-    return {
-      title: params.description,
-      metadata: {
-        summary: result.parts.filter((x) => x.type === "tool"),
-      },
-      output: result.parts.findLast((x) => x.type === "text")!.text,
-    }
-  },
+        output: result.parts.findLast((x) => x.type === "text")!.text,
+      }
+    },
+  }
 })
@@ -1,12 +1,19 @@
-Launch a new agent that has access to the following tools: Bash, Glob, Grep, LS, Read, Edit, MultiEdit, Write, NotebookRead, NotebookEdit, WebFetch, TodoRead, TodoWrite, WebSearch. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use the Agent tool to perform the search for you.
+Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+{agents}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.

 When to use the Agent tool:
- If you are searching for a keyword like "config" or "logger", or for questions like "which file does X?", the Agent tool is strongly recommended
+- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")

 When NOT to use the Agent tool:
 - If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
 - If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
 - If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+

 Usage notes:
 1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
@@ -14,3 +21,40 @@ Usage notes:
 3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
 4. The agent's outputs should generally be trusted
 5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a signficant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the Write tool to write a function that checks if a number is prime
+assistant: I'm going to use the Write tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>
@@ -18,8 +18,7 @@ const state = App.state("todo-tool", () => {
  return todos
 })

-export const TodoWriteTool = Tool.define({
-  id: "todowrite",
+export const TodoWriteTool = Tool.define("todowrite", {
  description: DESCRIPTION_WRITE,
  parameters: z.object({
    todos: z.array(TodoInfo).describe("The updated todo list"),
@@ -37,8 +36,7 @@ export const TodoWriteTool = Tool.define({
  },
 })

-export const TodoReadTool = Tool.define({
-  id: "todoread",
+export const TodoReadTool = Tool.define("todoread", {
  description: "Use this tool to read your todo list",
  parameters: z.object({}),
  async execute(_params, opts) {
@@ -12,21 +12,30 @@ export namespace Tool {
  }
  export interface Info<Parameters extends StandardSchemaV1 = StandardSchemaV1, M extends Metadata = Metadata> {
    id: string
-    description: string
-    parameters: Parameters
-    execute(
-      args: StandardSchemaV1.InferOutput<Parameters>,
-      ctx: Context,
-    ): Promise<{
-      title: string
-      metadata: M
-      output: string
+    init: () => Promise<{
+      description: string
+      parameters: Parameters
+      execute(
+        args: StandardSchemaV1.InferOutput<Parameters>,
+        ctx: Context,
+      ): Promise<{
+        title: string
+        metadata: M
+        output: string
+      }>
    }>
  }

  export function define<Parameters extends StandardSchemaV1, Result extends Metadata>(
-    input: Info<Parameters, Result>,
+    id: string,
+    init: Info<Parameters, Result>["init"] | Awaited<ReturnType<Info<Parameters, Result>["init"]>>,
  ): Info<Parameters, Result> {
-    return input
+    return {
+      id,
+      init: async () => {
+        if (init instanceof Function) return init()
+        return init
+      },
+    }
  }
 }
@@ -7,8 +7,7 @@ const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
 const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
 const MAX_TIMEOUT = 120 * 1000 // 2 minutes

-export const WebFetchTool = Tool.define({
-  id: "webfetch",
+export const WebFetchTool = Tool.define("webfetch", {
  description: DESCRIPTION,
  parameters: z.object({
    url: z.string().describe("The URL to fetch content from"),
@@ -9,8 +9,7 @@ import { Bus } from "../bus"
 import { File } from "../file"
 import { FileTime } from "../file/time"

-export const WriteTool = Tool.define({
-  id: "write",
+export const WriteTool = Tool.define("write", {
  description: DESCRIPTION,
  parameters: z.object({
    filePath: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
@@ -49,10 +49,12 @@ export namespace Filesystem {
        const glob = new Bun.Glob(pattern)
        for await (const match of glob.scan({
          cwd: current,
+          absolute: true,
          onlyFiles: true,
+          followSymlinks: true,
          dot: true,
        })) {
-          result.push(join(current, match))
+          result.push(match)
        }
      } catch {
        // Skip invalid glob patterns
@@ -326,6 +326,88 @@ const testCases: TestCase[] = [
    find: "const msg = `Hello\\tWorld`;",
    replace: "const msg = `Hi\\tWorld`;",
  },
+
+  // Test case that reproduces the greedy matching bug - now should fail due to low similarity
+  {
+    content: [
+      "func main() {",
+      "  if condition {",
+      "    doSomething()",
+      "  }",
+      "  processData()",
+      "  if anotherCondition {",
+      "    doOtherThing()",
+      "  }",
+      "  return mainLayout",
+      "}",
+      "",
+      "func helper() {",
+      "  }",
+      "  return mainLayout", // This should NOT be matched due to low similarity
+      "}",
+    ].join("\n"),
+    find: ["  }", "  return mainLayout"].join("\n"),
+    replace: ["  }", "  // Add some code here", "  return mainLayout"].join("\n"),
+    fail: true, // This should fail because the pattern has low similarity score
+  },
+
+  // Test case for the fix - more specific pattern should work
+  {
+    content: [
+      "function renderLayout() {",
+      "  const header = createHeader()",
+      "  const body = createBody()",
+      "  return mainLayout",
+      "}",
+    ].join("\n"),
+    find: ["function renderLayout() {", "  // different content", "  return mainLayout", "}"].join("\n"),
+    replace: [
+      "function renderLayout() {",
+      "  const header = createHeader()",
+      "  const body = createBody()",
+      "  // Add minimap overlay",
+      "  return mainLayout",
+      "}",
+    ].join("\n"),
+  },
+
+  // Test that large blocks without arbitrary size limits can work
+  {
+    content: Array.from({ length: 100 }, (_, i) => `line ${i}`).join("\n"),
+    find: Array.from({ length: 50 }, (_, i) => `line ${i + 25}`).join("\n"),
+    replace: Array.from({ length: 50 }, (_, i) => `updated line ${i + 25}`).join("\n"),
+  },
+
+  // Test case for the fix - more specific pattern should work
+  {
+    content: [
+      "function renderLayout() {",
+      "  const header = createHeader()",
+      "  const body = createBody()",
+      "  return mainLayout",
+      "}",
+    ].join("\n"),
+    find: ["function renderLayout() {", "  // different content", "  return mainLayout", "}"].join("\n"),
+    replace: [
+      "function renderLayout() {",
+      "  const header = createHeader()",
+      "  const body = createBody()",
+      "  // Add minimap overlay",
+      "  return mainLayout",
+      "}",
+    ].join("\n"),
+  },
+
+  // Test BlockAnchorReplacer with overly large blocks (should fail)
+  {
+    content:
+      Array.from({ length: 100 }, (_, i) => `line ${i}`).join("\n") +
+      "\nfunction test() {\n" +
+      Array.from({ length: 60 }, (_, i) => `  content ${i}`).join("\n") +
+      "\n  return result\n}",
+    find: ["function test() {", "  // different content", "  return result", "}"].join("\n"),
+    replace: ["function test() {", "  return 42", "}"].join("\n"),
+  },
 ]

 describe("EditTool Replacers", () => {
@@ -9,10 +9,13 @@ const ctx = {
  abort: AbortSignal.any([]),
  metadata: () => {},
 }
+const glob = await GlobTool.init()
+const list = await ListTool.init()
+
 describe("tool.glob", () => {
  test("truncate", async () => {
    await App.provide({ cwd: process.cwd() }, async () => {
-      let result = await GlobTool.execute(
+      let result = await glob.execute(
        {
          pattern: "../../node_modules/**/*",
          path: undefined,
@@ -24,7 +27,7 @@ describe("tool.glob", () => {
  })
  test("basic", async () => {
    await App.provide({ cwd: process.cwd() }, async () => {
-      let result = await GlobTool.execute(
+      let result = await glob.execute(
        {
          pattern: "*.json",
          path: undefined,
@@ -42,7 +45,7 @@ describe("tool.glob", () => {
 describe("tool.ls", () => {
  test("basic", async () => {
    const result = await App.provide({ cwd: process.cwd() }, async () => {
-      return await ListTool.execute({ path: "./example", ignore: [".git"] }, ctx)
+      return await list.execute({ path: "./example", ignore: [".git"] }, ctx)
    })
    expect(result.output).toMatchSnapshot()
  })
@@ -1,4 +1,4 @@
 configured_endpoints: 26
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-1efc45c35b58e88b0550fbb0c7a204ef66522742f87c9e29c76a18b120c0d945.yml
-openapi_spec_hash: 5e15d85e4704624f9b13bae1c71aa416
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-5748199af356c3243a46a466e73b5d0bab7eaa0c56895e1d0f903d637f61d0bb.yml
+openapi_spec_hash: c04f6b6be54b05d9b1283c24e870163b
 config_hash: 1ae82c93499b9f0b9ba828b8919f9cb3
@@ -147,7 +147,7 @@ export namespace Config {

    npm?: string;

-    options?: { [key: string]: unknown };
+    options?: Provider.Options;
  }

  export namespace Provider {
@@ -190,6 +190,14 @@ export namespace Config {
        output: number;
      }
    }
+
+    export interface Options {
+      apiKey?: string;
+
+      baseURL?: string;
+
+      [k: string]: unknown;
+    }
  }
 }

@@ -24,6 +24,7 @@ export type EventListResponse =
  | EventListResponse.EventMessageUpdated
  | EventListResponse.EventMessageRemoved
  | EventListResponse.EventMessagePartUpdated
+  | EventListResponse.EventMessagePartRemoved
  | EventListResponse.EventStorageWrite
  | EventListResponse.EventSessionUpdated
  | EventListResponse.EventSessionDeleted
@@ -135,6 +136,20 @@ export namespace EventListResponse {
    }
  }

+  export interface EventMessagePartRemoved {
+    properties: EventMessagePartRemoved.Properties;
+
+    type: 'message.part.removed';
+  }
+
+  export namespace EventMessagePartRemoved {
+    export interface Properties {
+      messageID: string;
+
+      partID: string;
+    }
+  }
+
  export interface EventStorageWrite {
    properties: EventStorageWrite.Properties;

@@ -102,6 +102,8 @@ export interface AssistantMessage {

  cost: number;

+  mode: string;
+
  modelID: string;

  path: AssistantMessage.Path;
@@ -217,7 +219,30 @@ export interface FileSource {

 export type Message = UserMessage | AssistantMessage;

-export type Part = TextPart | FilePart | ToolPart | StepStartPart | StepFinishPart | SnapshotPart;
+export type Part =
+  | TextPart
+  | FilePart
+  | ToolPart
+  | StepStartPart
+  | StepFinishPart
+  | SnapshotPart
+  | Part.PatchPart;
+
+export namespace Part {
+  export interface PatchPart {
+    id: string;
+
+    files: Array<string>;
+
+    hash: string;
+
+    messageID: string;
+
+    sessionID: string;
+
+    type: 'patch';
+  }
+}

 export interface Session {
  id: string;
@@ -23,6 +23,7 @@ type ModeModel struct {

 type State struct {
 	Theme              string               `toml:"theme"`
+	ScrollSpeed        *int                 `toml:"scroll_speed"`
 	ModeModel          map[string]ModeModel `toml:"mode_model"`
 	Provider           string               `toml:"provider"`
 	Model              string               `toml:"model"`
@@ -553,10 +553,18 @@ func renderToolTitle(
 		if filename, ok := toolArgsMap["filePath"].(string); ok {
 			title = fmt.Sprintf("%s %s", title, util.Relative(filename))
 		}
-	case "bash", "task":
+	case "bash":
 		if description, ok := toolArgsMap["description"].(string); ok {
 			title = fmt.Sprintf("%s %s", title, description)
 		}
+	case "task":
+		description := toolArgsMap["description"]
+		subagent := toolArgsMap["subagent_type"]
+		if description != nil && subagent != nil {
+			title = fmt.Sprintf("%s[%s] %s", title, subagent, description)
+		} else if description != nil {
+			title = fmt.Sprintf("%s %s", title, description)
+		}
 	case "webfetch":
 		toolArgs = renderArgs(&toolArgsMap, "url")
 		title = fmt.Sprintf("%s %s", title, toolArgs)
@@ -576,7 +584,7 @@ func renderToolTitle(
 func renderToolAction(name string) string {
 	switch name {
 	case "task":
-		return "Planning..."
+		return "Delegating..."
 	case "bash":
 		return "Writing command..."
 	case "edit":
@@ -670,15 +670,21 @@ func (m *messagesComponent) renderHeader() string {
 	isSubscriptionModel := m.app.Model != nil &&
 		m.app.Model.Cost.Input == 0 && m.app.Model.Cost.Output == 0

+	sessionInfoText := formatTokensAndCost(tokens, contextWindow, cost, isSubscriptionModel)
 	sessionInfo = styles.NewStyle().
 		Foreground(t.TextMuted()).
 		Background(t.Background()).
-		Render(formatTokensAndCost(tokens, contextWindow, cost, isSubscriptionModel))
+		Render(sessionInfoText)

 	shareEnabled := m.app.Config.Share != opencode.ConfigShareDisabled
+	headerTextWidth := headerWidth
+	if !shareEnabled {
+		// +1 is to ensure there is always at least one space between header and session info
+		headerTextWidth -= len(sessionInfoText) + 1
+	}
 	headerText := util.ToMarkdown(
 		"# "+m.app.Session.Title,
-		headerWidth,
+		headerTextWidth,
 		t.Background(),
 	)

@@ -705,11 +711,9 @@ func (m *messagesComponent) renderHeader() string {
 		items...,
 	)

-	var headerLines []string
+	headerLines := []string{headerRow}
 	if shareEnabled {
 		headerLines = []string{headerText, headerRow}
-	} else {
-		headerLines = []string{headerRow}
 	}

 	header := strings.Join(headerLines, "\n")
@@ -1015,7 +1019,12 @@ func (m *messagesComponent) RedoLastMessage() (tea.Model, tea.Cmd) {
 func NewMessagesComponent(app *app.App) MessagesComponent {
 	vp := viewport.New()
 	vp.KeyMap = viewport.KeyMap{}
-	vp.MouseWheelDelta = 4
+
+	if app.State.ScrollSpeed != nil && *app.State.ScrollSpeed > 0 {
+		vp.MouseWheelDelta = *app.State.ScrollSpeed
+	} else {
+		vp.MouseWheelDelta = 4
+	}

 	return &messagesComponent{
 		app:             app,
@@ -1,4 +1,4 @@
 configured_endpoints: 26
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-1efc45c35b58e88b0550fbb0c7a204ef66522742f87c9e29c76a18b120c0d945.yml
-openapi_spec_hash: 5e15d85e4704624f9b13bae1c71aa416
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/opencode%2Fopencode-5748199af356c3243a46a466e73b5d0bab7eaa0c56895e1d0f903d637f61d0bb.yml
+openapi_spec_hash: c04f6b6be54b05d9b1283c24e870163b
 config_hash: 1ae82c93499b9f0b9ba828b8919f9cb3
@@ -333,7 +333,7 @@ type ConfigProvider struct {
 	Env     []string                       `json:"env"`
 	Name    string                         `json:"name"`
 	Npm     string                         `json:"npm"`
-	Options map[string]interface{}         `json:"options"`
+	Options ConfigProviderOptions          `json:"options"`
 	JSON    configProviderJSON             `json:"-"`
 }

@@ -447,6 +447,30 @@ func (r configProviderModelsLimitJSON) RawJSON() string {
 	return r.raw
 }

+type ConfigProviderOptions struct {
+	APIKey      string                    `json:"apiKey"`
+	BaseURL     string                    `json:"baseURL"`
+	ExtraFields map[string]interface{}    `json:"-,extras"`
+	JSON        configProviderOptionsJSON `json:"-"`
+}
+
+// configProviderOptionsJSON contains the JSON metadata for the struct
+// [ConfigProviderOptions]
+type configProviderOptionsJSON struct {
+	APIKey      apijson.Field
+	BaseURL     apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *ConfigProviderOptions) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r configProviderOptionsJSON) RawJSON() string {
+	return r.raw
+}
+
 // Control sharing behavior:'manual' allows manual sharing via commands, 'auto'
 // enables automatic sharing, 'disabled' disables all sharing
 type ConfigShare string
@@ -55,6 +55,7 @@ type EventListResponse struct {
 	// [EventListResponseEventMessageUpdatedProperties],
 	// [EventListResponseEventMessageRemovedProperties],
 	// [EventListResponseEventMessagePartUpdatedProperties],
+	// [EventListResponseEventMessagePartRemovedProperties],
 	// [EventListResponseEventStorageWriteProperties],
 	// [EventListResponseEventSessionUpdatedProperties],
 	// [EventListResponseEventSessionDeletedProperties],
@@ -99,6 +100,7 @@ func (r *EventListResponse) UnmarshalJSON(data []byte) (err error) {
 // [EventListResponseEventInstallationUpdated],
 // [EventListResponseEventMessageUpdated], [EventListResponseEventMessageRemoved],
 // [EventListResponseEventMessagePartUpdated],
+// [EventListResponseEventMessagePartRemoved],
 // [EventListResponseEventStorageWrite], [EventListResponseEventSessionUpdated],
 // [EventListResponseEventSessionDeleted], [EventListResponseEventSessionIdle],
 // [EventListResponseEventSessionError],
@@ -113,6 +115,7 @@ func (r EventListResponse) AsUnion() EventListResponseUnion {
 // [EventListResponseEventInstallationUpdated],
 // [EventListResponseEventMessageUpdated], [EventListResponseEventMessageRemoved],
 // [EventListResponseEventMessagePartUpdated],
+// [EventListResponseEventMessagePartRemoved],
 // [EventListResponseEventStorageWrite], [EventListResponseEventSessionUpdated],
 // [EventListResponseEventSessionDeleted], [EventListResponseEventSessionIdle],
 // [EventListResponseEventSessionError], [EventListResponseEventFileWatcherUpdated]
@@ -160,6 +163,11 @@ func init() {
 			Type:               reflect.TypeOf(EventListResponseEventMessagePartUpdated{}),
 			DiscriminatorValue: "message.part.updated",
 		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(EventListResponseEventMessagePartRemoved{}),
+			DiscriminatorValue: "message.part.removed",
+		},
 		apijson.UnionVariant{
 			TypeFilter:         gjson.JSON,
 			Type:               reflect.TypeOf(EventListResponseEventStorageWrite{}),
@@ -651,6 +659,68 @@ func (r EventListResponseEventMessagePartUpdatedType) IsKnown() bool {
 	return false
 }

+type EventListResponseEventMessagePartRemoved struct {
+	Properties EventListResponseEventMessagePartRemovedProperties `json:"properties,required"`
+	Type       EventListResponseEventMessagePartRemovedType       `json:"type,required"`
+	JSON       eventListResponseEventMessagePartRemovedJSON       `json:"-"`
+}
+
+// eventListResponseEventMessagePartRemovedJSON contains the JSON metadata for the
+// struct [EventListResponseEventMessagePartRemoved]
+type eventListResponseEventMessagePartRemovedJSON struct {
+	Properties  apijson.Field
+	Type        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *EventListResponseEventMessagePartRemoved) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r eventListResponseEventMessagePartRemovedJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r EventListResponseEventMessagePartRemoved) implementsEventListResponse() {}
+
+type EventListResponseEventMessagePartRemovedProperties struct {
+	MessageID string                                                 `json:"messageID,required"`
+	PartID    string                                                 `json:"partID,required"`
+	JSON      eventListResponseEventMessagePartRemovedPropertiesJSON `json:"-"`
+}
+
+// eventListResponseEventMessagePartRemovedPropertiesJSON contains the JSON
+// metadata for the struct [EventListResponseEventMessagePartRemovedProperties]
+type eventListResponseEventMessagePartRemovedPropertiesJSON struct {
+	MessageID   apijson.Field
+	PartID      apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *EventListResponseEventMessagePartRemovedProperties) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r eventListResponseEventMessagePartRemovedPropertiesJSON) RawJSON() string {
+	return r.raw
+}
+
+type EventListResponseEventMessagePartRemovedType string
+
+const (
+	EventListResponseEventMessagePartRemovedTypeMessagePartRemoved EventListResponseEventMessagePartRemovedType = "message.part.removed"
+)
+
+func (r EventListResponseEventMessagePartRemovedType) IsKnown() bool {
+	switch r {
+	case EventListResponseEventMessagePartRemovedTypeMessagePartRemoved:
+		return true
+	}
+	return false
+}
+
 type EventListResponseEventStorageWrite struct {
 	Properties EventListResponseEventStorageWriteProperties `json:"properties,required"`
 	Type       EventListResponseEventStorageWriteType       `json:"type,required"`
@@ -1236,6 +1306,7 @@ const (
 	EventListResponseTypeMessageUpdated       EventListResponseType = "message.updated"
 	EventListResponseTypeMessageRemoved       EventListResponseType = "message.removed"
 	EventListResponseTypeMessagePartUpdated   EventListResponseType = "message.part.updated"
+	EventListResponseTypeMessagePartRemoved   EventListResponseType = "message.part.removed"
 	EventListResponseTypeStorageWrite         EventListResponseType = "storage.write"
 	EventListResponseTypeSessionUpdated       EventListResponseType = "session.updated"
 	EventListResponseTypeSessionDeleted       EventListResponseType = "session.deleted"
@@ -1247,7 +1318,7 @@ const (

 func (r EventListResponseType) IsKnown() bool {
 	switch r {
-	case EventListResponseTypeLspClientDiagnostics, EventListResponseTypePermissionUpdated, EventListResponseTypeFileEdited, EventListResponseTypeInstallationUpdated, EventListResponseTypeMessageUpdated, EventListResponseTypeMessageRemoved, EventListResponseTypeMessagePartUpdated, EventListResponseTypeStorageWrite, EventListResponseTypeSessionUpdated, EventListResponseTypeSessionDeleted, EventListResponseTypeSessionIdle, EventListResponseTypeSessionError, EventListResponseTypeFileWatcherUpdated, EventListResponseTypeIdeInstalled:
+	case EventListResponseTypeLspClientDiagnostics, EventListResponseTypePermissionUpdated, EventListResponseTypeFileEdited, EventListResponseTypeInstallationUpdated, EventListResponseTypeMessageUpdated, EventListResponseTypeMessageRemoved, EventListResponseTypeMessagePartUpdated, EventListResponseTypeMessagePartRemoved, EventListResponseTypeStorageWrite, EventListResponseTypeSessionUpdated, EventListResponseTypeSessionDeleted, EventListResponseTypeSessionIdle, EventListResponseTypeSessionError, EventListResponseTypeFileWatcherUpdated, EventListResponseTypeIdeInstalled:
 		return true
 	}
 	return false
@@ -175,6 +175,7 @@ func (r *SessionService) Unshare(ctx context.Context, id string, opts ...option.
 type AssistantMessage struct {
 	ID         string                 `json:"id,required"`
 	Cost       float64                `json:"cost,required"`
+	Mode       string                 `json:"mode,required"`
 	ModelID    string                 `json:"modelID,required"`
 	Path       AssistantMessagePath   `json:"path,required"`
 	ProviderID string                 `json:"providerID,required"`
@@ -193,6 +194,7 @@ type AssistantMessage struct {
 type assistantMessageJSON struct {
 	ID          apijson.Field
 	Cost        apijson.Field
+	Mode        apijson.Field
 	ModelID     apijson.Field
 	Path        apijson.Field
 	ProviderID  apijson.Field
@@ -735,6 +737,7 @@ type Message struct {
 	Cost float64     `json:"cost"`
 	// This field can have the runtime type of [AssistantMessageError].
 	Error   interface{} `json:"error"`
+	Mode    string      `json:"mode"`
 	ModelID string      `json:"modelID"`
 	// This field can have the runtime type of [AssistantMessagePath].
 	Path       interface{} `json:"path"`
@@ -756,6 +759,7 @@ type messageJSON struct {
 	Time        apijson.Field
 	Cost        apijson.Field
 	Error       apijson.Field
+	Mode        apijson.Field
 	ModelID     apijson.Field
 	Path        apijson.Field
 	ProviderID  apijson.Field
@@ -825,16 +829,19 @@ func (r MessageRole) IsKnown() bool {
 }

 type Part struct {
-	ID        string         `json:"id,required"`
-	MessageID string         `json:"messageID,required"`
-	SessionID string         `json:"sessionID,required"`
-	Type      PartType       `json:"type,required"`
-	CallID    string         `json:"callID"`
-	Cost      float64        `json:"cost"`
-	Filename  string         `json:"filename"`
-	Mime      string         `json:"mime"`
-	Snapshot  string         `json:"snapshot"`
-	Source    FilePartSource `json:"source"`
+	ID        string   `json:"id,required"`
+	MessageID string   `json:"messageID,required"`
+	SessionID string   `json:"sessionID,required"`
+	Type      PartType `json:"type,required"`
+	CallID    string   `json:"callID"`
+	Cost      float64  `json:"cost"`
+	Filename  string   `json:"filename"`
+	// This field can have the runtime type of [[]string].
+	Files    interface{}    `json:"files"`
+	Hash     string         `json:"hash"`
+	Mime     string         `json:"mime"`
+	Snapshot string         `json:"snapshot"`
+	Source   FilePartSource `json:"source"`
 	// This field can have the runtime type of [ToolPartState].
 	State     interface{} `json:"state"`
 	Synthetic bool        `json:"synthetic"`
@@ -858,6 +865,8 @@ type partJSON struct {
 	CallID      apijson.Field
 	Cost        apijson.Field
 	Filename    apijson.Field
+	Files       apijson.Field
+	Hash        apijson.Field
 	Mime        apijson.Field
 	Snapshot    apijson.Field
 	Source      apijson.Field
@@ -889,13 +898,13 @@ func (r *Part) UnmarshalJSON(data []byte) (err error) {
 // for more type safety.
 //
 // Possible runtime types of the union are [TextPart], [FilePart], [ToolPart],
-// [StepStartPart], [StepFinishPart], [SnapshotPart].
+// [StepStartPart], [StepFinishPart], [SnapshotPart], [PartPatchPart].
 func (r Part) AsUnion() PartUnion {
 	return r.union
 }

 // Union satisfied by [TextPart], [FilePart], [ToolPart], [StepStartPart],
-// [StepFinishPart] or [SnapshotPart].
+// [StepFinishPart], [SnapshotPart] or [PartPatchPart].
 type PartUnion interface {
 	implementsPart()
 }
@@ -934,9 +943,60 @@ func init() {
 			Type:               reflect.TypeOf(SnapshotPart{}),
 			DiscriminatorValue: "snapshot",
 		},
+		apijson.UnionVariant{
+			TypeFilter:         gjson.JSON,
+			Type:               reflect.TypeOf(PartPatchPart{}),
+			DiscriminatorValue: "patch",
+		},
 	)
 }

+type PartPatchPart struct {
+	ID        string            `json:"id,required"`
+	Files     []string          `json:"files,required"`
+	Hash      string            `json:"hash,required"`
+	MessageID string            `json:"messageID,required"`
+	SessionID string            `json:"sessionID,required"`
+	Type      PartPatchPartType `json:"type,required"`
+	JSON      partPatchPartJSON `json:"-"`
+}
+
+// partPatchPartJSON contains the JSON metadata for the struct [PartPatchPart]
+type partPatchPartJSON struct {
+	ID          apijson.Field
+	Files       apijson.Field
+	Hash        apijson.Field
+	MessageID   apijson.Field
+	SessionID   apijson.Field
+	Type        apijson.Field
+	raw         string
+	ExtraFields map[string]apijson.Field
+}
+
+func (r *PartPatchPart) UnmarshalJSON(data []byte) (err error) {
+	return apijson.UnmarshalRoot(data, r)
+}
+
+func (r partPatchPartJSON) RawJSON() string {
+	return r.raw
+}
+
+func (r PartPatchPart) implementsPart() {}
+
+type PartPatchPartType string
+
+const (
+	PartPatchPartTypePatch PartPatchPartType = "patch"
+)
+
+func (r PartPatchPartType) IsKnown() bool {
+	switch r {
+	case PartPatchPartTypePatch:
+		return true
+	}
+	return false
+}
+
 type PartType string

 const (
@@ -946,11 +1006,12 @@ const (
 	PartTypeStepStart  PartType = "step-start"
 	PartTypeStepFinish PartType = "step-finish"
 	PartTypeSnapshot   PartType = "snapshot"
+	PartTypePatch      PartType = "patch"
 )

 func (r PartType) IsKnown() bool {
 	switch r {
-	case PartTypeText, PartTypeFile, PartTypeTool, PartTypeStepStart, PartTypeStepFinish, PartTypeSnapshot:
+	case PartTypeText, PartTypeFile, PartTypeTool, PartTypeStepStart, PartTypeStepFinish, PartTypeSnapshot, PartTypePatch:
 		return true
 	}
 	return false
@@ -66,6 +66,7 @@ export default defineConfig({
        "docs/ide",
        "docs/share",
        "docs/modes",
+        "docs/agents",
        "docs/rules",
        "docs/config",
        "docs/models",
@@ -0,0 +1,181 @@
+---
+title: Agents
+description: Configure and use specialized agents in opencode.
+---
+
+Agents are specialized AI assistants that can be configured for specific tasks and workflows. They allow you to create focused tools with custom prompts, models, and tool access.
+
+## Creating Agents
+
+You can create new agents using the `opencode agent create` command. This interactive command will:
+
+1. Ask where to save the agent (global or project-specific)
+2. Prompt for a description of what the agent should do
+3. Generate an appropriate system prompt and identifier
+4. Let you select which tools the agent can access
+5. Create a markdown file with the agent configuration
+
+```bash
+opencode agent create
+```
+
+The command will guide you through the process and automatically generate a well-structured agent based on your requirements.
+
+## Built-in Agents
+
+opencode comes with a built-in `general` agent:
+
+- **general** - General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. Use this when searching for keywords or files and you're not confident you'll find the right match in the first few tries.
+
+## Configuration
+
+Agents can be configured in your `opencode.json` config file or as markdown files.
+
+### JSON Configuration
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "code-reviewer": {
+      "description": "Reviews code for best practices and potential issues",
+      "model": "anthropic/claude-sonnet-4-20250514",
+      "prompt": "You are a code reviewer. Focus on security, performance, and maintainability.",
+      "tools": {
+        "write": false,
+        "edit": false
+      }
+    },
+    "test-writer": {
+      "description": "Specialized agent for writing comprehensive tests",
+      "prompt": "You are a test writing specialist. Write thorough, maintainable tests.",
+      "tools": {
+        "bash": true,
+        "read": true,
+        "write": true
+      }
+    }
+  }
+}
+```
+
+### Markdown Configuration
+
+You can also define agents using markdown files. Place them in:
+
+- Global: `~/.config/opencode/agent/`
+- Project: `.opencode/agent/`
+
+```markdown title="~/.config/opencode/agent/code-reviewer.md"
+---
+description: Reviews code for best practices and potential issues
+model: anthropic/claude-sonnet-4-20250514
+tools:
+  write: false
+  edit: false
+---
+
+You are a code reviewer with expertise in security, performance, and maintainability.
+
+Focus on:
+
+- Security vulnerabilities
+- Performance bottlenecks
+- Code maintainability
+- Best practices adherence
+```
+
+## Agent Properties
+
+### Required
+
+- **description** - Brief description of what the agent does and when to use it
+
+### Optional
+
+- **model** - Specific model to use (defaults to your configured model)
+- **prompt** - Custom system prompt for the agent
+- **tools** - Object specifying which tools the agent can access (true/false for each tool)
+- **disable** - Set to true to disable the agent
+
+## Tool Access
+
+By default, agents inherit the same tool access as the main assistant. You can restrict or enable specific tools:
+
+```json
+{
+  "agent": {
+    "readonly-agent": {
+      "description": "Read-only agent for analysis",
+      "tools": {
+        "write": false,
+        "edit": false,
+        "bash": false
+      }
+    }
+  }
+}
+```
+
+Common tools you might want to control:
+
+- `write` - Create new files
+- `edit` - Modify existing files
+- `bash` - Execute shell commands
+- `read` - Read files
+- `glob` - Search for files
+- `grep` - Search file contents
+
+## Using Agents
+
+Agents are automatically available through the Task tool when configured. The main assistant will use them for specialized tasks based on their descriptions.
+
+## Best Practices
+
+1. **Clear descriptions** - Write specific descriptions that help the main assistant know when to use each agent
+2. **Focused prompts** - Keep agent prompts focused on their specific role
+3. **Appropriate tool access** - Only give agents the tools they need for their tasks
+4. **Consistent naming** - Use descriptive, consistent names for your agents
+5. **Project-specific agents** - Use `.opencode/agent/` for project-specific workflows
+
+## Examples
+
+### Documentation Agent
+
+```markdown title="~/.config/opencode/agent/docs-writer.md"
+---
+description: Writes and maintains project documentation
+tools:
+  bash: false
+---
+
+You are a technical writer. Create clear, comprehensive documentation.
+
+Focus on:
+
+- Clear explanations
+- Proper structure
+- Code examples
+- User-friendly language
+```
+
+### Security Auditor
+
+```markdown title="~/.config/opencode/agent/security-auditor.md"
+---
+description: Performs security audits and identifies vulnerabilities
+tools:
+  write: false
+  edit: false
+---
+
+You are a security expert. Focus on identifying potential security issues.
+
+Look for:
+
+- Input validation vulnerabilities
+- Authentication and authorization flaws
+- Data exposure risks
+- Dependency vulnerabilities
+- Configuration security issues
+```
@@ -50,9 +50,9 @@ opencode comes with two built-in modes: _build_, the default with all tools enab
 {
  "$schema": "https://opencode.ai/config.json",
  "mode": {
-    "build": { },
-    "plan": { },
-    "my-custom-mode": { }
+    "build": {},
+    "plan": {},
+    "my-custom-mode": {}
  }
 }
 ```
@@ -181,6 +181,31 @@ about rules here](/docs/rules).

 ---

+### Agents
+
+You can configure specialized agents for specific tasks through the `agent` option.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "agent": {
+    "code-reviewer": {
+      "description": "Reviews code for best practices and potential issues",
+      "model": "anthropic/claude-sonnet-4-20250514",
+      "prompt": "You are a code reviewer. Focus on security, performance, and maintainability.",
+      "tools": {
+        "write": false,
+        "edit": false
+      }
+    }
+  }
+}
+```
+
+You can also define agents using markdown files in `~/.config/opencode/agent/` or `.opencode/agent/`. [Learn more here](/docs/agents).
+
+---
+
 ### Disabled providers

 You can disable providers that are loaded automatically through the `disabled_providers` option. This is useful when you want to prevent certain providers from being loaded even if their credentials are available.
@@ -9,7 +9,21 @@ import { Tabs, TabItem } from "@astrojs/starlight/components"

 ![opencode TUI with the opencode theme](../../../assets/lander/screenshot.png)

-Let's start by installing opencode.
+Let's get started.
+
+---
+
+#### Prerequisites
+
+To use opencode, you'll need:
+
+1. A modern terminal emulator like:
+   - [WezTerm](https://wezterm.org), cross-platform
+   - [Alacritty](https://alacritty.org), cross-platform
+   - [Ghostty](https://ghostty.org), Linux and macOS
+   - [Kitty](https://sw.kovidgoyal.net/kitty/), Linux and macOS
+
+2. API keys for the LLM providers you want to use.

 ---

@@ -190,10 +204,17 @@ You can ask opencode to add new features to your project. Though we first recomm
   Once it gives you a plan, you can give it feedback or add more details.
   
   ```txt frame="none"
-   We'd like to design this new screen using the design we are already using.
-   There's an example of a list of notes in @packages/web/src/components/NoteList.tsx
+   We'd like to design this new screen using a design I've used before.
+   [Image #1] Take a look at this image and use it as a reference.
   ```

+   :::tip
+   Drag and drop images into the terminal to add them to the prompt.
+   :::
+
+   opencode can scan any images you give it and add them to the prompt. You can
+   do this by dragging and dropping an image into the terminal.
+
 3. **Build the feature**
   
   Once you feel comfortable with the plan, switch back to _Build mode_ by
@@ -97,6 +97,51 @@ Use the `model` config to override the default model for this mode. Useful for u

 ---

+### Temperature
+
+Control the randomness and creativity of the AI's responses with the `temperature` config. Lower values make responses more focused and deterministic, while higher values increase creativity and variability.
+
+```json title="opencode.json"
+{
+  "mode": {
+    "plan": {
+      "temperature": 0.1
+    },
+    "creative": {
+      "temperature": 0.8
+    }
+  }
+}
+```
+
+Temperature values typically range from 0.0 to 1.0:
+
+- **0.0-0.2**: Very focused and deterministic responses, ideal for code analysis and planning
+- **0.3-0.5**: Balanced responses with some creativity, good for general development tasks
+- **0.6-1.0**: More creative and varied responses, useful for brainstorming and exploration
+
+```json title="opencode.json"
+{
+  "mode": {
+    "analyze": {
+      "temperature": 0.1,
+      "prompt": "{file:./prompts/analysis.txt}"
+    },
+    "build": {
+      "temperature": 0.3
+    },
+    "brainstorm": {
+      "temperature": 0.7,
+      "prompt": "{file:./prompts/creative.txt}"
+    }
+  }
+}
+```
+
+If no temperature is specified, opencode uses model-specific defaults (typically 0 for most models, 0.55 for Qwen models).
+
+---
+
 ### Prompt

 Specify a custom system prompt file for this mode with the `prompt` config. The prompt file should contain instructions specific to the mode's purpose.
Author	SHA1	Message	Date
Dax Raad	10ae43a121	wip: sync publish / publish (push) Has been cancelled Details	2025-07-25 15:52:27 -04:00
Dax Raad	c85b970903	wip: drop	2025-07-25 15:51:02 -04:00
Dax Raad	7044662cfa	handle uploaded text/plain	2025-07-25 15:48:42 -04:00
kehanzhang	92656fdf29	fix(headless): respect mode passed to /message endpoint (#1300 )	2025-07-25 15:26:49 -04:00
Dax Raad	c65e7aff86	docs: mode temperature	2025-07-25 13:45:04 -04:00
Dax Raad	e97613ef9f	allow temperature to be configured per mode publish / publish (push) Has been cancelled Details	2025-07-25 13:29:44 -04:00
Dominik Engelhardt	827469c725	fix: apply content-level caching for non-anthropic providers (#1305 )	2025-07-25 12:19:44 -04:00
Yihui Khuu	613b5fbe48	feat: add csharp lsp (#1312 )	2025-07-25 12:17:06 -04:00
Dax Raad	7ed05962db	fix issue with trailing whitespace error in assistant message	2025-07-25 10:56:16 -04:00
Dax Raad	250a86ec52	fix reading model from config publish / publish (push) Has been cancelled Details	2025-07-25 10:53:37 -04:00
Yihui Khuu	0795a577e0	fix: header width to display header in one line when sharing disabled (#1310 )	2025-07-25 09:32:06 -05:00
Dax Raad	8e5607f9c0	fix double system prompt	2025-07-25 10:28:42 -04:00
Dax Raad	d6b3bb0807	disable todo tools by default in agent publish / publish (push) Has been cancelled Details	2025-07-25 10:23:23 -04:00
Dax Raad	f307a5ce0b	fix symlinked agents publish / publish (push) Has been cancelled Details	2025-07-25 10:20:16 -04:00
GitHub Action	151c7ed5a2	ignore: update download stats 2025-07-25	2025-07-25 12:04:21 +00:00
Dax Raad	fc13d057f8	agents better display when spawning publish / publish (push) Has been cancelled Details	2025-07-24 23:08:03 -04:00
Dax Raad	fc73d3c523	docs: agents publish / publish (push) Has been cancelled Details	2025-07-24 22:18:49 -04:00
Dax Raad	5d871b2075	docs: agents	2025-07-24 22:16:16 -04:00
Dax Raad	529a171d51	docs: agents	2025-07-24 22:07:30 -04:00
Dax Raad	8dcd39f5b7	real life totally configurabl ai subasians publish / publish (push) Has been cancelled Details	2025-07-24 21:21:02 -04:00
Frank	88477b3ee7	wip: github actions	2025-07-24 19:03:10 -04:00
Jay V	0c7e529e6d	docs: add to quick start	2025-07-24 18:57:54 -04:00
Filip	01f75839a9	Fix: added environment() to summarize() (#1290 )	2025-07-24 18:24:54 -04:00
Dax Raad	4306f1a339	wip: handle deleting file	2025-07-24 17:49:23 -04:00
Dax Raad	aa2a5057ac	wip: fix type errors	2025-07-24 17:38:11 -04:00
Dax Raad	284c01018e	wip: more snapshot stuff	2025-07-24 17:38:11 -04:00
Aiden Cline	22c9e2942b	(tui) tweak: add setting for scroll speed (#1288 )	2025-07-24 16:34:59 -05:00
Clay Warren	d50ae8e4d4	feat: Replace unzip with @zip.js/zip.js for Windows compatibility (#662 )	2025-07-24 16:49:04 -04:00
Filip	e9074e60cf	fix: add custom() to system prompt on summarize (#1289 )	2025-07-24 16:48:17 -04:00
Filip	541a7a39d3	fix: edit tool (#1287 )	2025-07-24 16:18:04 -04:00