feat(core): add pinned Code Mode tools

bun.lock

@@ -147,11 +147,6 @@
         "ws": "8.21.0",
       },
       "devDependencies": {
-        "@ff-labs/fff-bin-darwin-arm64": "0.10.1",
-        "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.1",
-        "@ff-labs/fff-bin-linux-x64-gnu": "0.10.1",
-        "@ff-labs/fff-bin-win32-arm64": "0.10.1",
-        "@ff-labs/fff-bin-win32-x64": "0.10.1",
         "@lydell/node-pty-darwin-arm64": "1.2.0-beta.12",
         "@lydell/node-pty-darwin-x64": "1.2.0-beta.12",
         "@lydell/node-pty-linux-arm64": "1.2.0-beta.12",
@@ -169,11 +164,6 @@
         "@types/bun": "catalog:",
         "@types/semver": "catalog:",
         "@typescript/native-preview": "catalog:",
-        "@yuuang/ffi-rs-darwin-arm64": "1.3.2",
-        "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.2",
-        "@yuuang/ffi-rs-linux-x64-gnu": "1.3.2",
-        "@yuuang/ffi-rs-win32-arm64-msvc": "1.3.2",
-        "@yuuang/ffi-rs-win32-x64-msvc": "1.3.2",
         "vite": "catalog:",
         "vite-plugin-solid": "catalog:",
       },
@@ -374,7 +364,6 @@
         "@effect/platform-node": "catalog:",
         "@effect/sql-sqlite-bun": "catalog:",
         "@ff-labs/fff-bun": "0.10.1",
-        "@ff-labs/fff-node": "0.10.1",
         "@lydell/node-pty": "catalog:",
         "@modelcontextprotocol/sdk": "1.29.0",
         "@opencode-ai/ai": "workspace:*",
@@ -1677,8 +1666,6 @@
 
     "@ff-labs/fff-bun": ["@ff-labs/fff-bun@0.10.1", "", { "optionalDependencies": { "@ff-labs/fff-bin-android-arm64": "0.10.1", "@ff-labs/fff-bin-darwin-arm64": "0.10.1", "@ff-labs/fff-bin-darwin-x64": "0.10.1", "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.1", "@ff-labs/fff-bin-linux-arm64-musl": "0.10.1", "@ff-labs/fff-bin-linux-x64-gnu": "0.10.1", "@ff-labs/fff-bin-linux-x64-musl": "0.10.1", "@ff-labs/fff-bin-win32-arm64": "0.10.1", "@ff-labs/fff-bin-win32-x64": "0.10.1" }, "os": [ "!aix", "!sunos", "!freebsd", "!openbsd", ], "cpu": [ "x64", "arm64", ] }, "sha512-9oUCxypGbf2q3vNfKZ31wdzt5KqjhA9S6TwQaFol/j1lkSHVGvtIa3RvdGHPs1UUuvR/MO7b6pHj054BR9bXPQ=="],
 
-    "@ff-labs/fff-node": ["@ff-labs/fff-node@0.10.1", "", { "dependencies": { "ffi-rs": "^1.0.0" }, "optionalDependencies": { "@ff-labs/fff-bin-android-arm64": "0.10.1", "@ff-labs/fff-bin-darwin-arm64": "0.10.1", "@ff-labs/fff-bin-darwin-x64": "0.10.1", "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.1", "@ff-labs/fff-bin-linux-arm64-musl": "0.10.1", "@ff-labs/fff-bin-linux-x64-gnu": "0.10.1", "@ff-labs/fff-bin-linux-x64-musl": "0.10.1", "@ff-labs/fff-bin-win32-arm64": "0.10.1", "@ff-labs/fff-bin-win32-x64": "0.10.1" }, "os": [ "!aix", "!sunos", "!freebsd", "!openbsd", ], "cpu": [ "x64", "arm64", ] }, "sha512-I2TIWHkey4wpLCncUQymBz/yWrjp/TE91yjrPvSLaPMUMRf3wXwEmelGNnZ5ynxy3cUauYg5b5hsUwhOK4skfA=="],
-
     "@floating-ui/core": ["@floating-ui/core@1.8.0", "", { "dependencies": { "@floating-ui/utils": "^0.2.12" } }, "sha512-0CIZ5itps/8x7BG8dEIhs53BvCUH2PCoogtakwRTut+Arm58sJooJ0AuZhLw2HJYIR5cMLNPBSS728sPho2khQ=="],
 
     "@floating-ui/dom": ["@floating-ui/dom@1.8.0", "", { "dependencies": { "@floating-ui/core": "^1.8.0", "@floating-ui/utils": "^0.2.12" } }, "sha512-yXSrzeHZBTZadLOlfyhCkJHNeLJnHRnRInwdZ40L7ZiaAtrBwoYlsDrX3v5zB1Utk7CLfzcOVnVVWoXEky7Ceg=="],
@@ -3313,28 +3300,6 @@
 
     "@xmldom/xmldom": ["@xmldom/xmldom@0.8.13", "", {}, "sha512-KRYzxepc14G/CEpEGc3Yn+JKaAeT63smlDr+vjB8jRfgTBBI9wRj/nkQEO+ucV8p8I9bfKLWp37uHgFrbntPvw=="],
 
