docs: mark repo as abandoned in favor of paperclip-plugin-k8s

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
0.2.5
2026-05-01 08:46:55 -04:00 · 2026-04-30 09:06:19 -04:00 · 2026-04-30 09:06:12 -04:00 · 2026-04-30 08:46:57 -04:00 · 2026-04-30 08:46:46 -04:00 · 2026-04-30 08:28:01 -04:00
17 changed files with 1739 additions and 1697 deletions
@@ -3,6 +3,7 @@ name: CI
 on:
  push:
    branches: [master]
+    tags: ['v*']
  pull_request:
    branches: [master]

@@ -28,7 +29,10 @@ jobs:
  publish:
    needs: test
    runs-on: ubuntu-latest
-    if: github.ref == 'refs/heads/master' && github.event_name == 'push'
+    if: (github.ref == 'refs/heads/master' && github.event_name == 'push') || startsWith(github.ref, 'refs/tags/')
+    concurrency:
+      group: publish-${{ github.sha }}
+      cancel-in-progress: false
    permissions:
      id-token: write
    steps:
@@ -1,3 +1,5 @@
+> **Abandoned** — This adapter is no longer maintained. The Kubernetes execution capability has moved to the sandbox plugin at [`farhoodlabs/paperclip-plugin-k8s`](https://github.com/farhoodlabs/paperclip-plugin-k8s) (`@farhoodlabs/paperclip-plugin-k8s` on npm).
+
 # Claude (Kubernetes) Paperclip Adapter Plugin

 Paperclip adapter plugin that runs Claude Code agents as isolated Kubernetes Jobs instead of inside the main Paperclip process.
@@ -1,26 +1,27 @@
 {
  "name": "paperclip-adapter-claude-k8s",
-  "version": "0.1.39",
+  "version": "0.2.5",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "paperclip-adapter-claude-k8s",
-      "version": "0.1.39",
+      "version": "0.2.5",
      "license": "MIT",
      "dependencies": {
        "@kubernetes/client-node": "^1.0.0",
        "picocolors": "^1.1.1"
      },
      "devDependencies": {
-        "@paperclipai/adapter-utils": "2026.415.0-canary.7",
+        "@paperclipai/adapter-utils": "^2026.428.0",
        "@types/node": "^24.6.0",
        "@vitest/coverage-v8": "^4.1.4",
+        "esbuild": "^0.24.0",
        "typescript": "^5.7.3",
        "vitest": "^4.1.4"
      },
      "peerDependencies": {
-        "@paperclipai/adapter-utils": ">=2026.415.0-canary.7"
+        "@paperclipai/adapter-utils": ">=2026.428.0"
      }
    },
    "node_modules/@babel/helper-string-parser": {
@@ -117,6 +118,431 @@
        "tslib": "^2.4.0"
      }
    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.24.2.tgz",
+      "integrity": "sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.24.2.tgz",
+      "integrity": "sha512-tmwl4hJkCfNHwFB3nBa8z1Uy3ypZpxqxfTQOcHX+xRByyYgunVbZ9MzUUfb0RxaHIMnbHagwAxuTL+tnNM+1/Q==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.24.2.tgz",
+      "integrity": "sha512-cNLgeqCqV8WxfcTIOeL4OAtSmL8JjcN6m09XIgro1Wi7cF4t/THaWEa7eL5CMoMBdjoHOTh/vwTO/o2TRXIyzg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.24.2.tgz",
+      "integrity": "sha512-B6Q0YQDqMx9D7rvIcsXfmJfvUYLoP722bgfBlO5cGvNVb5V/+Y7nhBE3mHV9OpxBf4eAS2S68KZztiPaWq4XYw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.24.2.tgz",
+      "integrity": "sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.24.2.tgz",
+      "integrity": "sha512-WeSrmwwHaPkNR5H3yYfowhZcbriGqooyu3zI/3GGpF8AyUdsrrP0X6KumITGA9WOyiJavnGZUwPGvxvwfWPHIA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.24.2.tgz",
+      "integrity": "sha512-UN8HXjtJ0k/Mj6a9+5u6+2eZ2ERD7Edt1Q9IZiB5UZAIdPnVKDoG7mdTVGhHJIeEml60JteamR3qhsr1r8gXvg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.24.2.tgz",
+      "integrity": "sha512-TvW7wE/89PYW+IevEJXZ5sF6gJRDY/14hyIGFXdIucxCsbRmLUcjseQu1SyTko+2idmCw94TgyaEZi9HUSOe3Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.24.2.tgz",
+      "integrity": "sha512-n0WRM/gWIdU29J57hJyUdIsk0WarGd6To0s+Y+LwvlC55wt+GT/OgkwoXCXvIue1i1sSNWblHEig00GBWiJgfA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.24.2.tgz",
+      "integrity": "sha512-7HnAD6074BW43YvvUmE/35Id9/NB7BeX5EoNkK9obndmZBUk8xmJJeU7DwmUeN7tkysslb2eSl6CTrYz6oEMQg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.24.2.tgz",
+      "integrity": "sha512-sfv0tGPQhcZOgTKO3oBE9xpHuUqguHvSo4jl+wjnKwFpapx+vUDcawbwPNuBIAYdRAvIDBfZVvXprIj3HA+Ugw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.24.2.tgz",
+      "integrity": "sha512-CN9AZr8kEndGooS35ntToZLTQLHEjtVB5n7dl8ZcTZMonJ7CCfStrYhrzF97eAecqVbVJ7APOEe18RPI4KLhwQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.24.2.tgz",
+      "integrity": "sha512-iMkk7qr/wl3exJATwkISxI7kTcmHKE+BlymIAbHO8xanq/TjHaaVThFF6ipWzPHryoFsesNQJPE/3wFJw4+huw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.24.2.tgz",
+      "integrity": "sha512-shsVrgCZ57Vr2L8mm39kO5PPIb+843FStGt7sGGoqiiWYconSxwTiuswC1VJZLCjNiMLAMh34jg4VSEQb+iEbw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.24.2.tgz",
+      "integrity": "sha512-4eSFWnU9Hhd68fW16GD0TINewo1L6dRrB+oLNNbYyMUAeOD2yCK5KXGK1GH4qD/kT+bTEXjsyTCiJGHPZ3eM9Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.24.2.tgz",
+      "integrity": "sha512-S0Bh0A53b0YHL2XEXC20bHLuGMOhFDO6GN4b3YjRLK//Ep3ql3erpNcPlEFed93hsQAjAQDNsvcK+hV90FubSw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.24.2.tgz",
+      "integrity": "sha512-8Qi4nQcCTbLnK9WoMjdC9NiTG6/E38RNICU6sUNqK0QFxCYgoARqVqxdFmWkdonVsvGqWhmm7MO0jyTqLqwj0Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.24.2.tgz",
+      "integrity": "sha512-wuLK/VztRRpMt9zyHSazyCVdCXlpHkKm34WUyinD2lzK07FAHTq0KQvZZlXikNWkDGoT6x3TD51jKQ7gMVpopw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.24.2.tgz",
+      "integrity": "sha512-VefFaQUc4FMmJuAxmIHgUmfNiLXY438XrL4GDNV1Y1H/RW3qow68xTwjZKfj/+Plp9NANmzbH5R40Meudu8mmw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.24.2.tgz",
+      "integrity": "sha512-YQbi46SBct6iKnszhSvdluqDmxCJA+Pu280Av9WICNwQmMxV7nLRHZfjQzwbPs3jeWnuAhE9Jy0NrnJ12Oz+0A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.24.2.tgz",
+      "integrity": "sha512-+iDS6zpNM6EnJyWv0bMGLWSWeXGN/HTaF/LXHXHwejGsVi+ooqDfMCCTerNFxEkM3wYVcExkeGXNqshc9iMaOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.24.2.tgz",
+      "integrity": "sha512-hTdsW27jcktEvpwNHJU4ZwWFGkz2zRJUz8pvddmXPtXDzVKTTINmlmga3ZzwcuMpUvLw7JkLy9QLKyGpD2Yxig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.24.2.tgz",
+      "integrity": "sha512-LihEQ2BBKVFLOC9ZItT9iFprsE9tqjDjnbulhHoFxYQtQfai7qfluVODIYxt1PgdoyQkz23+01rzwNwYfutxUQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.24.2.tgz",
+      "integrity": "sha512-q+iGUwfs8tncmFC9pcnD5IvRHAzmbwQ3GPS5/ceCyHdjXubwQWI12MKWSNSMYLJMq23/IUCvJMS76PDqXe1fxA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.24.2.tgz",
+      "integrity": "sha512-7VTgWzgMGvup6aSqDPLiW5zHaxYJGTO4OokMjIlrCtf+VpEL+cXKtCvg723iguPYI5oaUNdS+/V7OU2gvXVWEg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
    "node_modules/@jridgewell/resolve-uri": {
      "version": "3.1.2",
      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
@@ -223,9 +649,9 @@
      }
    },
    "node_modules/@paperclipai/adapter-utils": {
-      "version": "2026.415.0-canary.7",
-      "resolved": "https://registry.npmjs.org/@paperclipai/adapter-utils/-/adapter-utils-2026.415.0-canary.7.tgz",
-      "integrity": "sha512-VNzIZmu1lrK6QM8Ad9WkOihZItfkj21NHKQf+artDcbwFT2hHbDAD9hdW2W9NMVxYdFvvnws3w76FI/BUbCMbQ==",
+      "version": "2026.428.0",
+      "resolved": "https://registry.npmjs.org/@paperclipai/adapter-utils/-/adapter-utils-2026.428.0.tgz",
+      "integrity": "sha512-kGHpE7rhePPCbnG3OwXbNuHZZuI+XyuFgNSiDnrEeiSbkI2c5XHM2WnWDCZ/NGHULfJW3lWhSxGMFoYqiy38vQ==",
      "dev": true,
      "license": "MIT"
    },
@@ -1033,6 +1459,47 @@
        "node": ">= 0.4"
      }
    },
+    "node_modules/esbuild": {
+      "version": "0.24.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.24.2.tgz",
+      "integrity": "sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.24.2",
+        "@esbuild/android-arm": "0.24.2",
+        "@esbuild/android-arm64": "0.24.2",
+        "@esbuild/android-x64": "0.24.2",
+        "@esbuild/darwin-arm64": "0.24.2",
+        "@esbuild/darwin-x64": "0.24.2",
+        "@esbuild/freebsd-arm64": "0.24.2",
+        "@esbuild/freebsd-x64": "0.24.2",
+        "@esbuild/linux-arm": "0.24.2",
+        "@esbuild/linux-arm64": "0.24.2",
+        "@esbuild/linux-ia32": "0.24.2",
+        "@esbuild/linux-loong64": "0.24.2",
+        "@esbuild/linux-mips64el": "0.24.2",
+        "@esbuild/linux-ppc64": "0.24.2",
+        "@esbuild/linux-riscv64": "0.24.2",
+        "@esbuild/linux-s390x": "0.24.2",
+        "@esbuild/linux-x64": "0.24.2",
+        "@esbuild/netbsd-arm64": "0.24.2",
+        "@esbuild/netbsd-x64": "0.24.2",
+        "@esbuild/openbsd-arm64": "0.24.2",
+        "@esbuild/openbsd-x64": "0.24.2",
+        "@esbuild/sunos-x64": "0.24.2",
+        "@esbuild/win32-arm64": "0.24.2",
+        "@esbuild/win32-ia32": "0.24.2",
+        "@esbuild/win32-x64": "0.24.2"
+      }
+    },
    "node_modules/estree-walker": {
      "version": "3.0.3",
      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
@@ -1,6 +1,6 @@
 {
  "name": "paperclip-adapter-claude-k8s",
-  "version": "0.1.39",
+  "version": "0.2.5",
  "description": "Paperclip adapter plugin that runs Claude Code agents as Kubernetes Jobs",
  "license": "MIT",
  "repository": {
@@ -25,7 +25,8 @@
    "dist"
  ],
  "scripts": {
-    "build": "tsc",
+    "build": "tsc && npm run build:ui-parser",
+    "build:ui-parser": "esbuild src/ui-parser.ts --bundle --format=cjs --target=es2020 --outfile=dist/ui-parser.js --log-level=warning",
    "clean": "rm -rf dist",
    "typecheck": "tsc --noEmit",
    "test": "vitest run",
@@ -37,12 +38,13 @@
    "picocolors": "^1.1.1"
  },
  "peerDependencies": {
-    "@paperclipai/adapter-utils": ">=2026.415.0-canary.7"
+    "@paperclipai/adapter-utils": ">=2026.428.0"
  },
  "devDependencies": {
-    "@paperclipai/adapter-utils": "2026.415.0-canary.7",
+    "@paperclipai/adapter-utils": "^2026.428.0",
    "@types/node": "^24.6.0",
    "@vitest/coverage-v8": "^4.1.4",
+    "esbuild": "^0.24.0",
    "typescript": "^5.7.3",
    "vitest": "^4.1.4"
  }
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { printClaudeStreamEvent } from "./format-event.js";
+import { printClaudeStreamEvent, formatClaudeStreamLine } from "./format-event.js";

 // Mock console methods to capture output
 const consoleMock = {
@@ -138,6 +138,39 @@ describe("printClaudeStreamEvent", () => {
    expect(output()).toBe("some output text");
  });

+  it("prints rate_limit_event with type, status, and reset time", () => {
+    printClaudeStreamEvent(JSON.stringify({
+      type: "rate_limit_event",
+      rate_limit_info: {
+        status: "allowed",
+        resetsAt: 1777056000,
+        rateLimitType: "five_hour",
+        overageStatus: "allowed",
+        isUsingOverage: false,
+      },
+      uuid: "3ab8f9eb-b9d6-4bf6-9c39-4608427717fc",
+      session_id: "ad5f3e11-3c0c-4144-b53d-d4b959e57cee",
+    }), false);
+    expect(output()).toContain("rate_limit:");
+    expect(output()).toContain("five_hour");
+    expect(output()).toContain("allowed");
+    expect(output()).toContain("resets=");
+    // Raw JSON must not be surfaced verbatim
+    expect(output()).not.toContain("3ab8f9eb-b9d6-4bf6-9c39-4608427717fc");
+  });
+
+  it("prints rate_limit_event with unknown fields gracefully", () => {
+    printClaudeStreamEvent(JSON.stringify({
+      type: "rate_limit_event",
+      rate_limit_info: {},
+    }), false);
+    expect(output()).toContain("rate_limit:");
+    expect(output()).toContain("type=unknown");
+    expect(output()).toContain("status=unknown");
+    // No resetsAt present — reset clause omitted
+    expect(output()).not.toContain("resets=");
+  });
+
  it("does not print unknown types in non-debug mode", () => {
    printClaudeStreamEvent(JSON.stringify({ type: "unknown", data: "stuff" }), false);
    expect(output()).toBe("");
@@ -148,3 +181,103 @@ describe("printClaudeStreamEvent", () => {
    expect(output()).toContain("stuff");
  });
 });
+
+describe("formatClaudeStreamLine", () => {
+  it("returns null for empty/blank lines", () => {
+    expect(formatClaudeStreamLine("")).toBeNull();
+    expect(formatClaudeStreamLine("   ")).toBeNull();
+  });
+
+  it("returns raw text for non-JSON lines (adapter status messages pass through)", () => {
+    expect(formatClaudeStreamLine("[paperclip] Pod running: pod-abc")).toBe("[paperclip] Pod running: pod-abc");
+    expect(formatClaudeStreamLine("Error: disk full")).toBe("Error: disk full");
+  });
+
+  it("formats system/init event", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "system", subtype: "init", model: "claude-opus-4-7", session_id: "sess_abc",
+    }));
+    expect(result).toContain("Claude initialized");
+    expect(result).toContain("claude-opus-4-7");
+    expect(result).toContain("sess_abc");
+    expect(result).not.toContain("{");
+  });
+
+  it("formats assistant text block", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "assistant",
+      message: { content: [{ type: "text", text: "Hello world" }] },
+    }));
+    expect(result).toBe("assistant: Hello world");
+  });
+
+  it("formats assistant thinking block", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "assistant",
+      message: { content: [{ type: "thinking", thinking: "Let me think..." }] },
+    }));
+    expect(result).toBe("thinking: Let me think...");
+  });
+
+  it("formats assistant tool_use block", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "assistant",
+      message: { content: [{ type: "tool_use", name: "Bash", input: { command: "ls" } }] },
+    }));
+    expect(result).toContain("tool_call: Bash");
+    expect(result).toContain("ls");
+  });
+
+  it("returns null for assistant with no printable content (thinking-only with empty text)", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "assistant",
+      message: { content: [{ type: "thinking", thinking: "" }] },
+    }));
+    expect(result).toBeNull();
+  });
+
+  it("formats user tool_result", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "user",
+      message: { content: [{ type: "tool_result", content: "file1.txt\nfile2.txt" }] },
+    }));
+    expect(result).toContain("tool_result");
+    expect(result).toContain("file1.txt");
+  });
+
+  it("formats user tool_result error", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "user",
+      message: { content: [{ type: "tool_result", is_error: true, content: "Permission denied" }] },
+    }));
+    expect(result).toContain("tool_result (error)");
+    expect(result).toContain("Permission denied");
+  });
+
+  it("formats result event with tokens and cost", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "result", result: "Done", subtype: "stop", total_cost_usd: 0.005,
+      usage: { input_tokens: 100, output_tokens: 200, cache_read_input_tokens: 50 },
+    }));
+    expect(result).toContain("result:");
+    expect(result).toContain("Done");
+    expect(result).toContain("in=100");
+    expect(result).toContain("out=200");
+    expect(result).toContain("cached=50");
+  });
+
+  it("formats rate_limit_event (FAR-32 repro)", () => {
+    const result = formatClaudeStreamLine(JSON.stringify({
+      type: "rate_limit_event",
+      rate_limit_info: { status: "allowed", resetsAt: 1777056000, rateLimitType: "five_hour" },
+    }));
+    expect(result).toContain("rate_limit:");
+    expect(result).toContain("five_hour");
+    expect(result).toContain("allowed");
+    expect(result).not.toContain("{");
+  });
+
+  it("returns null for unknown event types", () => {
+    expect(formatClaudeStreamLine(JSON.stringify({ type: "unknown_event", data: "x" }))).toBeNull();
+  });
+});
@@ -17,27 +17,150 @@ function asErrorText(value: unknown): string {
  }
 }