-    "@yuuang/ffi-rs-android-arm64": ["@yuuang/ffi-rs-android-arm64@1.3.2", "", { "os": "android", "cpu": "arm64" }, "sha512-eDYLT0kVBkp7e2BwdRDmt6N1rkeDPUHDefk3ZX0/nok+GLsqfy1WBoSL3Yg7HVXN1EyW8OBVc2uK8Zq8HbmaSA=="],
-
-    "@yuuang/ffi-rs-darwin-arm64": ["@yuuang/ffi-rs-darwin-arm64@1.3.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-kRdgPaOM6TfuC5wHUwstlatk4HNie2lwSLJWQL2LiAUIJ7+96CoiWUNVhwBcFrhdfxhnWenYS6F668CV0vit8Q=="],
-
-    "@yuuang/ffi-rs-darwin-x64": ["@yuuang/ffi-rs-darwin-x64@1.3.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-O3AlVgre8FQcZRJe44Xs7A6iDLumoPXqbw40+eJCa2gyXaXyLPdHoWrS1W9rBCa1QZRRnG7zRulPVFw8C5uo8g=="],
-
-    "@yuuang/ffi-rs-linux-arm-gnueabihf": ["@yuuang/ffi-rs-linux-arm-gnueabihf@1.3.2", "", { "os": "linux", "cpu": "arm" }, "sha512-IXiNdTbIcTCPny5eeElijFWYeKSJjQWSjt9ZyJNdLHYiB1Np+XD6K7wNZS6EOMgMelhW1kQE62T654skGkVDIA=="],
-
-    "@yuuang/ffi-rs-linux-arm64-gnu": ["@yuuang/ffi-rs-linux-arm64-gnu@1.3.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-gWFO6xufUK9lPYUqDvKa6IR243dPqdetgl9Q7HrZWaDu7wLo06QQrosw8QTzndafQnOcBKm6LoLujmGCfTgJOA=="],
-
-    "@yuuang/ffi-rs-linux-arm64-musl": ["@yuuang/ffi-rs-linux-arm64-musl@1.3.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-lejvOSqypPziQH5rzfkDlJ6e92qhWbDutE9ttOO6z5I2k83zoh9iZhZWhaXSU5VqgQpcshRkrbtXb9gy1ft5dA=="],
-
-    "@yuuang/ffi-rs-linux-x64-gnu": ["@yuuang/ffi-rs-linux-x64-gnu@1.3.2", "", { "os": "linux", "cpu": "x64" }, "sha512-s8VCFazaJKmgY2hgMTpWk4TtBY/zy5ovbaGgwyY0FvBD0YvyhcET4IrMsDJpHhFVTPCYfKZ1dN45clD/YiFp6g=="],
-
-    "@yuuang/ffi-rs-linux-x64-musl": ["@yuuang/ffi-rs-linux-x64-musl@1.3.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Ahr5chfKZKWUik20bEZRug+be57LZ2yYrtolyjSRoo7A4ZniBUHBZUNWm6TD6i0CJayqyxWeVk/XiaABD8bY0w=="],
-
-    "@yuuang/ffi-rs-win32-arm64-msvc": ["@yuuang/ffi-rs-win32-arm64-msvc@1.3.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-yhpLcj0qel5VNlpzxPZfNmi7+rEX8444QHjUP6WWLxdRfqPllROu/Cp3OpkBpw3BLdxfcDhWkjWMD5QsJN0Pvg=="],
-
-    "@yuuang/ffi-rs-win32-ia32-msvc": ["@yuuang/ffi-rs-win32-ia32-msvc@1.3.2", "", { "os": "win32", "cpu": [ "x64", "ia32", ] }, "sha512-BFVSbdtg/7mJBw5kQFOPKFiA+SF7z3240HpzHN81Umm4Bp4dWkyx0msYn8+Q7/BBJiLQ4F6bi3Nftk58YA9r9w=="],
-
-    "@yuuang/ffi-rs-win32-x64-msvc": ["@yuuang/ffi-rs-win32-x64-msvc@1.3.2", "", { "os": "win32", "cpu": "x64" }, "sha512-ZL5MJ76n2rjwGo26kCWW7wK6QT/cee00Rx8pfW79pz6vM6jqfhoE7zTnwFiw4aOQUes9+HUc5DeeJ3z+Vb9oLg=="],
-
     "@zip.js/zip.js": ["@zip.js/zip.js@2.7.62", "", {}, "sha512-OaLvZ8j4gCkLn048ypkZu29KX30r8/OfFF2w4Jo5WXFr+J04J+lzJ5TKZBVgFXhlvSkqNFQdfnY1Q8TMTCyBVA=="],
 
     "abbrev": ["abbrev@4.0.0", "", {}, "sha512-a1wflyaL0tHtJSmLSOVybYhy22vRih4eduhhrkcjgrWGnRfrZtovJ2FRjxuTtkkj47O/baf0R86QU5OuYpz8fA=="],
@@ -4119,8 +4084,6 @@
 
     "fetchdts": ["fetchdts@0.1.7", "", {}, "sha512-YoZjBdafyLIop9lSxXVI33oLD5kN31q4Td+CasofLLYeLXRFeOsuOw0Uo+XNRi9PZlbfdlN2GmRtm4tCEQ9/KA=="],
 