-function printToolResult(block: Record<string, unknown>): void {
-  const isError = block.is_error === true;
-  let text = "";
-  if (typeof block.content === "string") {
-    text = block.content;
-  } else if (Array.isArray(block.content)) {
+function extractToolResultText(block: Record<string, unknown>): string {
+  if (typeof block.content === "string") return block.content;
+  if (Array.isArray(block.content)) {
    const parts: string[] = [];
    for (const part of block.content) {
      if (typeof part !== "object" || part === null || Array.isArray(part)) continue;
      const record = part as Record<string, unknown>;
      if (typeof record.text === "string") parts.push(record.text);
    }
-    text = parts.join("\n");
+    return parts.join("\n");
  }
+  return "";
+}

+function printToolResult(block: Record<string, unknown>): void {
+  const isError = block.is_error === true;
+  const text = extractToolResultText(block);
  console.log((isError ? pc.red : pc.cyan)(`tool_result${isError ? " (error)" : ""}`));
  if (text) {
    console.log((isError ? pc.red : pc.gray)(text));
  }
 }

+/**
+ * Format a single raw Claude stream-json line into a plain-text human-readable
+ * string (no ANSI colour codes) suitable for forwarding to the Paperclip server
+ * via onLog.  Returns null for lines that should be suppressed (empty,
+ * assistant events with no printable content, etc.).  Non-JSON lines are
+ * returned as-is so plain-text adapter status messages pass through unchanged.
+ *
+ * Mirrors the event coverage of printClaudeStreamEvent so the K8s server
+ * streaming path and the CLI display path produce consistent output.
+ */
+export function formatClaudeStreamLine(raw: string): string | null {
+  const line = raw.trim();
+  if (!line) return null;
+
+  let parsed: Record<string, unknown> | null = null;
+  try {
+    parsed = JSON.parse(line) as Record<string, unknown>;
+  } catch {
+    return line;
+  }
+
+  const type = typeof parsed.type === "string" ? parsed.type : "";
+
+  if (type === "system" && parsed.subtype === "init") {
+    const model = typeof parsed.model === "string" ? parsed.model : "unknown";
+    const sessionId = typeof parsed.session_id === "string" ? parsed.session_id : "";
+    return `Claude initialized (model: ${model}${sessionId ? `, session: ${sessionId}` : ""})`;
+  }
+
+  if (type === "assistant") {
+    const message =
+      typeof parsed.message === "object" && parsed.message !== null && !Array.isArray(parsed.message)
+        ? (parsed.message as Record<string, unknown>)
+        : {};
+    const content = Array.isArray(message.content) ? message.content : [];
+    const lines: string[] = [];
+    for (const blockRaw of content) {
+      if (typeof blockRaw !== "object" || blockRaw === null || Array.isArray(blockRaw)) continue;
+      const block = blockRaw as Record<string, unknown>;
+      const blockType = typeof block.type === "string" ? block.type : "";
+      if (blockType === "text") {
+        const text = typeof block.text === "string" ? block.text : "";
+        if (text) lines.push(`assistant: ${text}`);
+      } else if (blockType === "thinking") {
+        const text = typeof block.thinking === "string" ? block.thinking : "";
+        if (text) lines.push(`thinking: ${text}`);
+      } else if (blockType === "tool_use") {
+        const name = typeof block.name === "string" ? block.name : "unknown";
+        lines.push(`tool_call: ${name}`);
+        if (block.input !== undefined) {
+          lines.push(JSON.stringify(block.input, null, 2));
+        }
+      }
+    }
+    return lines.length > 0 ? lines.join("\n") : null;
+  }
+
+  if (type === "user") {
+    const message =
+      typeof parsed.message === "object" && parsed.message !== null && !Array.isArray(parsed.message)
+        ? (parsed.message as Record<string, unknown>)
+        : {};
+    const content = Array.isArray(message.content) ? message.content : [];
+    const lines: string[] = [];
+    for (const blockRaw of content) {
+      if (typeof blockRaw !== "object" || blockRaw === null || Array.isArray(blockRaw)) continue;
+      const block = blockRaw as Record<string, unknown>;
+      if (typeof block.type === "string" && block.type === "tool_result") {
+        const isError = block.is_error === true;
+        const text = extractToolResultText(block);
+        lines.push(`tool_result${isError ? " (error)" : ""}`);
+        if (text) lines.push(text);
+      }
+    }
+    return lines.length > 0 ? lines.join("\n") : null;
+  }
+
+  if (type === "result") {
+    const usage =
+      typeof parsed.usage === "object" && parsed.usage !== null && !Array.isArray(parsed.usage)
+        ? (parsed.usage as Record<string, unknown>)
+        : {};
+    const input = Number(usage.input_tokens ?? 0);
+    const output = Number(usage.output_tokens ?? 0);
+    const cached = Number(usage.cache_read_input_tokens ?? 0);
+    const cost = Number(parsed.total_cost_usd ?? 0);
+    const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";
+    const isError = parsed.is_error === true;
+    const resultText = typeof parsed.result === "string" ? parsed.result : "";
+    const errors = Array.isArray(parsed.errors) ? parsed.errors.map(asErrorText).filter(Boolean) : [];
+    const lines: string[] = [];
+    if (resultText) {
+      lines.push("result:");
+      lines.push(resultText);
+    }
+    if (subtype.startsWith("error") || isError || errors.length > 0) {
+      lines.push(`claude_result: subtype=${subtype || "unknown"} is_error=${isError ? "true" : "false"}`);
+      if (errors.length > 0) lines.push(`claude_errors: ${errors.join(" | ")}`);
+    }
+    lines.push(`tokens: in=${Number.isFinite(input) ? input : 0} out=${Number.isFinite(output) ? output : 0} cached=${Number.isFinite(cached) ? cached : 0} cost=$${Number.isFinite(cost) ? cost.toFixed(6) : "0.000000"}`);
+    return lines.join("\n");
+  }
+
+  if (type === "rate_limit_event") {
+    const info =
+      typeof parsed.rate_limit_info === "object" && parsed.rate_limit_info !== null
+        ? (parsed.rate_limit_info as Record<string, unknown>)
+        : {};
+    const limitType = typeof info.rateLimitType === "string" ? info.rateLimitType : "unknown";
+    const status = typeof info.status === "string" ? info.status : "unknown";
+    const resetsAt = typeof info.resetsAt === "number"
+      ? new Date(info.resetsAt * 1000).toISOString()
+      : "";
+    const parts = [`rate_limit: type=${limitType} status=${status}`];
+    if (resetsAt) parts.push(`resets=${resetsAt}`);
+    return parts.join(" ");
+  }
+
+  return null;
+}
+
 export function printClaudeStreamEvent(raw: string, debug: boolean): void {
  const line = raw.trim();
  if (!line) return;
@@ -133,6 +256,22 @@ export function printClaudeStreamEvent(raw: string, debug: boolean): void {
    return;
  }

+  if (type === "rate_limit_event") {
+    const info =
+      typeof parsed.rate_limit_info === "object" && parsed.rate_limit_info !== null
+        ? (parsed.rate_limit_info as Record<string, unknown>)
+        : {};
+    const limitType = typeof info.rateLimitType === "string" ? info.rateLimitType : "unknown";
+    const status = typeof info.status === "string" ? info.status : "unknown";
+    const resetsAt = typeof info.resetsAt === "number"
+      ? new Date(info.resetsAt * 1000).toISOString()
+      : "";
+    const parts = [`rate_limit: type=${limitType} status=${status}`];
+    if (resetsAt) parts.push(`resets=${resetsAt}`);
+    console.log(pc.yellow(parts.join(" ")));
+    return;
+  }
+
  if (debug) {
    console.log(pc.gray(line));
  }
@@ -1,7 +1,35 @@
+import type { AdapterModel } from "@paperclipai/adapter-utils";
+
 export const type = "claude_k8s";
 export const label = "Claude (Kubernetes)";

-export const models: undefined = undefined;
+function isBedrockEnv(): boolean {
+  return (
+    process.env.CLAUDE_CODE_USE_BEDROCK === "1" ||
+    process.env.CLAUDE_CODE_USE_BEDROCK === "true" ||
+    (typeof process.env.ANTHROPIC_BEDROCK_BASE_URL === "string" &&
+      process.env.ANTHROPIC_BEDROCK_BASE_URL.trim().length > 0)
+  );
+}
+
+const DIRECT_MODELS: AdapterModel[] = [
+  { id: "claude-opus-4-7", label: "Claude Opus 4.7" },
+  { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+  { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+  { id: "claude-haiku-4-6", label: "Claude Haiku 4.6" },
+  { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5" },
+  { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" },
+];
+
+const BEDROCK_MODELS: AdapterModel[] = [
+  { id: "us.anthropic.claude-opus-4-7", label: "Bedrock Opus 4.7" },
+  { id: "us.anthropic.claude-opus-4-6-v1", label: "Bedrock Opus 4.6" },
+  { id: "us.anthropic.claude-sonnet-4-6", label: "Bedrock Sonnet 4.6" },
+  { id: "us.anthropic.claude-sonnet-4-5-20250929-v1:0", label: "Bedrock Sonnet 4.5" },
+  { id: "us.anthropic.claude-haiku-4-5-20251001-v1:0", label: "Bedrock Haiku 4.5" },
+];
+
+export const models = isBedrockEnv() ? BEDROCK_MODELS : DIRECT_MODELS;

 export const agentConfigurationDoc = `# claude_k8s agent configuration

@@ -32,10 +60,6 @@ Kubernetes fields:
 - retainJobs (boolean, optional): skip cleanup on completion for debugging
 - reattachOrphanedJobs (boolean, optional): when true (default), attach to a running orphaned Job that matches the current agent/task/session instead of blocking; when false, any non-terminal orphan blocks the new run

-Output filtering fields:
- enableRtk (boolean, optional): truncate oversized tool outputs before they reach the model via a PostToolUse hook; default false
- rtkMaxOutputBytes (number, optional): byte threshold for tool output truncation when enableRtk is true; default 50000
-
 Operational fields:
 - timeoutSec (number, optional): run timeout in seconds; 0 means no timeout
 - graceSec (number, optional): additional grace before adapter gives up after Job deadline
@@ -133,22 +133,7 @@ export function getConfigSchema(): AdapterConfigSchema {
      label: "Labels",
      hint: "Extra labels added to Job metadata. One key=value per line.",
    },
-    // Output filtering (RTK-compatible)
-    {
-      type: "toggle",
-      key: "enableRtk",
-      label: "Enable Output Filtering",
-      hint: "Truncate oversized tool outputs before they reach the model, reducing token consumption. Implemented natively in Node.js — no external binary required. Installs a PostToolUse hook in ~/.claude/settings.json for each run.",
-      default: false,
-    },
-    {
-      type: "number",
-      key: "rtkMaxOutputBytes",
-      label: "Max Tool Output Bytes",
-      hint: "Maximum bytes of tool output to pass to the model when output filtering is enabled. Outputs exceeding this threshold are truncated with a summary. Default: 50000.",
-      default: 50000,
-    },
  ];

  return { fields };
-}
+}
@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import type { AdapterExecutionContext } from "@paperclipai/adapter-utils";
-import { buildJobManifest, buildRtkSetupCommands, sanitizeLabelValue } from "./job-manifest.js";
+import { buildJobManifest, buildPodLogPath, sanitizeLabelValue } from "./job-manifest.js";
 import type { SelfPodInfo } from "./k8s-client.js";

 function makeCtx(overrides: Partial<AdapterExecutionContext> = {}): AdapterExecutionContext {
@@ -221,11 +221,9 @@ describe("buildJobManifest", () => {

    it("omits paperclip.io/run-id when sanitized value is null (all-invalid runId)", () => {
      // inject an all-special-chars runId via context override — buildJobManifest
-      // uses ctx.runId directly
+      // uses ctx.runId directly. Use characters that are path-valid but label-invalid.
      const badCtx = makeCtx({ runId: "@@@" });
-      const { job, skippedLabels } = buildJobManifest({ ctx: badCtx, selfPod });
-      expect(job.metadata?.labels?.["paperclip.io/run-id"]).toBeUndefined();
-      expect(skippedLabels).toContain("paperclip.io/run-id");
+      expect(() => buildJobManifest({ ctx: badCtx, selfPod })).toThrow("Invalid runId");
    });

    it("selector matches sanitized agent-id label", () => {
@@ -301,7 +299,9 @@ describe("buildJobManifest", () => {
    it("write-prompt writes PROMPT_CONTENT to /tmp/prompt/prompt.txt", () => {
      const { job } = buildJobManifest({ ctx, selfPod });
      const init = job.spec?.template?.spec?.initContainers?.[0];
-      expect(init?.command).toEqual(["sh", "-c", "printf '%s' \"$PROMPT_CONTENT\" > /tmp/prompt/prompt.txt"]);
+      expect(init?.command?.[0]).toBe("sh");
+      expect(init?.command?.[1]).toBe("-c");
+      expect(init?.command?.[2]).toBe("printf '%s' \"$PROMPT_CONTENT\" > /tmp/prompt/prompt.txt");
    });

    it("write-prompt mounts prompt volume", () => {
@@ -794,112 +794,69 @@ describe("buildJobManifest", () => {
    });
  });

-  describe("rtk output filtering", () => {
+  describe("pod log file tailing", () => {
    it("does not modify main command when enableRtk is false (default)", () => {
      const { job } = buildJobManifest({ ctx, selfPod });
      const cmd = job.spec?.template?.spec?.containers[0]?.command;
-      // Command should be the plain `cat ... | claude ...` form with no rtk setup
-      expect(cmd?.[2]).toMatch(/^cat \/tmp\/prompt\/prompt\.txt \| claude /);
+      // Command should be the plain `cat ... | claude ... | tee ...` form with no rtk setup
+      expect(cmd?.[2]).toMatch(/^cat \/tmp\/prompt\/prompt\.txt \| claude .* \| tee /);
      expect(cmd?.[2]).not.toContain("rtk-filter");
    });

-    it("prepends RTK setup commands when enableRtk is true", () => {
-      ctx.config = { enableRtk: true };
-      const { job } = buildJobManifest({ ctx, selfPod });
-      const cmd = job.spec?.template?.spec?.containers[0]?.command;
-      expect(cmd?.[2]).toContain(".rtk-filter.js");
-      expect(cmd?.[2]).toContain("cat /tmp/prompt/prompt.txt | claude");
-    });
-
-    it("RTK setup runs before claude invocation", () => {
-      ctx.config = { enableRtk: true };
+    it("command includes tee to pod log path", () => {
      const { job } = buildJobManifest({ ctx, selfPod });
      const cmd = job.spec?.template?.spec?.containers[0]?.command?.[2] ?? "";
-      const rtkIdx = cmd.indexOf(".rtk-filter.js");
-      const claudeIdx = cmd.indexOf("cat /tmp/prompt/prompt.txt | claude");
-      expect(rtkIdx).toBeGreaterThanOrEqual(0);
-      expect(claudeIdx).toBeGreaterThan(rtkIdx);
+      expect(cmd).toContain("| tee");
+      expect(cmd).toContain("/paperclip/instances/default/data/run-logs/");
    });

-    it("RTK setup uses node (no external binaries)", () => {
-      ctx.config = { enableRtk: true };
+    it("podLogPath is returned from buildJobManifest", () => {
+      const result = buildJobManifest({ ctx, selfPod });
+      expect(result.podLogPath).toBe(
+        "/paperclip/instances/default/data/run-logs/co1/agent-abc/run-abc12345.pod.ndjson",
+      );
+    });
+
+    it("buildPodLogPath returns correctly formatted path", () => {
+      expect(buildPodLogPath("co1", "agent-abc", "run-abc12345")).toBe(
+        "/paperclip/instances/default/data/run-logs/co1/agent-abc/run-abc12345.pod.ndjson",
+      );
+    });
+
+    it("init container does not create log directory (server pre-creates it on shared PVC)", () => {
      const { job } = buildJobManifest({ ctx, selfPod });
-      const cmd = job.spec?.template?.spec?.containers[0]?.command?.[2] ?? "";
-      // Should only use `node` — no curl, wget, apt, pip, etc.
-      expect(cmd).not.toMatch(/\b(curl|wget|apt|yum|pip|gem|cargo|go\s+get)\b/);
-      expect(cmd).toContain("node ");
+      const initCmd = job.spec?.template?.spec?.initContainers?.[0]?.command;
+      expect(initCmd?.[2]).not.toContain("mkdir -p /paperclip");
    });

-    it("uses default 50000 byte threshold when rtkMaxOutputBytes not set", () => {
-      ctx.config = { enableRtk: true };
-      const setup = buildRtkSetupCommands(50000);
-      // The filter script base64 should decode to contain the MAX constant
-      const b64Match = setup.match(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/);
-      expect(b64Match).not.toBeNull();
-      const decoded = Buffer.from(b64Match![1], "base64").toString("utf-8");
-      expect(decoded).toContain("50000");
+    it("sanitizes companyId with / to valid path component for log path", () => {
+      const badCtx = {
+        ...ctx,
+        agent: { ...ctx.agent, companyId: "co/1" },
+      };
+      const { podLogPath } = buildJobManifest({ ctx: badCtx as typeof ctx, selfPod });
+      // / is stripped by sanitizeForK8sPath
+      expect(podLogPath).toContain("co1/");
    });

-    it("respects custom rtkMaxOutputBytes", () => {
-      ctx.config = { enableRtk: true, rtkMaxOutputBytes: 100000 };
-      const { job } = buildJobManifest({ ctx, selfPod });
-      const cmd = job.spec?.template?.spec?.containers[0]?.command?.[2] ?? "";
-      // The custom threshold should appear in the base64-encoded filter script
-      const b64Matches = [...cmd.matchAll(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/g)];
-      const decoded = b64Matches.map((m) => Buffer.from(m[1], "base64").toString("utf-8")).join("\n");
-      expect(decoded).toContain("100000");
+    it("sanitizes agentId with @ to valid path component for log path", () => {
+      const badCtx = {
+        ...ctx,
+        agent: { ...ctx.agent, id: "agent@123" },
+      };
+      const { podLogPath } = buildJobManifest({ ctx: badCtx as typeof ctx, selfPod });
+      // @ is stripped by sanitizeForK8sPath
+      expect(podLogPath).toContain("/agent123/");
    });

-    it("RTK setup installs a PostToolUse hook in claude settings", () => {
-      const setup = buildRtkSetupCommands(50000);
-      // The settings script (second base64 block) should reference PostToolUse
-      const b64Matches = [...setup.matchAll(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/g)];
-      expect(b64Matches.length).toBeGreaterThanOrEqual(2);
-      const settingsScript = Buffer.from(b64Matches[1]![1], "base64").toString("utf-8");
-      expect(settingsScript).toContain("PostToolUse");
-      expect(settingsScript).toContain("settings.json");
-    });
-
-    it("filter script handles string content truncation", () => {
-      // Decode the filter script and verify it truncates string content
-      const setup = buildRtkSetupCommands(1000);
-      const b64Matches = [...setup.matchAll(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/g)];
-      const filterScript = Buffer.from(b64Matches[0]![1], "base64").toString("utf-8");
-      expect(filterScript).toContain("MAX=1000");
-      expect(filterScript).toContain("truncated by paperclip-rtk");
-      expect(filterScript).toContain("tool_response");
-      expect(filterScript).toContain("tool_result");
-    });
-
-    it("filter script truncates without corrupting multi-byte UTF-8", () => {
-      // "中" is U+4E2D, 3 bytes in UTF-8: E4 B8 AD
-      // With MAX=5, two "中" (6 bytes) should truncate to one (3 bytes), not
-      // produce a replacement character from slicing mid-codepoint.
-      const setup = buildRtkSetupCommands(5);
-      const b64Matches = [...setup.matchAll(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/g)];
-      const filterScript = Buffer.from(b64Matches[0]![1], "base64").toString("utf-8");
-
-      // Extract the trunc function from the filter script and evaluate it
-      const fnMatch = filterScript.match(/(function trunc\(s\)\{.*\})(?=const tr=)/);
-      expect(fnMatch).toBeTruthy();
-      // eslint-disable-next-line no-eval
-      const trunc = eval(`(()=>{const MAX=5;${fnMatch![1]};return trunc;})()`);
-
-      const result = trunc("中中");
-      expect(result).not.toContain("�");
-      expect(result).toContain("中");
-      expect(result).toContain("truncated by paperclip-rtk");
-      // Should report bytes from the actual truncation point, not MAX
-      expect(result).toContain("3 bytes truncated");
-    });
-
-    it("filter script handles array content (block format)", () => {
-      const setup = buildRtkSetupCommands(50000);
-      const b64Matches = [...setup.matchAll(/Buffer\.from\('([A-Za-z0-9+/=]+)','base64'\)/g)];
-      const filterScript = Buffer.from(b64Matches[0]![1], "base64").toString("utf-8");
-      // Should handle array content blocks (text field on each block)
-      expect(filterScript).toContain("Array.isArray");
-      expect(filterScript).toContain("b.text");
+    it("sanitizes runId with underscore to valid path component for log path", () => {
+      const badCtx = {
+        ...ctx,
+        runId: "run_123",
+      };
+      const { podLogPath } = buildJobManifest({ ctx: badCtx as typeof ctx, selfPod });
+      // _ is stripped by sanitizeForK8sPath
+      expect(podLogPath).toContain("/run123.pod.ndjson");
    });
  });
 });
@@ -12,85 +12,18 @@ import {
 import { createHash } from "node:crypto";
 import type { ClaudePromptBundle } from "./prompt-cache.js";

-/**
- * Build the shell command prefix that installs a native Node.js PostToolUse
- * hook into Claude Code's settings.  The hook truncates oversized tool outputs
- * before they reach the model — replacing the RTK binary init-container
- * approach with a self-contained Node.js implementation.
- *
- * Both scripts are base64-encoded so they can be embedded in a sh -c command
- * string without any quoting or escaping issues.
- *
- * @param maxOutputBytes  Byte threshold above which tool output is truncated.
- * @returns               A shell command string (suitable for "&&"-chaining
- *                        before the claude invocation).
- */
-export function buildRtkSetupCommands(maxOutputBytes: number): string {
-  // --- Filter script ----------------------------------------------------------
-  // This script runs as the PostToolUse hook inside every K8s Job pod.
-  // Claude Code writes the hook event as JSON to the script's stdin; the script
-  // truncates the tool_response/tool_result content when it exceeds the
-  // threshold and writes the (possibly modified) JSON to stdout.
-  //
-  // Field-name coverage:
-  //   • tool_response — documented hook event format for PostToolUse
-  //   • tool_result   — alternative name seen in some Claude Code versions
-  // Content may be a plain string or an array of typed blocks (text/image/…).
-  const filterScript = [
-    `const c=[];`,
-    `process.stdin.on('data',d=>c.push(d));`,
-    `process.stdin.on('end',()=>{`,
-    `const raw=Buffer.concat(c).toString('utf-8');`,
-    `let o;try{o=JSON.parse(raw);}catch{process.stdout.write(raw);return;}`,
-    `const MAX=${maxOutputBytes};`,
-    `function trunc(s){`,
-    `if(typeof s!=='string')return s;`,
-    `const b=Buffer.from(s,'utf-8');`,
-    `if(b.length<=MAX)return s;`,
-    `let e=MAX;if(e>0){let p=e-1;while(p>0&&(b[p]&0xC0)===0x80)p--;const l=b[p];let n=1;if((l&0xE0)===0xC0)n=2;else if((l&0xF0)===0xE0)n=3;else if((l&0xF8)===0xF0)n=4;if(p+n>e)e=p;}`,
-    `return b.slice(0,e).toString('utf-8')+'\\n[...'+(b.length-e)+' bytes truncated by paperclip-rtk]';`,
-    `}`,
-    `const tr=o&&(o.tool_response||o.tool_result);`,
-    `if(tr){`,
-    `if(typeof tr.content==='string'){tr.content=trunc(tr.content);}`,
-    `else if(Array.isArray(tr.content)){`,
-    `tr.content=tr.content.map(function(b){`,
-    `if(b&&typeof b==='object'&&typeof b.text==='string'){`,
-    `return Object.assign({},b,{text:trunc(b.text)});`,
-    `}return b;`,
-    `});`,
-    `}`,
-    `}`,
-    `process.stdout.write(JSON.stringify(o));`,
-    `});`,
-  ].join("");
+function assertSafePathComponent(field: string, value: string): void {
+  if (!/^[a-zA-Z0-9-]+$/.test(value)) {
+    throw new Error(`Invalid ${field} for log path: ${value}`);
+  }
+}

-  // --- Settings script --------------------------------------------------------
-  // Reads the existing ~/.claude/settings.json (if any), merges in the RTK
-  // PostToolUse hook, and writes the file back.  All other settings sections
-  // are preserved; only PostToolUse is replaced so we own the full hook list
-  // for this run.
-  const settingsScript = [
-    `const fs=require('fs'),pt=require('path');`,
-    `const p=pt.join(process.env.HOME,'.claude','settings.json');`,
-    `let s={};try{s=JSON.parse(fs.readFileSync(p,'utf-8'));}catch(e){}`,
-    `s.hooks=s.hooks||{};`,
-    `s.hooks.PostToolUse=[{matcher:'.*',hooks:[{type:'command',command:'node /tmp/.rtk-filter.js'}]}];`,
-    `fs.mkdirSync(pt.dirname(p),{recursive:true});`,
-    `fs.writeFileSync(p,JSON.stringify(s));`,
-  ].join("");
+function sanitizeForK8sPath(value: string): string {
+  return value.replace(/[^a-zA-Z0-9-]/g, "");
+}

-  // Encode as base64 so the strings can be embedded directly in a shell command
-  // without any quoting concerns (base64 alphabet: A-Za-z0-9+/=).
-  const filterB64 = Buffer.from(filterScript, "utf-8").toString("base64");
-  const settingsB64 = Buffer.from(settingsScript, "utf-8").toString("base64");
-
-  return [
-    // Write the filter script
-    `node -e "require('fs').writeFileSync('/tmp/.rtk-filter.js',Buffer.from('${filterB64}','base64').toString('utf-8'))"`,
-    // Install the Claude Code PostToolUse hook (merge into existing settings)
-    `node -e "eval(Buffer.from('${settingsB64}','base64').toString('utf-8'))"`,
-  ].join(" && ");
+export function buildPodLogPath(companyId: string, agentId: string, runId: string): string {
+  return `/paperclip/instances/default/data/run-logs/${companyId}/${agentId}/${runId}.pod.ndjson`;
 }

 /** Prompts above this size (bytes) are staged via a Secret instead of an
@@ -202,6 +135,8 @@ export interface JobBuildResult {
  promptSecret: PromptSecret | null;
  /** User-supplied extra labels that were dropped because they used a reserved prefix. */
  skippedLabels: string[];
+  /** Path to the pod log file on the shared PVC. */
+  podLogPath: string;
 }

 function sanitizeForK8sName(value: string, maxLen = 16): string {
@@ -353,8 +288,6 @@ export function buildJobManifest(input: JobBuildInput): JobBuildResult {
  const nodeSelector = parseKeyValueConfig(config.nodeSelector);
  const tolerations = Array.isArray(config.tolerations) ? config.tolerations : [];
  const extraLabels = parseKeyValueConfig(config.labels);
-  const enableRtk = asBoolean(config.enableRtk, false);
-  const rtkMaxOutputBytes = asNumber(config.rtkMaxOutputBytes, 50000);

  // Resolve working directory — use workspace cwd, fall back to /paperclip
  const workspaceContext = parseObject(context.paperclipWorkspace);
@@ -535,13 +468,15 @@ export function buildJobManifest(input: JobBuildInput): JobBuildResult {

  // Build the claude command string for the main container
  const claudeArgsEscaped = claudeArgs.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
-  const claudeInvocation = `cat /tmp/prompt/prompt.txt | claude ${claudeArgsEscaped}`;
-  // When RTK output filtering is enabled, prepend the Node.js hook setup.
-  // This writes a filter script and a Claude Code settings file that installs
-  // it as a PostToolUse hook — no external binary or init container required.
-  const mainCommand = enableRtk
-    ? `${buildRtkSetupCommands(rtkMaxOutputBytes)} && ${claudeInvocation}`
-    : claudeInvocation;
+  const logPathCompanyId = sanitizeForK8sPath(agent.companyId);
+  const logPathAgentId = sanitizeForK8sPath(agent.id);
+  const logPathRunId = sanitizeForK8sPath(runId);
+  assertSafePathComponent("companyId", logPathCompanyId);
+  assertSafePathComponent("agentId", logPathAgentId);
+  assertSafePathComponent("runId", logPathRunId);
+  const podLogPath = buildPodLogPath(logPathCompanyId, logPathAgentId, logPathRunId);
+  const claudeInvocation = `cat /tmp/prompt/prompt.txt | claude ${claudeArgsEscaped} | tee ${podLogPath}`;
+  const mainCommand = claudeInvocation;

  // Decide prompt delivery strategy: env var (small) or Secret volume (large).
  const promptBytes = Buffer.byteLength(prompt, "utf-8");
@@ -584,7 +519,7 @@ export function buildJobManifest(input: JobBuildInput): JobBuildResult {
        name: "write-prompt",
        image: "busybox:1.36",
        imagePullPolicy: "IfNotPresent",
-        command: ["sh", "-c", "printf '%s' \"$PROMPT_CONTENT\" > /tmp/prompt/prompt.txt"],
+        command: ["sh", "-c", `printf '%s' "$PROMPT_CONTENT" > /tmp/prompt/prompt.txt`],
        env: [{ name: "PROMPT_CONTENT", value: prompt }],
        volumeMounts: [{ name: "prompt", mountPath: "/tmp/prompt" }],
        securityContext,
@@ -641,5 +576,5 @@ export function buildJobManifest(input: JobBuildInput): JobBuildResult {
    },
  };

-  return { job, jobName, namespace, prompt, claudeArgs, promptMetrics, promptSecret, skippedLabels };
+  return { job, jobName, namespace, prompt, claudeArgs, promptMetrics, promptSecret, skippedLabels, podLogPath };
 }
@@ -1,173 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { LogLineDedupFilter, eventDedupKey } from "./log-dedup.js";
-
-function assistantEvent(id: string, text: string): string {
-  return JSON.stringify({
-    type: "assistant",
-    session_id: "sess_1",
-    message: {
-      id,
-      content: [{ type: "text", text }],
-    },
-  });
-}
-
-function userToolResultEvent(toolUseId: string, content: string): string {
-  return JSON.stringify({
-    type: "user",
-    session_id: "sess_1",
-    message: {
-      content: [{ type: "tool_result", tool_use_id: toolUseId, content }],
-    },
-  });
-}
-
-function systemInitEvent(sessionId: string): string {
-  return JSON.stringify({
-    type: "system",
-    subtype: "init",
-    session_id: sessionId,
-    model: "claude-opus-4-7",
-  });
-}
-
-function resultEvent(sessionId: string): string {
-  return JSON.stringify({
-    type: "result",
-    subtype: "success",
-    session_id: sessionId,
-    result: "done",
-    total_cost_usd: 0.01,
-    usage: { input_tokens: 1, output_tokens: 1, cache_read_input_tokens: 0 },
-  });
-}
-
-describe("eventDedupKey", () => {
-  it("keys assistant events by message.id", () => {
-    const key = eventDedupKey(JSON.parse(assistantEvent("msg_abc", "hi")));
-    expect(key).toBe("assistant:msg_abc");
-  });
-
-  it("keys user tool_result events by tool_use_id", () => {
-    const key = eventDedupKey(JSON.parse(userToolResultEvent("toolu_1", "ok")));
-    expect(key).toBe("user:tool_result:toolu_1");
-  });
-
-  it("keys system init events by session_id", () => {
-    const key = eventDedupKey(JSON.parse(systemInitEvent("sess_xyz")));
-    expect(key).toBe("system:init:sess_xyz");
-  });
-
-  it("keys result events by session_id", () => {
-    const key = eventDedupKey(JSON.parse(resultEvent("sess_xyz")));
-    expect(key).toBe("result:sess_xyz");
-  });
-
-  it("returns null for assistant events missing message.id", () => {
-    const event = { type: "assistant", message: { content: [] } };
-    expect(eventDedupKey(event)).toBeNull();
-  });
-
-  it("returns null for unknown event types", () => {
-    expect(eventDedupKey({ type: "unknown" })).toBeNull();
-    expect(eventDedupKey({})).toBeNull();
-  });
-});
-
-describe("LogLineDedupFilter", () => {
-  it("passes unique lines through unchanged", () => {
-    const filter = new LogLineDedupFilter();
-    const a = assistantEvent("msg_1", "hello");
-    const b = assistantEvent("msg_2", "world");
-    expect(filter.filter(`${a}\n${b}\n`)).toBe(`${a}\n${b}\n`);
-  });
-
-  it("drops assistant events replayed with the same message.id", () => {
-    const filter = new LogLineDedupFilter();
-    const a = assistantEvent("msg_1", "Three nits to fix.");
-    filter.filter(`${a}\n`);
-    expect(filter.filter(`${a}\n`)).toBe("");
-  });
-
-  it("drops user tool_result events replayed with the same tool_use_id", () => {
-    const filter = new LogLineDedupFilter();
-    const a = userToolResultEvent("toolu_abc", "file contents");
-    filter.filter(`${a}\n`);
-    expect(filter.filter(`${a}\n`)).toBe("");
-  });
-
-  it("drops system init and result events on replay", () => {
-    const filter = new LogLineDedupFilter();
-    const init = systemInitEvent("sess_1");
-    const result = resultEvent("sess_1");
-    filter.filter(`${init}\n${result}\n`);
-    expect(filter.filter(`${init}\n${result}\n`)).toBe("");
-  });
-
-  it("buffers incomplete trailing lines across chunks", () => {
-    const filter = new LogLineDedupFilter();
-    const line = assistantEvent("msg_1", "hello");
-    const mid = Math.floor(line.length / 2);
-    const out1 = filter.filter(line.slice(0, mid));
-    const out2 = filter.filter(line.slice(mid) + "\n");
-    expect(out1).toBe("");
-    expect(out2).toBe(`${line}\n`);
-  });
-
-  it("flush() emits a final incomplete line that was not replayed", () => {
-    const filter = new LogLineDedupFilter();
-    const line = assistantEvent("msg_tail", "no newline");
-    filter.filter(line);
-    expect(filter.flush()).toBe(line);
-  });
-
-  it("flush() drops an incomplete line that was already seen with a newline", () => {
-    const filter = new LogLineDedupFilter();
-    const line = assistantEvent("msg_same", "x");
-    filter.filter(`${line}\n`);
-    filter.filter(line);
-    expect(filter.flush()).toBe("");
-  });
-
-  it("passes non-JSON lines through every time (does not dedup paperclip status)", () => {
-    const filter = new LogLineDedupFilter();
-    const status = "[paperclip] keepalive — job foo running\n";
-    expect(filter.filter(status)).toBe(status);
-    expect(filter.filter(status)).toBe(status);
-  });
-
-  it("dedups structurally identical JSON with identical content (raw fallback)", () => {
-    const filter = new LogLineDedupFilter();
-    // No recognized type → raw fallback key.
-    const line = JSON.stringify({ foo: "bar", baz: 1 });
-    filter.filter(`${line}\n`);
-    expect(filter.filter(`${line}\n`)).toBe("");
-  });
-
-  it("handles multiple complete lines in a single chunk with partial trailing", () => {
-    const filter = new LogLineDedupFilter();
-    const a = assistantEvent("msg_a", "a");
-    const b = assistantEvent("msg_b", "b");
-    const c = assistantEvent("msg_c", "c");
-    // a and b are complete, c is partial (no trailing newline).
-    const out = filter.filter(`${a}\n${b}\n${c}`);
-    expect(out).toBe(`${a}\n${b}\n`);
-    // Completing c later should emit exactly c.
-    expect(filter.filter("\n")).toBe(`${c}\n`);
-  });
-
-  it("drops the classic FAR-123 replay scenario across reconnects", () => {
-    const filter = new LogLineDedupFilter();
-    const assistantNits = assistantEvent("msg_nits", "Three nits to fix. Let me look at an existing test file...");
-    const assistantWrite = assistantEvent("msg_write", "Now I need to write unit tests");
-    // First stream attempt emits both events.
-    const out1 = filter.filter(`${assistantNits}\n${assistantWrite}\n`);
-    expect(out1).toBe(`${assistantNits}\n${assistantWrite}\n`);
-    // Reconnect replays both within the sinceSeconds overlap — filter should drop them.
-    const out2 = filter.filter(`${assistantNits}\n${assistantWrite}\n`);
-    expect(out2).toBe("");
-    // And a genuinely new event after the replay should still pass through.
-    const assistantFresh = assistantEvent("msg_fresh", "next turn");
-    expect(filter.filter(`${assistantFresh}\n`)).toBe(`${assistantFresh}\n`);
-  });
-});
@@ -1,146 +0,0 @@
-/**
- * Line-level dedup filter for the K8s log stream.
- *
- * The K8s log follow stream can reconnect with an overlapping `sinceSeconds`
- * window (integer-second granularity + a safety buffer), which replays a few
- * seconds of recent output on every reconnect. Without dedup those replayed
- * lines appear as duplicate events in the streaming UI — the same assistant
- * text block shows up between every subsequent tool call (FAR-123).
- *
- * The filter operates at the chunk → line level: chunks are split on `\n`,
- * incomplete trailing content is buffered until the next chunk, and each
- * complete line is emitted at most once. JSON-shaped Claude stream-json
- * events are keyed by their stable structural IDs; non-JSON lines pass
- * through unchanged so genuinely-repeated status lines are not swallowed.
- */
-
-type Parsed = Record<string, unknown>;
-
-function asString(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
-
-function asRecord(value: unknown): Parsed | null {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
-  return value as Parsed;
-}
-
-/**
- * Build a stable dedup key for a Claude stream-json event.  Returns `null`
- * when the event is not a recognized Claude event — those lines fall back to
- * raw-content hashing so non-JSON output (paperclip status lines, shell
- * output) is never deduped by identity.
- */
-export function eventDedupKey(event: Parsed): string | null {
-  const type = asString(event.type);
-
-  if (type === "system") {
-    const subtype = asString(event.subtype);
-    const sessionId = asString(event.session_id);
-    if (subtype === "init" && sessionId) return `system:init:${sessionId}`;
-    return null;
-  }
-
-  if (type === "assistant") {
-    const message = asRecord(event.message);
-    const id = message ? asString(message.id) : "";
-    if (id) return `assistant:${id}`;
-    return null;
-  }
-
-  if (type === "user") {
-    const message = asRecord(event.message);
-    const content = message && Array.isArray(message.content) ? message.content : [];
-    const toolUseIds: string[] = [];
-    for (const entry of content) {
-      const block = asRecord(entry);
-      if (!block) continue;
-      const toolUseId = asString(block.tool_use_id);
-      if (toolUseId) toolUseIds.push(toolUseId);
-    }
-    if (toolUseIds.length > 0) return `user:tool_result:${toolUseIds.join(",")}`;
-    return null;
-  }
-
-  if (type === "result") {
-    const sessionId = asString(event.session_id);
-    return sessionId ? `result:${sessionId}` : "result:unknown";
-  }
-
-  return null;
-}
-
-/**
- * Stateful line-level dedup filter.  Emits `filter(chunk)` output through
- * the caller — preserves original chunk formatting (including trailing
- * newlines) for lines that pass the dedup check.
- */
-export class LogLineDedupFilter {
-  private buffer = "";
-  private readonly seenKeys = new Set<string>();
-
-  /**
-   * Process a chunk and return the subset that should be forwarded.
-   * Incomplete trailing content (no terminating newline) is buffered and
-   * emitted on the next chunk that completes the line (or on flush()).
-   */
-  filter(chunk: string): string {
-    if (!chunk) return "";
-    const combined = this.buffer + chunk;
-    const endsWithNewline = combined.endsWith("\n");
-    const parts = combined.split("\n");
-
-    if (endsWithNewline) {
-      // Discard the final empty element — last line was complete.
-      parts.pop();
-      this.buffer = "";
-    } else {
-      // Last element is an incomplete line — hold it for the next chunk.
-      this.buffer = parts.pop() ?? "";
-    }
-
-    const out: string[] = [];
-    for (const line of parts) {
-      if (this.shouldEmit(line)) out.push(line);
-    }
-    if (out.length === 0) return "";
-    return out.join("\n") + "\n";
-  }
-
-  /**
-   * Flush any incomplete trailing content.  Called when the stream ends
-   * without a terminating newline so the final partial line isn't lost.
-   */
-  flush(): string {
-    const pending = this.buffer;
-    this.buffer = "";
-    if (!pending) return "";
-    return this.shouldEmit(pending) ? pending : "";
-  }
-
-  private shouldEmit(line: string): boolean {
-    const trimmed = line.trim();
-    if (!trimmed) return true;
-
-    // Only attempt dedup on JSON-shaped lines; pass shell/text output through.
-    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return true;
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      return true;
-    }
-
-    const event = asRecord(parsed);
-    if (!event) return true;
-
-    // Recognized Claude stream-json event → structural key.
-    const structuralKey = eventDedupKey(event);
-    const key = structuralKey ?? `raw:${trimmed}`;
-
-    if (this.seenKeys.has(key)) return false;
-    this.seenKeys.add(key);
-    return true;
-  }
-}
@@ -50,3 +50,4 @@ describe("listK8sModels", () => {
    expect(models.some((m) => m.id === "claude-opus-4-7")).toBe(true);
  });
 });
+
@@ -154,6 +154,131 @@ more raw output`;
    // Should not be "Hello world\n\nHello world"
    expect(result.summary.split("Hello world").length).toBe(2);
  });
+
+  it("sets llmApiEmptyResponse=true when stop_reason:null and usage.output_tokens:0", () => {
+    const initLine = JSON.stringify({ type: "system", subtype: "init", model: "MiniMax-M2.7", session_id: "sess_1" });
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      session_id: "sess_1",
+      message: {
+        id: "msg_abc",
+        stop_reason: null,
+        usage: { input_tokens: 100, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 },
+        content: [],
+      },
+    });
+    const result = parseClaudeStreamJson([initLine, assistantEvent].join("\n"));
+    expect(result.llmApiEmptyResponse).toBe(true);
+    expect(result.resultJson).toBeNull();
+  });
+
+  it("sets llmApiEmptyResponse=true when stop_reason:null and message-level output_tokens:0", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: { stop_reason: null, output_tokens: 0, content: [] },
+    });
+    const result = parseClaudeStreamJson(assistantEvent);
+    expect(result.llmApiEmptyResponse).toBe(true);
+  });
+
+  it("does not set llmApiEmptyResponse when stop_reason is non-null", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: {
+        stop_reason: "end_turn",
+        usage: { output_tokens: 0 },
+        content: [],
+      },
+    });
+    const result = parseClaudeStreamJson(assistantEvent);
+    expect(result.llmApiEmptyResponse).toBe(false);
+  });
+
+  it("does not set llmApiEmptyResponse when output_tokens > 0", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: {
+        stop_reason: null,
+        usage: { output_tokens: 5 },
+        content: [{ type: "text", text: "hello" }],
+      },
+    });
+    const result = parseClaudeStreamJson(assistantEvent);
+    expect(result.llmApiEmptyResponse).toBe(false);
+  });
+
+  it("clears llmApiEmptyResponse when a result event follows the empty assistant event", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: { stop_reason: null, usage: { output_tokens: 0 }, content: [] },
+    });
+    const resultEvent = JSON.stringify({
+      type: "result",
+      result: "Done",
+      subtype: "stop",
+      total_cost_usd: 0.001,
+      usage: { input_tokens: 10, output_tokens: 5, cache_read_input_tokens: 0 },
+    });
+    const result = parseClaudeStreamJson([assistantEvent, resultEvent].join("\n"));
+    expect(result.llmApiEmptyResponse).toBe(false);
+    expect(result.resultJson).not.toBeNull();
+  });
+
+  it("sets truncatedMidStream=true when assistant event with output_tokens>0 has no result (FAR-95)", () => {
+    const initLine = JSON.stringify({ type: "system", subtype: "init", model: "claude-opus-4-7", session_id: "sess_1" });
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      session_id: "sess_1",
+      message: {
+        id: "msg_abc",
+        stop_reason: null,
+        usage: { input_tokens: 1, output_tokens: 35, cache_creation_input_tokens: 523, cache_read_input_tokens: 46295 },
+        content: [{ type: "tool_use", id: "tool_1", name: "Bash", input: { command: "echo hi" } }],
+      },
+    });
+    const result = parseClaudeStreamJson([initLine, assistantEvent].join("\n"));
+    expect(result.truncatedMidStream).toBe(true);
+    expect(result.llmApiEmptyResponse).toBe(false);
+    expect(result.resultJson).toBeNull();
+  });
+
+  it("clears truncatedMidStream when a result event follows assistant content", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: { stop_reason: null, usage: { output_tokens: 35 }, content: [] },
+    });
+    const resultEvent = JSON.stringify({
+      type: "result",
+      result: "Done",
+      subtype: "stop",
+      total_cost_usd: 0.001,
+      usage: { input_tokens: 10, output_tokens: 5, cache_read_input_tokens: 0 },
+    });
+    const result = parseClaudeStreamJson([assistantEvent, resultEvent].join("\n"));
+    expect(result.truncatedMidStream).toBe(false);
+    expect(result.resultJson).not.toBeNull();
+  });
+
+  it("does not set truncatedMidStream when assistant has output_tokens=0", () => {
+    const assistantEvent = JSON.stringify({
+      type: "assistant",
+      message: { stop_reason: null, usage: { output_tokens: 0 }, content: [] },
+    });
+    const result = parseClaudeStreamJson(assistantEvent);
+    expect(result.truncatedMidStream).toBe(false);
+  });
+
+  it("sets llmApiEmptyResponse=false for normal result", () => {
+    const resultEvent = JSON.stringify({
+      type: "result",
+      result: "Done",
+      subtype: "stop",
+      total_cost_usd: 0.005,
+      usage: { input_tokens: 100, output_tokens: 200, cache_read_input_tokens: 50 },
+    });
+    const result = parseClaudeStreamJson(resultEvent);
+    expect(result.llmApiEmptyResponse).toBe(false);
+  });
 });

 describe("extractClaudeLoginUrl", () => {
@@ -15,6 +15,14 @@ export function parseClaudeStreamJson(stdout: string) {
  // at the line level; this guard only needs to protect against the same
  // message block being parsed twice.
  const seenBlocks = new Set<string>();
+  // Set when we see stop_reason:null + output_tokens:0 on an assistant event
+  // with no subsequent result event — indicates the upstream LLM API returned
+  // an empty/malformed response (e.g. MiniMax degraded performance).
+  let llmApiEmptyResponse = false;
+  // Set when an assistant event with output_tokens > 0 was seen but no result
+  // event arrived — indicates the run was truncated mid-stream (pod terminated,
+  // OOMKill, or claude CLI crash after producing content).
+  let assistantContentSeen = false;

  for (const rawLine of stdout.split(/\r?\n/)) {
    const line = rawLine.trim();
@@ -34,6 +42,21 @@ export function parseClaudeStreamJson(stdout: string) {
      const message = parseObject(event.message);
      const messageId = asString(message.id, "");
      const content = Array.isArray(message.content) ? message.content : [];
+
+      // Detect empty LLM API response: stop_reason:null with zero output tokens.
+      // output_tokens may appear directly on message or nested under message.usage.
+      const stopReason = message.stop_reason;
+      const usageObj = parseObject(message.usage as Record<string, unknown>);
+      const outputTokens = typeof message.output_tokens === "number"
+        ? message.output_tokens
+        : asNumber(usageObj.output_tokens, -1);
+      if (stopReason === null && outputTokens === 0) {
+        llmApiEmptyResponse = true;
+      }
+      if (outputTokens > 0) {
+        assistantContentSeen = true;
+      }
+
      for (let i = 0; i < content.length; i++) {
        const entry = content[i];
        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
@@ -55,6 +78,8 @@ export function parseClaudeStreamJson(stdout: string) {

    if (type === "result") {
      finalResult = event;
+      llmApiEmptyResponse = false; // result event means Claude completed normally
+      assistantContentSeen = false; // result event means stream was not truncated
      sessionId = asString(event.session_id, sessionId ?? "") || sessionId;
    }
  }
@@ -67,6 +92,8 @@ export function parseClaudeStreamJson(stdout: string) {
      usage: null as UsageSummary | null,
      summary: assistantTexts.join("\n\n").trim(),
      resultJson: null as Record<string, unknown> | null,
+      llmApiEmptyResponse,
+      truncatedMidStream: assistantContentSeen,
    };
  }

@@ -87,6 +114,8 @@ export function parseClaudeStreamJson(stdout: string) {
    usage,
    summary,
    resultJson: finalResult,
+    llmApiEmptyResponse: false,
+    truncatedMidStream: false,
  };
 }