-    "ffi-rs": ["ffi-rs@1.3.2", "", { "optionalDependencies": { "@yuuang/ffi-rs-android-arm64": "1.3.2", "@yuuang/ffi-rs-darwin-arm64": "1.3.2", "@yuuang/ffi-rs-darwin-x64": "1.3.2", "@yuuang/ffi-rs-linux-arm-gnueabihf": "1.3.2", "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.2", "@yuuang/ffi-rs-linux-arm64-musl": "1.3.2", "@yuuang/ffi-rs-linux-x64-gnu": "1.3.2", "@yuuang/ffi-rs-linux-x64-musl": "1.3.2", "@yuuang/ffi-rs-win32-arm64-msvc": "1.3.2", "@yuuang/ffi-rs-win32-ia32-msvc": "1.3.2", "@yuuang/ffi-rs-win32-x64-msvc": "1.3.2" } }, "sha512-4s8dX9VbBw/jd5NOuE3EJRqXaIVdjMyiumeeDzrOhtjQRwp6Bz2za7iksWXTnvTQKV/tTdm1s1w7mObe92zPjQ=="],
-
     "filelist": ["filelist@1.0.6", "", { "dependencies": { "minimatch": "^5.0.1" } }, "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA=="],
 
     "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],

packages/ai/src/protocols/anthropic-messages.ts

@@ -7,7 +7,6 @@ import { Protocol } from "../route/protocol"
 import {
   LLMError,
   LLMEvent,
-  mergeJsonRecords,
   Usage,
   type CacheHint,
   type FinishReasonDetails,
@@ -235,27 +234,12 @@ const AnthropicBodyFields = {
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
-const AnthropicUsage = Schema.StructWithRest(
-  Schema.Struct({
-    input_tokens: Schema.optional(Schema.Number),
-    output_tokens: Schema.optional(Schema.Number),
-    cache_creation_input_tokens: optionalNull(Schema.Number),
-    cache_read_input_tokens: optionalNull(Schema.Number),
-    server_tool_use: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({ web_search_requests: Schema.optional(Schema.Number) }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-    output_tokens_details: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({ thinking_tokens: Schema.optional(Schema.Number) }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
+const AnthropicUsage = Schema.Struct({
+  input_tokens: Schema.optional(Schema.Number),
+  output_tokens: Schema.optional(Schema.Number),
+  cache_creation_input_tokens: optionalNull(Schema.Number),
+  cache_read_input_tokens: optionalNull(Schema.Number),
+})
 type AnthropicUsage = Schema.Schema.Type<typeof AnthropicUsage>
 
 const AnthropicStreamBlock = Schema.Struct({
@@ -682,8 +666,9 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // `input_tokens` is the *non-cached* count per the Messages API docs, with
 // cache reads and writes as separate fields. We sum them to derive the
 // inclusive `inputTokens` the rest of the contract expects. Extended
-// thinking tokens are included in `output_tokens`; newer responses also
-// expose that subset through `output_tokens_details.thinking_tokens`.
+// thinking tokens are *not* broken out by Anthropic — they're billed as
+// part of `output_tokens`, so `reasoningTokens` stays `undefined` and
+// `outputTokens` carries the combined total.
 const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
   if (!usage) return undefined
   const nonCached = usage.input_tokens
@@ -696,7 +681,6 @@ const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cacheRead,
     cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
     providerMetadata: { anthropic: usage },
   })
@@ -715,18 +699,18 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined) => {
   const cacheWriteInputTokens = right.cacheWriteInputTokens ?? left.cacheWriteInputTokens
   const inputTokens = ProviderShared.sumTokens(nonCachedInputTokens, cacheReadInputTokens, cacheWriteInputTokens)
   const outputTokens = right.outputTokens ?? left.outputTokens
-  const reasoningTokens = right.reasoningTokens ?? left.reasoningTokens
   return new Usage({
     inputTokens,
     outputTokens,
     nonCachedInputTokens,
     cacheReadInputTokens,
     cacheWriteInputTokens,
-    reasoningTokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
     providerMetadata: {
-      anthropic:
-        mergeJsonRecords(left.providerMetadata?.["anthropic"], right.providerMetadata?.["anthropic"]) ?? {},
+      anthropic: {
+        ...left.providerMetadata?.["anthropic"],
+        ...right.providerMetadata?.["anthropic"],
+      },
     },
   })
 }

packages/ai/src/schema/events.ts

@@ -40,9 +40,9 @@ import { ProviderFailureClassification } from "./errors"
  * - Anthropic and Bedrock report the input breakdown natively: Anthropic's
  *   `input_tokens` and Bedrock's `inputTokens` are non-cached only. Their
  *   mappers sum the breakdown to derive the inclusive `inputTokens`.
- *   Anthropic's `outputTokens` includes extended thinking. Newer responses
- *   expose that subset as `output_tokens_details.thinking_tokens`, which maps
- *   to `reasoningTokens`; older responses leave it undefined.
+ *   Anthropic does *not* break extended-thinking out of `output_tokens`, so
+ *   `reasoningTokens` is `undefined` and `outputTokens` carries the
+ *   combined total — a documented limitation of the Anthropic API.
  *
  * `providerMetadata` always carries the provider's raw usage payload —
  * keyed by provider name (`{ openai: ... }`, `{ anthropic: ... }`, etc.)

packages/ai/test/provider/anthropic-messages.test.ts

@@ -543,66 +543,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("maps thinking tokens and preserves unknown Anthropic usage fields", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "message_start",
-                message: {
-                  usage: {
-                    input_tokens: 5,
-                    cache_read_input_tokens: 2,
-                    service_tier: "standard",
-                    cache_creation: { ephemeral_5m_input_tokens: 1 },
-                    server_tool_use: { web_search_requests: 1, start_counter: 2 },
-                    output_tokens_details: { thinking_tokens: 3, start_detail: "preserved" },
-                  },
-                },
-              },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "end_turn" },
-                usage: {
-                  output_tokens: 8,
-                  server_tool_use: { web_search_requests: 2, terminal_counter: 3 },
-                  output_tokens_details: { terminal_detail: "preserved" },
-                  future_terminal: { requests: 4 },
-                },
-              },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.usage).toMatchObject({
-        inputTokens: 7,
-        outputTokens: 8,
-        reasoningTokens: 3,
-        totalTokens: 15,
-        providerMetadata: {
-          anthropic: {
-            input_tokens: 5,
-            cache_read_input_tokens: 2,
-            service_tier: "standard",
-            cache_creation: { ephemeral_5m_input_tokens: 1 },
-            server_tool_use: { web_search_requests: 2, start_counter: 2, terminal_counter: 3 },
-            output_tokens: 8,
-            output_tokens_details: {
-              thinking_tokens: 3,
-              start_detail: "preserved",
-              terminal_detail: "preserved",
-            },
-            future_terminal: { requests: 4 },
-          },
-        },
-      })
-    }),
-  )
-
   it.effect("round-trips omitted thinking carried only by a signature delta", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(

packages/cli/package.json

@@ -56,16 +56,6 @@
     "@lydell/node-pty-linux-x64": "1.2.0-beta.12",
     "@lydell/node-pty-win32-arm64": "1.2.0-beta.12",
     "@lydell/node-pty-win32-x64": "1.2.0-beta.12",
-    "@ff-labs/fff-bin-darwin-arm64": "0.10.1",
-    "@ff-labs/fff-bin-linux-arm64-gnu": "0.10.1",
-    "@ff-labs/fff-bin-linux-x64-gnu": "0.10.1",
-    "@ff-labs/fff-bin-win32-arm64": "0.10.1",
-    "@ff-labs/fff-bin-win32-x64": "0.10.1",
-    "@yuuang/ffi-rs-darwin-arm64": "1.3.2",
-    "@yuuang/ffi-rs-linux-arm64-gnu": "1.3.2",
-    "@yuuang/ffi-rs-linux-x64-gnu": "1.3.2",
-    "@yuuang/ffi-rs-win32-arm64-msvc": "1.3.2",
-    "@yuuang/ffi-rs-win32-x64-msvc": "1.3.2",
     "@parcel/watcher-darwin-arm64": "2.5.1",
     "@parcel/watcher-linux-arm64-glibc": "2.5.1",
     "@parcel/watcher-linux-x64-glibc": "2.5.1",

packages/cli/script/node-assets.ts

@@ -37,8 +37,6 @@ export async function collectNodeAssets(target: NodeTarget) {
       ...(target.platform === "linux" ? { libc: "glibc" as const } : {}),
     }),
     { key: target.parcelWatcherAsset, source: fileURLToPath(import.meta.resolve(target.parcelWatcherPackage)) },
-    { key: target.fffAsset, source: fileURLToPath(import.meta.resolve(target.fffPackage)) },
-    { key: target.fffFfiAsset, source: fileURLToPath(import.meta.resolve(target.fffFfiPackage)) },
     {
       key: photonWasmAsset,
       source: fileURLToPath(import.meta.resolve(photonWasmAsset)),

packages/cli/src/node/target.ts

@@ -11,8 +11,6 @@ export function nodeTarget(platform: string, arch: string) {
   const targetArch = arch as "arm64" | "x64"
   const nodePtyPackage = `@lydell/node-pty-${targetPlatform}-${targetArch}`
   const parcelWatcherPackage = `@parcel/watcher-${targetPlatform}-${targetArch}${targetPlatform === "linux" ? "-glibc" : ""}`
-  const fffPackage = `@ff-labs/fff-bin-${targetPlatform}-${targetArch}${targetPlatform === "linux" ? "-gnu" : ""}`
-  const fffFfiPackage = `@yuuang/ffi-rs-${targetPlatform}-${targetArch}${targetPlatform === "linux" ? "-gnu" : targetPlatform === "win32" ? "-msvc" : ""}`
 
   return {
     platform: targetPlatform,
@@ -21,10 +19,6 @@ export function nodeTarget(platform: string, arch: string) {
     nodePtyEntryAsset: `${nodePtyPackage}/lib/index.js`,
     parcelWatcherPackage,
     parcelWatcherAsset: `${parcelWatcherPackage}/watcher.node`,
-    fffPackage,
-    fffAsset: `${fffPackage}/${targetPlatform === "darwin" ? "libfff_c.dylib" : targetPlatform === "win32" ? "fff_c.dll" : "libfff_c.so"}`,
-    fffFfiPackage,
-    fffFfiAsset: `${fffFfiPackage}/ffi-rs.${targetPlatform}-${targetArch}${targetPlatform === "linux" ? "-gnu" : targetPlatform === "win32" ? "-msvc" : ""}.node`,
   }
 }
 

packages/cli/vite.node.config.ts

@@ -30,30 +30,6 @@ function runtimeRequirePlugin(): Plugin {
   }
 }
 
-function fffNodePlugin(): Plugin {
-  return {
-    name: "opencode:fff-node",
-    enforce: "pre",
-    transform(code, id) {
-      const normalized = id.replaceAll("\\", "/")
-      if (normalized.endsWith("/ffi-rs/index.js")) {
-        const start = code.indexOf("if (!nativeBinding) {")
-        if (start === -1) this.error("Failed to rewrite ffi-rs native binding loader")
-        return `const nativeBinding = globalThis.__OPENCODE_FFF_FFI
-const loadError = undefined
-${code.slice(start)}`
-      }
-      if (!normalized.endsWith("/fff-node/dist/src/binary.js")) return
-      const transformed = code.replace(
-        "export function findBinary() {",
-        "export function findBinary() { if (process.env.FFF_BINARY_PATH) return process.env.FFF_BINARY_PATH;",
-      )
-      if (transformed === code) this.error("Failed to rewrite FFF binary loader")
-      return transformed
-    },
-  }
-}
-
 const resolve = {
   alias: [
     { find: /^solid-js\/store$/, replacement: "solid-js/store/dist/store.js" },
@@ -189,9 +165,6 @@ process.env.OTUI_ASSET_ROOT = __ocAssetRoot
 process.env.OPENCODE_NODE_PTY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.nodePtyEntryAsset)})
 process.env.OPENCODE_PARCEL_WATCHER_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.parcelWatcherAsset)})
 process.env.OPENCODE_PHOTON_WASM_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(photonWasmAsset)})
-process.env.FFF_BINARY_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffAsset)})
-process.env.OPENCODE_FFF_FFI_PATH = __ocPath.join(__ocAssetRoot, ${JSON.stringify(input.target.fffFfiAsset)})
-globalThis.__OPENCODE_FFF_FFI = require(process.env.OPENCODE_FFF_FFI_PATH)
 globalThis.__OPENCODE_PHOTON_WASM_PATH = process.env.OPENCODE_PHOTON_WASM_PATH
 if (process.platform === "linux") process.env.OPENTUI_LIBC = "glibc"`
 }
@@ -210,7 +183,6 @@ export function mainConfig(input: NodeBuildInput): UserConfig {
     plugins: [
       rawTextPlugin(),
       runtimeRequirePlugin(),
-      fffNodePlugin(),
       solid({
         solid: {
           generate: "universal",

packages/core/package.json

@@ -92,7 +92,6 @@
     "@lydell/node-pty": "catalog:",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@ff-labs/fff-bun": "0.10.1",
-    "@ff-labs/fff-node": "0.10.1",
     "@opencode-ai/codemode": "workspace:*",
     "@opencode-ai/effect-drizzle-sqlite": "workspace:*",
     "@opencode-ai/effect-sqlite-node": "workspace:*",

packages/core/src/codemode/catalog.ts

@@ -6,6 +6,7 @@ export const Entry = Schema.Struct({
   path: Schema.String,
   description: Schema.String,
   signature: Schema.String,
+  pinned: Schema.optionalKey(Schema.Literal(true)),
 })
 export type Entry = typeof Entry.Type
 
@@ -31,8 +32,8 @@ const DESCRIPTION_LIMIT = 120
 const CHARACTERS_PER_TOKEN = 4
 const INLINE_BUDGET = 2_000
 
-// Keep every namespace searchable, then select full listings one per namespace per round,
-// considering shorter listings first until the inline budget is exhausted.
+// Keep every namespace searchable and every pinned listing visible, then select additional
+// listings one per namespace per round until the remaining inline budget is exhausted.
 export function summarize(entries: ReadonlyArray<Entry>, budget = INLINE_BUDGET): Summary {
   const namespaces = [...Map.groupBy(entries, (entry) => entry.path.split(".", 1)[0] ?? entry.path)]
     .sort(([left], [right]) => {
@@ -45,44 +46,46 @@ export function summarize(entries: ReadonlyArray<Entry>, budget = INLINE_BUDGET)
         .map((entry) => {
           const firstLine = entry.description.split("\n", 1)[0]?.trim() ?? ""
           const description =
-            firstLine.length > DESCRIPTION_LIMIT
-              ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..."
-              : firstLine
+            firstLine.length > DESCRIPTION_LIMIT ? firstLine.slice(0, DESCRIPTION_LIMIT - 3) + "..." : firstLine
           const suffix = description.length === 0 ? "" : ` // ${description}`
-          return { path: entry.path, line: `  - ${entry.signature}${suffix}` }
+          return { path: entry.path, line: `  - ${entry.signature}${suffix}`, pinned: entry.pinned === true }
         })
         .toSorted((left, right) => {
           if (left.path < right.path) return -1
           if (left.path > right.path) return 1
           return 0
         })
+      const pinned = listings.filter((listing) => listing.pinned)
       return {
         name,
         listings,
-        selectionOrder: rankListings(listings),
-        selectedListings: new Set<typeof Listing.Type>(),
+        selectionOrder: rankListings(listings.filter((listing) => !listing.pinned)),
+        selectedListings: new Set<typeof Listing.Type>(pinned),
+        pinnedCost: pinned.reduce((total, listing) => total + listingCost(listing), 0),
       }
     })
 
   const active = new Set(namespaces)
-  let remaining = budget
+  let remaining = Math.max(0, budget - namespaces.reduce((total, namespace) => total + namespace.pinnedCost, 0))
   while (active.size > 0) {
     for (const namespace of active) {
-      const candidate = namespace.selectionOrder[namespace.selectedListings.size]
+      const candidate = namespace.selectionOrder.shift()
       if (!candidate || candidate.cost > remaining) {
         active.delete(namespace)
         continue
       }
       namespace.selectedListings.add(candidate.listing)
       remaining -= candidate.cost
-      if (namespace.selectedListings.size === namespace.selectionOrder.length) active.delete(namespace)
+      if (namespace.selectionOrder.length === 0) active.delete(namespace)
     }
   }
 
   const namespaceSummaries = namespaces.map((namespace) => ({
     name: namespace.name,
     count: namespace.listings.length,
-    entries: namespace.listings.filter((listing) => namespace.selectedListings.has(listing)),
+    entries: namespace.listings
+      .filter((listing) => namespace.selectedListings.has(listing))
+      .map((listing) => ({ path: listing.path, line: listing.line })),
   }))
   return {
     total: entries.length,
@@ -91,9 +94,13 @@ export function summarize(entries: ReadonlyArray<Entry>, budget = INLINE_BUDGET)
   }
 }
 
+function listingCost(listing: typeof Listing.Type) {
+  return Math.round(listing.line.length / CHARACTERS_PER_TOKEN)
+}
+
 function rankListings(listings: ReadonlyArray<typeof Listing.Type>) {
   return listings
-    .map((listing) => ({ listing, cost: Math.round(listing.line.length / CHARACTERS_PER_TOKEN) }))
+    .map((listing) => ({ listing, cost: listingCost(listing) }))
     .toSorted((left, right) => {
       if (left.cost !== right.cost) return left.cost - right.cost
       if (left.listing.path < right.listing.path) return -1

packages/core/src/filesystem/fff.node.ts

@@ -1,51 +1,71 @@
-import {
-  FileFinder,
-  type DirItem,
-  type DirSearchResult,
-  type FileItem,
-  type GrepCursor,
-  type GrepMatch,
-  type GrepResult,
-  type InitOptions,
-  type MixedItem,
-  type MixedSearchResult,
-  type SearchResult,
-} from "@ff-labs/fff-node"
-
 export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
 
-export type Init = InitOptions
+export interface Init {
+  basePath: string
+  frecencyDbPath?: string
+  historyDbPath?: string
+  useUnsafeNoLock?: boolean
+  disableMmapCache?: boolean
+  disableContentIndexing?: boolean
+  disableWatch?: boolean
+  aiMode?: boolean
+  logFilePath?: string
+  logLevel?: "trace" | "debug" | "info" | "warn" | "error"
+  enableFsRootScanning?: boolean
+  enableHomeDirScanning?: boolean
+}
+
+export interface File {
+  relativePath: string
+  fileName: string
+  modified: number
+}
+
+export interface Directory {
+  relativePath: string
+  dirName: string
+  maxAccessFrecency: number
+}
+
+export type Mixed = { type: "file"; item: File } | { type: "directory"; item: Directory }
 
 export interface Search {
-  items: FileItem[]
-  scores: SearchResult["scores"]
+  items: File[]
+  scores: Array<{ total: number }>
   totalMatched: number
   totalFiles: number
 }
 
 export interface DirSearch {
-  items: DirItem[]
-  scores: DirSearchResult["scores"]
+  items: Directory[]
+  scores: Array<{ total: number }>
   totalMatched: number
   totalDirs: number
 }
 
 export interface MixedSearch {
-  items: MixedItem[]
-  scores: MixedSearchResult["scores"]
+  items: Mixed[]
+  scores: Array<{ total: number }>
   totalMatched: number
   totalFiles: number
   totalDirs: number
 }
 
-export type File = FileItem
-export type Directory = DirItem
-export type Mixed = MixedItem
-export type Cursor = GrepCursor | null
-export type Hit = GrepMatch
+export type Cursor = null
+
+export interface Hit {
+  relativePath: string
+  fileName: string
+  lineNumber: number
+  byteOffset: number
+  lineContent: string
+  matchRanges: [number, number][]
+  contextBefore?: string[]
+  contextAfter?: string[]
+}
 
 export interface Grep {
-  items: GrepResult["items"]
+  items: Hit[]
   totalMatched: number
   totalFilesSearched: number
   totalFiles: number
@@ -108,29 +128,11 @@ export interface Picker {
 }
 
 export function available() {
-  return FileFinder.isAvailable()
+  return false
 }
 
-export function create(opts: Init): Result<Picker> {
-  const made = FileFinder.create(opts)
-  if (!made.ok) return made
-  const pick = made.value
-  return {
-    ok: true,
-    value: {
-      destroy: () => pick.destroy(),
-      isScanning: () => pick.isScanning(),
-      waitForScan: (timeoutMs) => pick.waitForScan(timeoutMs),
-      refreshGitStatus: () => pick.refreshGitStatus(),
-      fileSearch: (query, next) => pick.fileSearch(query, next),
-      glob: (pattern, next) => pick.glob(pattern, next),
-      directorySearch: (query, next) => pick.directorySearch(query, next),
-      mixedSearch: (query, next) => pick.mixedSearch(query, next),
-      grep: (query, next) => pick.grep(query, next),
-      trackQuery: (query, file) => pick.trackQuery(query, file),
-      getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
-    },
-  }
+export function create(_opts: Init): Result<Picker> {
+  return { ok: false, error: "fff unavailable on node runtime" }
 }
 
 export * as Fff from "./fff.node"

packages/core/src/tool/execute.ts

@@ -129,7 +129,14 @@ export const create = (registrations: ReadonlyMap<string, Registration>) => {
 }
 
 export const catalog = (registrations: ReadonlyMap<string, Registration>) => {
-  return runtime(registrations, () => Effect.fail(toolError("Execute context is unavailable"))).catalog()
+  const pinned = new Set(
+    Array.from(registrations.values()).flatMap((registration) =>
+      registration.pinned === true ? [registrationPath(registration)] : [],
+    ),
+  )
+  return runtime(registrations, () => Effect.fail(toolError("Execute context is unavailable")))
+    .catalog()
+    .map((entry) => (pinned.has(entry.path) ? { ...entry, pinned: true as const } : entry))
 }
 
 function runtime(
@@ -140,8 +147,7 @@ function runtime(
   const tools: Record<string, Tool.Tool<never>> = {}
   for (const [name, registration] of registrations) {
     const child = toLLMDefinition(name, registration.tool)
-    const path =
-      registration.namespace === undefined ? registration.name : `${registration.namespace}.${registration.name}`
+    const path = registrationPath(registration)
     tools[path] = Tool.make({
       description: child.description,
       input: child.inputSchema,
@@ -152,6 +158,10 @@ function runtime(
   return CodeMode.make<typeof tools>({ tools, ...hooks })
 }
 
+function registrationPath(registration: Registration) {
+  return registration.namespace === undefined ? registration.name : `${registration.namespace}.${registration.name}`
+}
+
 // Tool inputs arrive as parsed JSON, so the JSON value cast is a boundary fact.
 function displayInput(input: unknown): Record<string, typeof Schema.Json.Type> | undefined {
   if (input === null || input === undefined) return

packages/core/src/tool/registry.ts

@@ -245,6 +245,13 @@ const registryLayer = Layer.effect(
                 }),
               )
             const codemode = options?.codemode ?? true
+            if (!codemode && options?.pinned === true)
+              return yield* Effect.fail(
+                new Tool.RegistrationError({
+                  name: entries[0]?.key ?? "",
+                  message: "Pinned tools must use Code Mode",
+                }),
+              )
             const reserved = codemode ? undefined : entries.find((entry) => entry.key === "execute")
             if (reserved)
               return yield* Effect.fail(

packages/core/test/codemode.test.ts

@@ -10,14 +10,17 @@ describe("CodeMode", () => {
     Effect.gen(function* () {
       const codeMode = yield* CodeMode.Service
       yield* codeMode.register(
-        Tool.registrationEntries({
-          echo: Tool.make({
-            description: "Echo text",
-            input: Schema.Struct({ text: Schema.String }),
-            output: Schema.String,
-            execute: ({ text }) => Effect.succeed({ output: text }),
-          }),
-        }),
+        Tool.registrationEntries(
+          {
+            echo: Tool.make({
+              description: "Echo text",
+              input: Schema.Struct({ text: Schema.String }),
+              output: Schema.String,
+              execute: ({ text }) => Effect.succeed({ output: text }),
+            }),
+          },
+          { pinned: true },
+        ),
       )
 
       const materialized = yield* codeMode.materialize()
@@ -27,6 +30,46 @@ describe("CodeMode", () => {
           path: "echo",
           description: "Echo text",
           signature: "tools.echo(input: {\n  text: string,\n}): Promise<string>",
+          pinned: true,
+        },
+      ])
+    }).pipe(Effect.scoped, Effect.provide(AppNodeBuilder.build(CodeMode.node))),
+  )
+
+  it.effect("omits denied pinned registrations from the catalog", () =>
+    Effect.gen(function* () {
+      const codeMode = yield* CodeMode.Service
+      yield* codeMode.register(
+        Tool.registrationEntries({
+          visible: Tool.make({
+            description: "Visible tool",
+            input: Schema.Struct({}),
+            output: Schema.String,
+            execute: () => Effect.succeed({ output: "visible" }),
+          }),
+        }),
+      )
+      yield* codeMode.register(
+        Tool.registrationEntries(
+          {
+            hidden: Tool.make({
+              description: "Hidden tool",
+              input: Schema.Struct({}),
+              output: Schema.String,
+              execute: () => Effect.succeed({ output: "hidden" }),
+            }),
+          },
+          { permission: "hidden", pinned: true },
+        ),
+      )
+
+      const materialized = yield* codeMode.materialize([{ action: "hidden", resource: "*", effect: "deny" }])
+      expect(materialized.tool).toBeDefined()
+      expect(materialized.catalog).toEqual([
+        {
+          path: "visible",
+          description: "Visible tool",
+          signature: "tools.visible(input: {}): Promise<string>",
         },
       ])
     }).pipe(Effect.scoped, Effect.provide(AppNodeBuilder.build(CodeMode.node))),

packages/core/test/codemode/catalog.test.ts

@@ -57,6 +57,23 @@ describe("CodeModeCatalog.summarize", () => {
     expect(description).toHaveLength(120)
     expect(description).toEndWith("...")
   })
+
+  test("keeps pinned signatures when no unpinned listing fits", () => {
+    const pinned = { ...entry("files.read", "Read a file"), pinned: true as const }
+    const catalog = CodeModeCatalog.summarize([entry("files.write", "Write a file"), pinned], 0)
+
+    expect(catalog).toEqual({
+      total: 2,
+      shown: 1,
+      namespaces: [
+        {
+          name: "files",
+          count: 2,
+          entries: [{ path: pinned.path, line: `  - ${pinned.signature} // Read a file` }],
+        },
+      ],
+    })
+  })
 })
 
 describe("CodeModeInstructions.render", () => {

packages/core/test/session-runner-tool-registry.test.ts

@@ -121,6 +121,17 @@ describe("ToolRegistry", () => {
     }),
   )
 
+  it.effect("rejects pinned tools outside Code Mode", () =>
+    Effect.gen(function* () {
+      const service = yield* ToolRegistry.Service
+      const error = yield* service.register({ echo: make() }, { codemode: false, pinned: true }).pipe(Effect.flip)
+
+      expect(error).toBeInstanceOf(Tool.RegistrationError)
+      expect(error.message).toBe("Pinned tools must use Code Mode")
+      expect((yield* service.snapshot()).definitions).toEqual([])
+    }),
+  )
+
   it.effect("canonicalizes effective definitions and keeps Code Mode last", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service

packages/docs/build/plugins.mdx

@@ -326,12 +326,15 @@ Unsupported characters in tool names are normalized to underscores. Namespace
 segments must begin with a letter, contain at most 64 letters, digits,
 underscores, or hyphens, and are joined with dots. Pass the optional third
 argument to `tools.add` to configure the registration with
-`{ namespace, codemode }`:
+`{ namespace, codemode, pinned }`:
 
 - `namespace` prefixes and groups the exposed tool name.
 - `codemode` defaults to `true` and makes the tool available through the
   `execute` CodeMode tool. Set `codemode: false` to expose it directly to the
   provider.
+- `pinned: true` keeps the tool's complete signature visible when the Code Mode
+  catalog is compact. Pinned tools must use Code Mode and cannot set
+  `codemode: false`.
 
 The executor receives a second context argument containing `sessionID`,
 `agent`, `messageID`, `callID`, and `progress`. A tool with `output`

packages/plugin/src/v2/effect/internal/tool.ts

@@ -129,6 +129,8 @@ export interface RegisterOptions {
   readonly namespace?: string
   /** Defaults to true. False exposes the tool directly to the provider. */
   readonly codemode?: boolean
+  /** Keeps the complete signature visible when the Code Mode catalog is compact. */
+  readonly pinned?: boolean
   /** Permission action used for whole-tool visibility filtering. */
   readonly permission?: string
 }
@@ -138,6 +140,7 @@ export interface Registration {
   readonly name: string
   readonly namespace?: string
   readonly permission: string
+  readonly pinned?: boolean
 }
 
 export const validateName = (name: string) =>
@@ -159,6 +162,7 @@ export const registrationEntries = (
       namespace: options?.namespace,
       tool,
       permission: options?.permission ?? key,
+      ...(options?.pinned === true ? { pinned: true } : {}),
     }
   })
 

packages/plugin/test/tool.test.ts

@@ -125,3 +125,16 @@ test("raw JSON schemas are render-only and omitted output means model-only", asy
   })
   expect(await Effect.runPromise(Tool.decodeInput(tool.input, { value: 1 }))).toEqual({ value: 1 })
 })
+
+test("registration metadata omits disabled pinning", () => {
+  const tool = Tool.make({
+    description: "Echo text",
+    input: Schema.Struct({ text: Schema.String }),
+    output: Schema.String,
+    execute: ({ text }) => Effect.succeed({ output: text }),
+  })
+  const registration = Tool.registrationEntries({ echo: tool })
+
+  expect(Tool.registrationEntries({ echo: tool }, { pinned: false })).toEqual(registration)
+  expect(Tool.registrationEntries({ echo: tool }, { pinned: true })).toEqual([{ ...registration[0], pinned: true }])
+})