agent-harness 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11c53accd50a5842f5f67a3ef1adb97e2d25539966e08cf5ed1a2659b047ce0b
-  data.tar.gz: 562f0baad4bdc24dda2dcb7d65ef93d7657be1e64e2460400afc28e7ac419afa
+  metadata.gz: 0a5be3b23b73351341808a0f62fb6e060f226c309ceb508c378ad3d549273e61
+  data.tar.gz: aa6f754664cd08deeb36f8a54ec3531249a10c80bbe6561706a59db1191afe4f
 SHA512:
-  metadata.gz: c9e7fb58eb6298e79f193b9de47c5fff995f92be7a9aff396277cf64489022d92030464b5cc08da506cc4496a4872dfc1fea1ca880f3d4cb82ad5133eaa65622
-  data.tar.gz: 40ca98102aedafdefb12d00794b721b0eb04f376eb7695034ca840ce17582abfb0741cd689f5c1a27b516acffa85399f9b58550fb516fe8e9e5652c3bb01d8d0
+  metadata.gz: d28ce3a2ecc67df9f125c1bb82f51192811fd5cd8394252f9450ec746876d125d2487a65eef6bbf925bdb4438bd74e554213d9ac5aacbbca398357ba32ae1570
+  data.tar.gz: 63f514add56b1975e1d1a70f1962f8512a9af6eb4427ce893d4fd1c364bc054824fd5208198d61a6ecab0162cd4d382351bb09bcec7c4c0c7f63c5804ac007cd

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.6.0"
+  ".": "0.7.0"
 }

data/CHANGELOG.md

@@ -1,5 +1,158 @@
 ## [Unreleased]
 
+## [0.7.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.6.0...agent-harness/v0.7.0) (2026-04-13)
+
+
+### Features
+
+* **copilot:** add JSON output parsing and token extraction ([4f5fc5a](https://github.com/viamin/agent-harness/commit/4f5fc5acd8d45ac8563998a132a0c4878f3b9e0a))
+* **kilocode:** extract token usage from Kilo CLI structured JSON output ([b5384f8](https://github.com/viamin/agent-harness/commit/b5384f8be52431f95d8aa3524a33ceed6bf094eb)), closes [#97](https://github.com/viamin/agent-harness/issues/97)
+
+
+### Bug Fixes
+
+* **copilot:** add nil guard for stdout and improve error string construction ([6a30ce3](https://github.com/viamin/agent-harness/commit/6a30ce342100b27c0b16fc8c2abdce48bbf10ef7))
+* **copilot:** align error ordering with base parser ([0a02d34](https://github.com/viamin/agent-harness/commit/0a02d34cbf07e4f4ecb4d3efc6d69b5b072c6114))
+* **copilot:** align metadata and reply parsing ([e5c3387](https://github.com/viamin/agent-harness/commit/e5c338743dbb5ec8eea5b1a8de5a515f1df7e141))
+* **copilot:** avoid double-counting token aliases ([40e78f3](https://github.com/viamin/agent-harness/commit/40e78f34a6304a5ae21e26c6c291eed773618bea))
+* **copilot:** avoid mixing shutdown token totals ([c4bdfb8](https://github.com/viamin/agent-harness/commit/c4bdfb8fd4c20781ef4621cf421947b14514cb45))
+* **copilot:** drop superseded delta chunks ([769acd6](https://github.com/viamin/agent-harness/commit/769acd6a45f1037f11fc83ea23f5ddeda9aadd17))
+* **copilot:** fall back across malformed token aliases ([9c9f5f8](https://github.com/viamin/agent-harness/commit/9c9f5f8048f63407b6ffc14fb339c26158f74dab))
+* **copilot:** fall back from empty nested message content ([ecd9f49](https://github.com/viamin/agent-harness/commit/ecd9f497e0ef9812f2df363b02679b5842cf668c))
+* **copilot:** fall back from empty shutdown metrics ([0397f1e](https://github.com/viamin/agent-harness/commit/0397f1e5f9442d0d6489c9fe7744d31a0ff48965))
+* **copilot:** fall back from malformed nested message content ([a313487](https://github.com/viamin/agent-harness/commit/a313487f2c1bb9fbf5e7a60e5dc08e7a7079447c))
+* **copilot:** fall back from malformed usage payloads ([733599c](https://github.com/viamin/agent-harness/commit/733599c599cda90873cec823c245b13c81f74ee6))
+* **copilot:** gate json output by cli version ([528d03b](https://github.com/viamin/agent-harness/commit/528d03bed7506996cf9cfd6c4cf54807da254260))
+* **copilot:** guard scalar json events ([13a4131](https://github.com/viamin/agent-harness/commit/13a413157cc159cfc4fd6b7e7ab7fdbb948d07b6))
+* **copilot:** handle JSON event envelopes and camelCase token fields ([e0ee83e](https://github.com/viamin/agent-harness/commit/e0ee83ed73d715d9c67806b5253abab33cce9e19))
+* **copilot:** hash unresolved probe path keys ([ea9aca2](https://github.com/viamin/agent-harness/commit/ea9aca215b000833be18bf035cba6c0bf029615d))
+* **copilot:** hide structured control events from output ([81c108d](https://github.com/viamin/agent-harness/commit/81c108d521e8f72522dc1dc604cccdf46f0d01d4))
+* **copilot:** ignore delta chunks after final reply ([6aef1ca](https://github.com/viamin/agent-harness/commit/6aef1ca4459a5588fc53b70692f95c6eff3b9d88))
+* **copilot:** ignore empty delta chunks ([dca6395](https://github.com/viamin/agent-harness/commit/dca63951866a4dc65b2adca3b834d05a6716f298))
+* **copilot:** ignore failed version probes ([fa6ba35](https://github.com/viamin/agent-harness/commit/fa6ba35e1e36f153f47bccf9c423cea7927176e7))
+* **copilot:** ignore malformed delta content fallback ([0c9211b](https://github.com/viamin/agent-harness/commit/0c9211bb16e713f4b7185c1b9ccda5d065b9d405))
+* **copilot:** ignore malformed token payloads ([0f2f06b](https://github.com/viamin/agent-harness/commit/0f2f06b9a8c0b4244c7b8040e5590cc6e4710143))
+* **copilot:** ignore malformed typed json fallbacks ([0cd5535](https://github.com/viamin/agent-harness/commit/0cd553594aff277ce07abd3d151028ad22b3f597))
+* **copilot:** ignore nested non-assistant fallback text ([799f976](https://github.com/viamin/agent-harness/commit/799f976ef19618acaae1a6e0ecf7faa76b9ff37f))
+* **copilot:** ignore non-assistant top-level messages ([119c854](https://github.com/viamin/agent-harness/commit/119c8540e7db9f1827eac75e73403b638cf8db23))
+* **copilot:** ignore non-assistant top-level token payloads ([23c05b9](https://github.com/viamin/agent-harness/commit/23c05b9dbc6231755783f4a8eefd5099067f9389))
+* **copilot:** ignore partial invalid token aliases ([3344c07](https://github.com/viamin/agent-harness/commit/3344c078d291277b8831ab69fa5d2a40ca95135b))
+* **copilot:** isolate probe cache for PATH overrides ([5fa79a9](https://github.com/viamin/agent-harness/commit/5fa79a91fd90dd33a15d5c6a0c25c2619b8f0ac3))
+* **copilot:** keep delta output on empty final reply ([64fbf68](https://github.com/viamin/agent-harness/commit/64fbf68ffb66b58d7546bc1841c78fec86201acb))
+* **copilot:** keep preflight errors inside base handler ([49c9075](https://github.com/viamin/agent-harness/commit/49c9075d4a1fb9ff42d633723cb5f375e8c2721c))
+* **copilot:** merge partial shutdown token totals ([49d6b2b](https://github.com/viamin/agent-harness/commit/49d6b2b6727297a58e9aa265347c781405012aa0))
+* **copilot:** merge top-level token fallbacks ([826c1f9](https://github.com/viamin/agent-harness/commit/826c1f9fd427b10c40fb34c5b47f4c9fb06f1e64))
+* **copilot:** parse session shutdown token totals ([0148afd](https://github.com/viamin/agent-harness/commit/0148afd2f95312eae687799541545dd8ece185f3))
+* **copilot:** parse streamed delta reply events ([55f553f](https://github.com/viamin/agent-harness/commit/55f553f39dbe729588641b86168f8c36500ec872))
+* **copilot:** prefer final replies and trim probe cache keys ([38dc20e](https://github.com/viamin/agent-harness/commit/38dc20edac2326265c8f9d149394650b70c43e90))
+* **copilot:** prefer final reply over delta chunks ([955654d](https://github.com/viamin/agent-harness/commit/955654db325cc47c8cf0ac992de55e574a45c641))
+* **copilot:** prefer nested assistant message fallback ([15aa6db](https://github.com/viamin/agent-harness/commit/15aa6dbf4bb171eaaa5b85c552008953141ba622))
+* **copilot:** prefer per-turn usage over shutdown totals ([38bd47c](https://github.com/viamin/agent-harness/commit/38bd47c00e5d74ef365a74dc61df9e2fdc5b9c04))
+* **copilot:** prefer populated top-level usage payloads ([8b3aac0](https://github.com/viamin/agent-harness/commit/8b3aac029004f65efe26e8b3fc27f62ac2008dca))
+* **copilot:** preserve blank mixed output lines ([e9830fc](https://github.com/viamin/agent-harness/commit/e9830fcfcceeb7fc67caac658ed16867e1f303d0))
+* **copilot:** preserve empty nested message payloads ([edf27bc](https://github.com/viamin/agent-harness/commit/edf27bcafbfb29dc0f5baf54fcedb8e959e20bba))
+* **copilot:** preserve empty top-level fallback payloads ([1863854](https://github.com/viamin/agent-harness/commit/1863854af8545573a6c9a80cc47297487ee6d2ac))
+* **copilot:** preserve legitimate exit codes in responses ([d1a3cc0](https://github.com/viamin/agent-harness/commit/d1a3cc0f21ea1a45fee0dbf181462efc8b414fc8))
+* **copilot:** preserve literal json stdout ([7d7862c](https://github.com/viamin/agent-harness/commit/7d7862c4da83ccf9bafbbca19b595911923edeed))
+* **copilot:** preserve malformed top-level json output ([f7c5bec](https://github.com/viamin/agent-harness/commit/f7c5becaa01584c53f1327be0afbd2fcebe7f3e8))
+* **copilot:** preserve malformed usage hashes ([0eef69b](https://github.com/viamin/agent-harness/commit/0eef69b470927412c405a774125ca0aa9a58e302))
+* **copilot:** preserve mixed json and text output ([95de0f7](https://github.com/viamin/agent-harness/commit/95de0f72a2bd8a86d33ab0806fb1baf481e52d03))
+* **copilot:** preserve mixed output line boundaries ([b285526](https://github.com/viamin/agent-harness/commit/b28552627192aa613c73c7bf2c8c8afed6811c36))
+* **copilot:** preserve mixed plain-text output ([d277f3a](https://github.com/viamin/agent-harness/commit/d277f3a4ed2799182a2083989a0bdaf9960df16b))
+* **copilot:** preserve non-event typed json output ([27d01c6](https://github.com/viamin/agent-harness/commit/27d01c649cab65ba2da206636f45170af5abbcc9))
+* **copilot:** preserve scalar json stdout ([7c5e74c](https://github.com/viamin/agent-harness/commit/7c5e74cd9aed9de17f572b98faac9c09b8cd9707))
+* **copilot:** preserve unknown typed json output ([942edac](https://github.com/viamin/agent-harness/commit/942edac7bc36d9e26a7c02945f15503ce7faeb73))
+* **copilot:** preserve zero token aliases ([853d251](https://github.com/viamin/agent-harness/commit/853d251869adb3cc36bebc5b6d750a58c70843f7))
+* **copilot:** probe json support per request env ([da94082](https://github.com/viamin/agent-harness/commit/da94082a79a044eb89b470b26eeda29196e7ac95))
+* **copilot:** reject invalid token counts ([106c386](https://github.com/viamin/agent-harness/commit/106c3867d024751e77aa0fc215c651de87230a13))
+* **copilot:** restore reply token fallback ([c9d7182](https://github.com/viamin/agent-harness/commit/c9d71820b0becc80e44a77169c2990be20469be2))
+* **copilot:** restrict token accumulation to usage event types only ([80c979b](https://github.com/viamin/agent-harness/commit/80c979b9952defa05923920a737bb74e1c8885e4))
+* **copilot:** skip blank assistant boundaries ([b9dec9a](https://github.com/viamin/agent-harness/commit/b9dec9af0c6084e1809dc1fb1c50535b987037a1))
+* **copilot:** skip json parsing in legacy mode ([af9ac12](https://github.com/viamin/agent-harness/commit/af9ac1253aa4246c92727bc04f23d6704ec8926e))
+* **copilot:** store probe env per thread ([301f2aa](https://github.com/viamin/agent-harness/commit/301f2aa4c43b183dea8450d21eb7fec799e92ec6))
+* **copilot:** stub json support in parser specs ([96a945e](https://github.com/viamin/agent-harness/commit/96a945ec1572e10231b696008c7514d1acb92c11))
+* **copilot:** sum reply token fallback ([82c5097](https://github.com/viamin/agent-harness/commit/82c5097b73f17e64cd3015c34aa92bfd713c0428))
+* **copilot:** support snake_case delta chunks ([d33ecbc](https://github.com/viamin/agent-harness/commit/d33ecbcc446d895d35f03a7513ad7b16f0f57b1d))
+* **copilot:** support snake_case shutdown metrics ([8c6e93e](https://github.com/viamin/agent-harness/commit/8c6e93e70e0927c95c63811b247291faaceacab0))
+* **copilot:** suppress additional control events ([b14b8bb](https://github.com/viamin/agent-harness/commit/b14b8bbebb2fcc0c975788c1168965bee3281a79))
+* **copilot:** suppress control event namespaces ([7b31bb2](https://github.com/viamin/agent-harness/commit/7b31bb293fb858808e493a23e268d89a590741a0))
+* **copilot:** suppress root control events ([5d4d3ec](https://github.com/viamin/agent-harness/commit/5d4d3ecb80864ad4d20e0da1083ac02d90773fbf))
+* **copilot:** update output_format metadata and add missing parse_response tests ([7fdedde](https://github.com/viamin/agent-harness/commit/7fdeddee3bbe5eca96f29f5613a5c36189695ec4))
+* **kilocode:** aggregate token counts across multiple step_finish events ([23c8c55](https://github.com/viamin/agent-harness/commit/23c8c55def0452de1e0b25765c4f6d1fcd3474d4))
+* **kilocode:** avoid raw ndjson in structured failures ([932e56e](https://github.com/viamin/agent-harness/commit/932e56e06567095750a7bcf15bf5adea065eab44))
+* **kilocode:** clear stale extra usage categories ([2ff7079](https://github.com/viamin/agent-harness/commit/2ff70795a9e3397d5844de92c47a59b49a599426))
+* **kilocode:** count extra result usage tokens ([f65dd3d](https://github.com/viamin/agent-harness/commit/f65dd3d8e4f54174b18233ddd55dba2d3c3fd1f3))
+* **kilocode:** count reasoning and cache step tokens ([c46d089](https://github.com/viamin/agent-harness/commit/c46d089d4d0492534d98736dcdcb1ff82a67d0c1))
+* **kilocode:** fail on structured error events ([48f5378](https://github.com/viamin/agent-harness/commit/48f5378f37cf64af28238c67314a01a3758aab05))
+* **kilocode:** fall back to result text after blank chunks ([7508c58](https://github.com/viamin/agent-harness/commit/7508c58a84f365a680578891dd582a6f13484f1e))
+* **kilocode:** fall back to step token totals when usage is incomplete ([8534691](https://github.com/viamin/agent-harness/commit/8534691ff74ba4efa1ae5d50de329bc53e863bcf))
+* **kilocode:** fall through blank part message aliases ([85db058](https://github.com/viamin/agent-harness/commit/85db05824684cde93755c4d87323bce79e0a1dd7))
+* **kilocode:** fall through blank part text chunks ([417a4c8](https://github.com/viamin/agent-harness/commit/417a4c8005f23c28f5a68a834890614ca49c5dca))
+* **kilocode:** fall through blank text aliases ([63ed6a1](https://github.com/viamin/agent-harness/commit/63ed6a1bb002329ab823a8844e0ac81ef065938b))
+* **kilocode:** guard malformed structured output payloads ([30a59a2](https://github.com/viamin/agent-harness/commit/30a59a21d3b4012cec4dbfa27b5471b9dee329bd))
+* **kilocode:** guard scalar structured error payloads ([26843a9](https://github.com/viamin/agent-harness/commit/26843a90019d3f29f15eb363d098f0bba0f00582))
+* **kilocode:** guard step_finish part.tokens against non-Hash values ([ff2d841](https://github.com/viamin/agent-harness/commit/ff2d8414eb928bd679d9754a71d0849963298a4b))
+* **kilocode:** honor explicit usage totals ([d1e5275](https://github.com/viamin/agent-harness/commit/d1e5275f3515ae40db4b523e0efe2ce8a3d169a1))
+* **kilocode:** honor later explicit total alias updates ([496df42](https://github.com/viamin/agent-harness/commit/496df425a8a5e76e97134dea8b1f74a0067aad1b))
+* **kilocode:** honor synthesized result usage totals ([b0779a7](https://github.com/viamin/agent-harness/commit/b0779a78400c1a3b6aa38610582c5cf96446b28e))
+* **kilocode:** honor valid total fallback aliases ([d0ae122](https://github.com/viamin/agent-harness/commit/d0ae12245be3e606d0919bf78dcc858525c64036))
+* **kilocode:** ignore blank terminal result strings ([ebb34b6](https://github.com/viamin/agent-harness/commit/ebb34b663c7c0a933aedc17efba444263a891b80))
+* **kilocode:** ignore negative token counts ([aee8d1e](https://github.com/viamin/agent-harness/commit/aee8d1e35e438ae25bf3a37571d273d891b89b24))
+* **kilocode:** ignore non-string text payloads ([4a35a6f](https://github.com/viamin/agent-harness/commit/4a35a6fb1555923b3d1555bc895051bbaa7db26c))
+* **kilocode:** ignore scalar json fallback noise ([1f62463](https://github.com/viamin/agent-harness/commit/1f624631477557ae533d605ecf37a5fb40c39544))
+* **kilocode:** ignore usage on non-usage events ([b23ac10](https://github.com/viamin/agent-harness/commit/b23ac10c0d4107e05a50a2dc83204c0088bddbbb))
+* **kilocode:** ignore whitespace-only text alias placeholders ([62bb641](https://github.com/viamin/agent-harness/commit/62bb641a7b7ac5434b2e905c6b297b2abf989020))
+* **kilocode:** ignore whitespace-only text chunks ([699cccc](https://github.com/viamin/agent-harness/commit/699cccc1025b83a3850b7ed2670ff60de39e6adf))
+* **kilocode:** keep last usable structured usage payload ([1b9d9bd](https://github.com/viamin/agent-harness/commit/1b9d9bd7ebbaa0ae9ed6dd7379f9b8c67de19025))
+* **kilocode:** keep stdout diagnostics with structured errors ([76446fc](https://github.com/viamin/agent-harness/commit/76446fc8a95c89c9944b47db794ddb776e29686f))
+* **kilocode:** merge partial structured usage events ([2de37e2](https://github.com/viamin/agent-harness/commit/2de37e246317650f60a0399c2f731f03ecf28ec9))
+* **kilocode:** normalize malformed token counts ([ef4c3dc](https://github.com/viamin/agent-harness/commit/ef4c3dce783e71aae1b60c543da59f64b4efdb6c))
+* **kilocode:** parse hash-shaped structured error aliases ([431f8c4](https://github.com/viamin/agent-harness/commit/431f8c438d7b13bf45d3416e947d3ad34b8b4eca))
+* **kilocode:** parse NDJSON event stream instead of single JSON object ([4e1252f](https://github.com/viamin/agent-harness/commit/4e1252fc384c51d118b43647a7026281927b6794))
+* **kilocode:** parse nested part error messages ([8d49794](https://github.com/viamin/agent-harness/commit/8d49794f79bbe553cfe8f569867508bb80a86805))
+* **kilocode:** parse nested structured error messages ([b9fee6a](https://github.com/viamin/agent-harness/commit/b9fee6a8814045f0c5329bac23b0f0b424b17566))
+* **kilocode:** parse token usage from step_finish.part.tokens ([bbf5a58](https://github.com/viamin/agent-harness/commit/bbf5a58fc6bc631a483a3e71bc0d8b99744e9f7b))
+* **kilocode:** pass legitimate_exit_codes in Response metadata ([dac77c2](https://github.com/viamin/agent-harness/commit/dac77c24711bf717b7d98d847a21d3922889026b))
+* **kilocode:** preserve base error stream ordering ([5281d78](https://github.com/viamin/agent-harness/commit/5281d7875c54cd010364b251069d921c4c5e4838))
+* **kilocode:** preserve extra usage totals without io counts ([b4fb265](https://github.com/viamin/agent-harness/commit/b4fb2657aa56ad42e514a42dd0176742a48fdbc4))
+* **kilocode:** preserve json array fallback output ([16cb566](https://github.com/viamin/agent-harness/commit/16cb5668e1442a9232ca5fcc38d0b196eb673956))
+* **kilocode:** preserve mixed structured failure diagnostics ([5ec3be7](https://github.com/viamin/agent-harness/commit/5ec3be7ff143803c8e9602a1d76b6c7c4c0beb12))
+* **kilocode:** preserve mixed structured success output ([ea64e2e](https://github.com/viamin/agent-harness/commit/ea64e2ea7154c15193ce35c115874bb898dcdc84))
+* **kilocode:** preserve provider token totals ([b62d749](https://github.com/viamin/agent-harness/commit/b62d7499070aa5233c56b7207b6a2aede97a7dfc))
+* **kilocode:** preserve raw mixed stdout spacing ([881c51e](https://github.com/viamin/agent-harness/commit/881c51e9a88705e0d8e28e06cb7fd7381f55feed))
+* **kilocode:** preserve raw output for non-event json ([ce9be0f](https://github.com/viamin/agent-harness/commit/ce9be0f5f8d807dda995202fbe2dc26cddee32b2))
+* **kilocode:** preserve step extras with partial usage ([14eeddb](https://github.com/viamin/agent-harness/commit/14eeddb6ec9e056c8b20ee9251e42a26de260079))
+* **kilocode:** preserve step token totals for partial usage ([5efe2f4](https://github.com/viamin/agent-harness/commit/5efe2f4d3804f52cfae1b6ee63da87d3459a8c0f))
+* **kilocode:** preserve terminal result payload spacing ([977faa7](https://github.com/viamin/agent-harness/commit/977faa7eed454c6070503589cc995f3021d19476))
+* **kilocode:** preserve terminal result text ([282ae35](https://github.com/viamin/agent-harness/commit/282ae35051b715f0210534f31adb87152c75b6b7))
+* **kilocode:** preserve terminal result text across result events ([5652453](https://github.com/viamin/agent-harness/commit/56524531434d9d7c71f7af3acd17d25dbf9656ca))
+* **kilocode:** preserve unreconstructable step totals ([a906ee9](https://github.com/viamin/agent-harness/commit/a906ee951d6dfa5aa74e149f2e41fa214ffad2cf))
+* **kilocode:** preserve unreconstructable totals with result extras ([7585e29](https://github.com/viamin/agent-harness/commit/7585e29d0eb6668f48b6db3ab033272b74d4831f))
+* **kilocode:** preserve whitespace in text alias chunks ([a6592c1](https://github.com/viamin/agent-harness/commit/a6592c12e753a91cdd8f6c0041100c2a0c01d89a))
+* **kilocode:** read terminal result text from hash payloads ([2ac7012](https://github.com/viamin/agent-harness/commit/2ac701278133e2f0fee64a7cb33f854ecff0754b))
+* **kilocode:** recompute totals from updated usage ([aafabfd](https://github.com/viamin/agent-harness/commit/aafabfd972c56e35bcaa36eb92b1658cb6579a6c))
+* **kilocode:** reject fractional token counts ([935a41d](https://github.com/viamin/agent-harness/commit/935a41d327f7d9433368db40da93ab1983e14cbc))
+* **kilocode:** reject non-decimal string token counts ([0be6ddf](https://github.com/viamin/agent-harness/commit/0be6ddf31a306face9b61498d1a77d08a94a02a5))
+* **kilocode:** remove stray binstubs and add missing test coverage ([25287f7](https://github.com/viamin/agent-harness/commit/25287f736c8bd81820553fc5ca2517e1c64f261c))
+* **kilocode:** replace stale partial extra usage fields ([4b89027](https://github.com/viamin/agent-harness/commit/4b8902768620ffb5787e194753b14f6eb7c496d7))
+* **kilocode:** skip scalar JSON lines before reading event fields ([b8fce27](https://github.com/viamin/agent-harness/commit/b8fce27bceb998a6a4b2a3de7ed95f96a2794c3d))
+* **kilocode:** support hash-shaped part text aliases ([778e25c](https://github.com/viamin/agent-harness/commit/778e25c62cf32bafd1c0fb4bae32b2ea13cf1df9))
+* **kilocode:** support nested result message aliases ([e8a5988](https://github.com/viamin/agent-harness/commit/e8a5988e34dfb1afd70eccb551985fa7e273192e))
+* **kilocode:** support result text aliases ([63ccff9](https://github.com/viamin/agent-harness/commit/63ccff9be0c32ffcfd04e3745a441d6d2370eeac))
+* **kilocode:** support scalar part structured errors ([2dd4740](https://github.com/viamin/agent-harness/commit/2dd47408f39340b075815ce64ac02c588fc445de))
+* **kilocode:** support scalar text part payloads ([b9e9013](https://github.com/viamin/agent-harness/commit/b9e90137e6b43fb2eb789857da319221203a7f76))
+* **kilocode:** support text event alias payloads ([4c425ff](https://github.com/viamin/agent-harness/commit/4c425fff93dcd872e2640743cb21da9668f952b7))
+* **kilocode:** support top-level result text aliases ([9ce7c02](https://github.com/viamin/agent-harness/commit/9ce7c0249acaf3b44731271fc8b50d8fbb14cedc))
+* **kilocode:** support top-level structured error text ([cad1d31](https://github.com/viamin/agent-harness/commit/cad1d31007d79b75daecb61b4f1ed8573f9e70a0))
+* **kilocode:** suppress raw ndjson output for structured events ([d7a07d7](https://github.com/viamin/agent-harness/commit/d7a07d70812b40a75f6a09924d1fd609e99a61df))
+* **kilocode:** treat missing usage tokens as unknown ([5e6335f](https://github.com/viamin/agent-harness/commit/5e6335f901e8f197de9c8f4df5727f90fc06ee43))
+* **kilocode:** whitelist structured event types ([d6d8a7d](https://github.com/viamin/agent-harness/commit/d6d8a7d5bf6268050bf2083494360debeec80fab))
+
+
+### Improvements
+
+* **kilocode:** remove unreachable structured error branch ([3d7ec3d](https://github.com/viamin/agent-harness/commit/3d7ec3d94e7be6b6f2c2c92d0daf0ce0590c4067))
+
 ## [0.6.0](https://github.com/viamin/agent-harness/compare/agent-harness/v0.5.9...agent-harness/v0.6.0) (2026-04-12)
 
 

data/lib/agent_harness/providers/github_copilot.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require "digest"
+require "json"
+
 module AgentHarness
   module Providers
     # GitHub Copilot CLI provider
     #
     # Provides integration with the GitHub Copilot CLI tool.
     class GithubCopilot < Base
+      MIN_JSON_OUTPUT_VERSION = Gem::Version.new("0.0.422").freeze
+      REQUEST_PROBE_ENV_STACK_KEY = :agent_harness_github_copilot_request_probe_env_stack
+
       # Model name pattern for GitHub Copilot (uses OpenAI models)
       MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
 
@@ -144,10 +150,16 @@ module AgentHarness
         :oauth
       end
 
+      def send_message(prompt:, **options)
+        with_request_probe_env(request_probe_env_from_raw_runtime(options[:provider_runtime])) do
+          super(prompt: prompt, **options)
+        end
+      end
+
       def execution_semantics
         {
           prompt_delivery: :arg,
-          output_format: :text,
+          output_format: copilot_cli_supports_json_output? ? :json : :text,
           sandbox_aware: false,
           uses_subcommand: true,
           non_interactive_flag: nil,
@@ -186,6 +198,7 @@ module AgentHarness
 
       def build_command(prompt, options)
         cmd = [self.class.binary_name, "what-the-shell", prompt]
+        cmd += ["--output-format", "json"] if copilot_cli_supports_json_output?
 
         # Opt in to unrestricted tool access explicitly to preserve a safe default.
         if supports_dangerous_mode? && options[:dangerous_mode]
@@ -203,6 +216,586 @@ module AgentHarness
       def default_timeout
         300
       end
+
+      def parse_response(result, duration:)
+        return super unless copilot_cli_supports_json_output?
+
+        output = result.stdout.to_s
+        error = nil
+
+        legitimate = execution_semantics[:legitimate_exit_codes] || [0]
+        unless legitimate.include?(result.exit_code)
+          combined = [result.stderr.to_s, output].map(&:strip).reject(&:empty?).join("\n")
+          error = combined unless combined.empty?
+        end
+
+        structured_json_seen = false
+        shutdown_tokens = empty_token_totals
+        usage_tokens = empty_token_totals
+        fallback_tokens = empty_token_totals
+        output_segments = []
+        authoritative_reply_seen = false
+        output.lines.each do |line|
+          stripped_line = line.strip
+          if stripped_line.empty?
+            output_segments << {kind: :raw, content: line, terminated: line.end_with?("\n")}
+            next
+          end
+          begin
+            obj = JSON.parse(stripped_line)
+          rescue JSON::ParserError
+            output_segments << {kind: :raw, content: line, terminated: line.end_with?("\n")}
+            next
+          end
+
+          structured_json_seen ||= obj.is_a?(Hash)
+
+          text, text_kind = extract_event_text(obj)
+          if text
+            if text_kind == :assistant_delta
+              next if authoritative_reply_seen
+
+              append_delta_segment!(output_segments, text, terminated: line.end_with?("\n"))
+            elsif !text.empty?
+              replace_assistant_segments!(output_segments, text, terminated: line.end_with?("\n"))
+              authoritative_reply_seen = true
+            end
+          elsif preserve_raw_json_line?(obj) || !obj.is_a?(Hash)
+            output_segments << {kind: :raw, content: line, terminated: line.end_with?("\n")}
+          end
+
+          token_usage = extract_token_usage(obj)
+          next unless token_usage
+
+          if token_usage[:source] == :shutdown
+            accumulate_token_totals!(shutdown_tokens, token_usage)
+          elsif token_usage[:source] == :usage
+            accumulate_token_totals!(usage_tokens, token_usage)
+          else
+            accumulate_token_totals!(fallback_tokens, token_usage)
+          end
+        end
+        tokens = build_tokens(shutdown_tokens: shutdown_tokens, usage_tokens: usage_tokens, fallback_tokens: fallback_tokens)
+        final_output = structured_json_seen ? render_output_segments(output_segments) : output
+
+        Response.new(
+          output: final_output,
+          exit_code: result.exit_code,
+          duration: duration,
+          provider: self.class.provider_name,
+          model: @config.model,
+          tokens: tokens,
+          error: error,
+          metadata: {
+            legitimate_exit_codes: legitimate
+          }
+        )
+      end
+
+      ASSISTANT_OUTPUT_EVENT_TYPES = %w[assistant assistant.message assistant.message_delta].freeze
+      ASSISTANT_TOKEN_FALLBACK_EVENT_TYPES = %w[assistant assistant.message].freeze
+      SESSION_SHUTDOWN_EVENT_TYPES = ["session.shutdown"].freeze
+      USAGE_EVENT_TYPES = %w[usage assistant.usage].freeze
+      COPILOT_EVENT_TYPE_PREFIXES = %w[
+        assistant.
+        user.
+        user_input.
+        system.
+        session.
+        tool.
+        permission.
+        elicitation.
+        exit_plan_mode.
+        skill.
+        subagent.
+        external_tool.
+        command.
+      ].freeze
+      COPILOT_EVENT_TYPES = %w[
+        abort
+        command
+        elicitation
+        exit_plan_mode
+        external_tool
+        permission
+        session
+        skill
+        subagent
+        system
+        tool
+        user
+        user_input
+      ].freeze
+
+      def extract_event_text(obj)
+        return [nil, nil] unless obj.is_a?(Hash)
+
+        if obj.key?("type")
+          return [nil, nil] unless obj["data"].is_a?(Hash)
+          return [nil, nil] unless ASSISTANT_OUTPUT_EVENT_TYPES.include?(obj["type"])
+
+          data = obj["data"]
+          if obj["type"] == "assistant.message_delta"
+            delta_content = string_content(data["deltaContent"])
+            delta_content = string_content(data["delta_content"]) if delta_content.nil? || delta_content.empty?
+            return [delta_content, :assistant_delta] if delta_content && !delta_content.empty?
+
+            return [nil, nil]
+          end
+
+          return [string_content(data["content"]), :assistant] if data.key?("content")
+
+          return [nil, nil]
+        end
+
+        return [nil, nil] if obj.key?("role") && !assistant_role?(obj["role"])
+        return [nil, nil] if obj["message"].is_a?(Hash) && obj["message"].key?("role") &&
+          !assistant_role?(obj["message"]["role"])
+
+        if obj["message"].is_a?(Hash) && obj["message"].key?("content")
+          nested_content = string_content(obj["message"]["content"])
+          return [nested_content, :assistant] if nested_content && !nested_content.empty?
+        end
+
+        output = string_content(obj["output"])
+        return [output, :assistant] if output && !output.empty?
+
+        content = string_content(obj["content"])
+        return [content, :assistant] if content && !content.empty?
+
+        [nil, nil]
+      end
+
+      def string_content(value)
+        return value if value.is_a?(String)
+
+        nil
+      end
+
+      def preserve_raw_json_line?(obj)
+        return false unless obj.is_a?(Hash)
+        return false if obj.key?("type") && copilot_event_type?(obj["type"])
+        return true if obj.key?("type")
+        return false if obj.key?("role") && !assistant_role?(obj["role"])
+        return false if obj["message"].is_a?(Hash) && obj["message"].key?("role") &&
+          !assistant_role?(obj["message"]["role"])
+        return false if extract_token_usage(obj)
+        return false if (output = string_content(obj["output"])) && !output.empty?
+        return false if (content = string_content(obj["content"])) && !content.empty?
+        return false if obj["message"].is_a?(Hash) &&
+          (message_content = string_content(obj["message"]["content"])) &&
+          !message_content.empty?
+
+        true
+      end
+
+      def assistant_role?(role)
+        role == "assistant"
+      end
+
+      def copilot_event_type?(event_type)
+        return true if ASSISTANT_OUTPUT_EVENT_TYPES.include?(event_type)
+        return true if ASSISTANT_TOKEN_FALLBACK_EVENT_TYPES.include?(event_type)
+        return true if SESSION_SHUTDOWN_EVENT_TYPES.include?(event_type)
+        return true if USAGE_EVENT_TYPES.include?(event_type)
+        return false unless event_type.is_a?(String)
+        return true if COPILOT_EVENT_TYPES.include?(event_type)
+
+        COPILOT_EVENT_TYPE_PREFIXES.any? { |prefix| event_type.start_with?(prefix) }
+      end
+
+      def extract_token_usage(obj)
+        return nil unless obj.is_a?(Hash)
+
+        if obj.key?("type")
+          return nil unless obj["data"].is_a?(Hash)
+
+          data = obj["data"]
+
+          if SESSION_SHUTDOWN_EVENT_TYPES.include?(obj["type"])
+            return extract_shutdown_token_usage(data)
+          end
+
+          if USAGE_EVENT_TYPES.include?(obj["type"])
+            return extract_payload_token_usage(
+              data,
+              source: :usage,
+              input_keys: ["inputTokens", "input_tokens"],
+              output_keys: ["outputTokens", "output_tokens"]
+            )
+          end
+
+          if ASSISTANT_TOKEN_FALLBACK_EVENT_TYPES.include?(obj["type"])
+            return extract_payload_token_usage(
+              data,
+              source: :assistant,
+              input_keys: ["inputTokens", "input_tokens"],
+              output_keys: ["outputTokens", "output_tokens"]
+            )
+          end
+
+          return nil
+        end
+
+        extract_top_level_token_usage(obj)
+      end
+
+      def extract_shutdown_token_usage(data)
+        model_metrics = extract_shutdown_model_metrics_usage(data["modelMetrics"])
+        snake_case_model_metrics = extract_shutdown_model_metrics_usage(data["model_metrics"])
+
+        input, input_present = merged_token_metric(model_metrics, snake_case_model_metrics, :input)
+        output, output_present = merged_token_metric(model_metrics, snake_case_model_metrics, :output)
+        return nil unless input_present || output_present
+
+        {
+          source: :shutdown,
+          input: input,
+          output: output,
+          input_present: input_present,
+          output_present: output_present
+        }
+      end
+
+      def extract_shutdown_model_metrics_usage(model_metrics)
+        return nil unless model_metrics.is_a?(Hash)
+
+        totals = empty_token_totals
+
+        model_metrics.each_value do |metric|
+          next unless metric.is_a?(Hash)
+
+          usage = metric["usage"]
+          next unless usage.is_a?(Hash)
+
+          metric_usage = extract_payload_token_usage(
+            usage,
+            source: :shutdown,
+            input_keys: ["inputTokens", "input_tokens", "input"],
+            output_keys: ["outputTokens", "output_tokens", "output"]
+          )
+          next unless metric_usage
+
+          accumulate_token_totals!(totals, metric_usage)
+        end
+
+        return nil unless totals[:input_present] || totals[:output_present]
+
+        totals
+      end
+
+      def extract_payload_token_usage(payload, source:, input_keys:, output_keys:)
+        return nil unless payload.is_a?(Hash)
+
+        input, input_present = token_value(payload, *input_keys)
+        output, output_present = token_value(payload, *output_keys)
+        return nil unless input_present || output_present
+
+        {
+          source: source,
+          input: input,
+          output: output,
+          input_present: input_present,
+          output_present: output_present
+        }
+      end
+
+      def extract_top_level_token_usage(obj)
+        return nil if obj.key?("role") && !assistant_role?(obj["role"])
+        return nil if obj["message"].is_a?(Hash) && obj["message"].key?("role") &&
+          !assistant_role?(obj["message"]["role"])
+
+        usage = extract_payload_token_usage(
+          obj["usage"],
+          source: :usage,
+          input_keys: ["input_tokens", "inputTokens", "input"],
+          output_keys: ["output_tokens", "outputTokens", "output"]
+        )
+        tokens = extract_payload_token_usage(
+          obj["tokens"],
+          source: :usage,
+          input_keys: ["input_tokens", "inputTokens", "input"],
+          output_keys: ["output_tokens", "outputTokens", "output"]
+        )
+        return nil unless usage || tokens
+
+        input, input_present = merged_token_metric(usage, tokens, :input)
+        output, output_present = merged_token_metric(usage, tokens, :output)
+        return nil unless input_present || output_present
+
+        {
+          source: :usage,
+          input: input,
+          output: output,
+          input_present: input_present,
+          output_present: output_present
+        }
+      end
+
+      def merged_token_metric(primary, fallback, metric)
+        present_key = :"#{metric}_present"
+        return [primary[metric], true] if primary&.[](present_key)
+        return [fallback[metric], true] if fallback&.[](present_key)
+
+        [0, false]
+      end
+
+      def empty_token_totals
+        {
+          input: 0,
+          output: 0,
+          input_present: false,
+          output_present: false
+        }
+      end
+
+      def accumulate_token_totals!(totals, token_usage)
+        if token_usage[:input_present]
+          totals[:input_present] = true
+          totals[:input] += token_usage[:input]
+        end
+
+        return unless token_usage[:output_present]
+
+        totals[:output_present] = true
+        totals[:output] += token_usage[:output]
+      end
+
+      def token_value(obj, *keys)
+        keys.each do |candidate|
+          next unless obj.key?(candidate)
+
+          value, valid = coerce_token_value(obj[candidate])
+          return [value, true] if valid
+        end
+
+        [0, false]
+      end
+
+      def build_tokens(shutdown_tokens:, usage_tokens:, fallback_tokens:)
+        input, input_present = first_present_token_metric(usage_tokens, fallback_tokens, :input)
+        output, output_present = first_present_token_metric(usage_tokens, fallback_tokens, :output)
+        return token_hash(input, output, input_present, output_present) if input_present || output_present
+
+        input, input_present = first_present_token_metric(shutdown_tokens, :input)
+        output, output_present = first_present_token_metric(shutdown_tokens, :output)
+        token_hash(input, output, input_present, output_present)
+      end
+
+      def token_hash(input, output, input_present, output_present)
+        return nil unless input_present || output_present
+
+        {input: input, output: output, total: input + output}
+      end
+
+      def first_present_token_metric(*sources, metric)
+        present_key = :"#{metric}_present"
+
+        sources.each do |source|
+          next unless source[present_key]
+
+          return [source[metric], true]
+        end
+
+        [0, false]
+      end
+
+      def render_output_segments(segments)
+        rendered = +""
+        previous_kind = nil
+        previous_terminated = false
+
+        segments.each do |segment|
+          if previous_terminated && previous_kind == :assistant &&
+              segment[:kind] != :assistant &&
+              !rendered.empty? &&
+              !rendered.end_with?("\n")
+            rendered << "\n"
+          end
+
+          rendered << segment[:content]
+          previous_kind = segment[:kind]
+          previous_terminated = segment[:terminated]
+        end
+
+        rendered
+      end
+
+      def append_delta_segment!(segments, text, terminated:)
+        previous_segment = segments.last
+        if previous_segment&.[](:provisional) && previous_segment[:kind] == :assistant
+          previous_segment[:content] << text
+          previous_segment[:terminated] = terminated
+          return
+        end
+
+        segments << {
+          kind: :assistant,
+          content: +text,
+          terminated: terminated,
+          provisional: true
+        }
+      end
+
+      def replace_assistant_segments!(segments, text, terminated:)
+        drop_assistant_segments!(segments)
+        segments << {kind: :assistant, content: text, terminated: terminated}
+      end
+
+      def drop_assistant_segments!(segments)
+        segments.reject! { |segment| segment[:kind] == :assistant }
+      end
+
+      def with_request_probe_env(env)
+        stack = writable_request_probe_env_stack
+        stack << env
+        yield
+      ensure
+        stack&.pop
+        clear_request_probe_env_stack! if stack&.empty?
+      end
+
+      def current_probe_env
+        stacks = Thread.current.thread_variable_get(REQUEST_PROBE_ENV_STACK_KEY)
+        stack = stacks && stacks[object_id]
+        stack&.last || {}
+      end
+
+      def version_probe_env_cache_key(env)
+        resolved_binary_path_for_env(env) ||
+          if env.key?("PATH")
+            [:path_override, cacheable_path_override(env["PATH"])]
+          else
+            self.class.binary_name
+          end
+      end
+
+      def cacheable_path_override(path)
+        return nil unless path.is_a?(String)
+
+        Digest::SHA256.hexdigest(path)
+      end
+
+      def resolved_binary_path_for_env(env)
+        path = if env.key?("PATH")
+          env["PATH"]
+        else
+          ENV["PATH"]
+        end
+        return nil unless path.is_a?(String) && !path.empty?
+
+        path.split(File::PATH_SEPARATOR).each do |entry|
+          full_path = File.join(entry, self.class.binary_name)
+          return full_path if File.executable?(full_path)
+        end
+
+        nil
+      end
+
+      def request_probe_env_from_raw_runtime(runtime)
+        case runtime
+        when nil
+          {}
+        when ProviderRuntime
+          runtime.env.merge(runtime.unset_env.to_h { |key| [key, nil] })
+        when Hash
+          request_probe_env_from_raw_hash(runtime)
+        else
+          {}
+        end
+      end
+
+      def request_probe_env_from_raw_hash(runtime_hash)
+        env = stringify_probe_env(runtime_hash[:env] || runtime_hash["env"])
+        unset_env = stringify_probe_unset_env(runtime_hash[:unset_env] || runtime_hash["unset_env"])
+        return {} unless env && unset_env
+
+        env.merge(unset_env.to_h { |key| [key, nil] })
+      end
+
+      def stringify_probe_env(raw_env)
+        return {} if raw_env.nil?
+        return nil unless raw_env.is_a?(Hash)
+
+        raw_env.each_with_object({}) do |(key, value), env|
+          return nil unless value.is_a?(String)
+
+          env[key.to_s] = value
+        end
+      end
+
+      def stringify_probe_unset_env(raw_unset_env)
+        return [] if raw_unset_env.nil?
+        return nil unless raw_unset_env.is_a?(Array)
+
+        raw_unset_env.map(&:to_s)
+      rescue NoMethodError
+        nil
+      end
+
+      def writable_request_probe_env_stack
+        stacks = Thread.current.thread_variable_get(REQUEST_PROBE_ENV_STACK_KEY)
+        unless stacks
+          stacks = {}
+          Thread.current.thread_variable_set(REQUEST_PROBE_ENV_STACK_KEY, stacks)
+        end
+
+        stacks[object_id] ||= []
+      end
+
+      def clear_request_probe_env_stack!
+        stacks = Thread.current.thread_variable_get(REQUEST_PROBE_ENV_STACK_KEY)
+        return unless stacks
+
+        stacks.delete(object_id)
+        Thread.current.thread_variable_set(REQUEST_PROBE_ENV_STACK_KEY, nil) if stacks.empty?
+      end
+
+      def copilot_cli_supports_json_output?(env: current_probe_env)
+        @copilot_cli_supports_json_output ||= {}
+        cache_key = version_probe_env_cache_key(env)
+        return @copilot_cli_supports_json_output[cache_key] if @copilot_cli_supports_json_output.key?(cache_key)
+
+        version = copilot_cli_version(env: env)
+        @copilot_cli_supports_json_output[cache_key] = !version.nil? && version >= MIN_JSON_OUTPUT_VERSION
+      rescue
+        @copilot_cli_supports_json_output[cache_key] = false
+      end
+
+      def copilot_cli_version(env: current_probe_env)
+        @copilot_cli_version ||= {}
+        cache_key = version_probe_env_cache_key(env)
+        return @copilot_cli_version[cache_key] if @copilot_cli_version.key?(cache_key)
+
+        result = @executor.execute([self.class.binary_name, "--version"], timeout: 5, env: env)
+        return @copilot_cli_version[cache_key] = nil unless result.exit_code.zero?
+
+        @copilot_cli_version[cache_key] = parse_copilot_cli_version(result.stdout) || parse_copilot_cli_version(result.stderr)
+      rescue
+        @copilot_cli_version[cache_key] = nil
+      end
+
+      def parse_copilot_cli_version(output)
+        match = output.to_s.match(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/)
+        return nil unless match
+
+        Gem::Version.new(match[1])
+      rescue ArgumentError
+        nil
+      end
+
+      def coerce_token_value(value)
+        case value
+        when Integer
+          return [value, true] if value >= 0
+        when Float
+          return [value.to_i, true] if value.finite? && value >= 0 && value == value.to_i
+        when String
+          return [value.to_i, true] if /\A\+?\d+\z/.match?(value)
+        end
+
+        [0, false]
+      end
     end
   end
 end

data/lib/agent_harness/providers/kilocode.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module AgentHarness
   module Providers
     # Kilocode CLI provider
@@ -9,6 +11,18 @@ module AgentHarness
       PACKAGE_NAME = "@kilocode/cli"
       DEFAULT_VERSION = "7.1.3"
       SUPPORTED_VERSION_REQUIREMENT = "= #{DEFAULT_VERSION}"
+      STRUCTURED_EVENT_TYPES = %w[text error step_finish result usage].freeze
+      USAGE_EVENT_TYPES = %w[result usage].freeze
+      TOKEN_USAGE_KEYS = %w[
+        input_tokens
+        output_tokens
+        total_tokens
+        total
+        reasoning_tokens
+        cache_creation_input_tokens
+        cache_read_input_tokens
+        cache_write_input_tokens
+      ].freeze
 
       class << self
         def provider_name
@@ -118,7 +132,7 @@ module AgentHarness
       def execution_semantics
         {
           prompt_delivery: :arg,
-          output_format: :text,
+          output_format: :json,
           sandbox_aware: false,
           uses_subcommand: true,
           non_interactive_flag: nil,
@@ -131,14 +145,495 @@ module AgentHarness
       protected
 
       def build_command(prompt, options)
-        cmd = [self.class.binary_name, "run"]
+        cmd = [self.class.binary_name, "run", "--format", "json"]
         cmd << prompt
         cmd
       end
 
+      def parse_response(result, duration:)
+        output = result.stdout
+        tokens = nil
+        structured_errors = []
+        error = nil
+        unstructured_output = nil
+
+        if result.failed?
+          combined = [result.stderr, result.stdout]
+            .map { |s| s.to_s.strip }
+            .reject(&:empty?)
+            .join("\n")
+          error = combined unless combined.empty?
+        end
+
+        text_parts = []
+        accumulated_input = 0
+        accumulated_output = 0
+        accumulated_total = 0
+        accumulated_extra_total = 0
+        has_step_tokens = false
+        result_usage = nil
+        result_text = nil
+        saw_structured_event = false
+
+        each_json_event(output) do |event|
+          next unless structured_event?(event)
+
+          saw_structured_event = true
+          part = event["part"]
+
+          if event["type"] == "text"
+            text = extract_text_chunk(event, part)
+            text_parts << text if text.is_a?(String)
+          end
+
+          if event["type"] == "result"
+            extracted_result_text = extract_terminal_result_text(event["result"]) ||
+              extract_terminal_result_text(part) ||
+              extract_terminal_result_text(event["text"]) ||
+              extract_terminal_result_text(event["message"])
+            result_text = extracted_result_text if extracted_result_text
+          end
+
+          if event["type"] == "error"
+            structured_error = extract_error_message(event)
+            structured_errors << structured_error if structured_error
+          end
+
+          if event["type"] == "step_finish"
+            part_tokens = part["tokens"] if part.is_a?(Hash)
+            if part_tokens.is_a?(Hash)
+              step_total = coerce_step_total_token_count(part_tokens)
+              step_token_counts = build_token_counts({
+                "input_tokens" => part_tokens["input"],
+                "output_tokens" => part_tokens["output"],
+                "total_tokens" => step_total
+              })
+
+              if step_token_counts
+                accumulated_input += step_token_counts[:input]
+                accumulated_output += step_token_counts[:output]
+                accumulated_total += step_token_counts[:total]
+                accumulated_extra_total += portable_step_extra_total(part_tokens, step_token_counts[:total])
+                has_step_tokens = true
+              end
+            end
+          end
+
+          usage = event["usage"]
+          if USAGE_EVENT_TYPES.include?(event["type"]) && usage.is_a?(Hash) && usage_has_token_data?(usage)
+            result_usage = merge_usage_data(result_usage, usage)
+          end
+        end
+
+        if saw_structured_event
+          unstructured_output = extract_unstructured_output(result.stdout)
+          joined_text = text_parts.join if text_parts.any?
+          output = if joined_text && !joined_text.strip.empty?
+            joined_text
+          else
+            result_text || unstructured_output
+          end
+          if result.failed? || structured_errors.any?
+            error = build_structured_error(
+              result,
+              structured_errors,
+              unstructured_output:
+            )
+          end
+        end
+        step_tokens = nil
+        if has_step_tokens
+          step_tokens = build_token_counts({
+            "input_tokens" => accumulated_input,
+            "output_tokens" => accumulated_output,
+            "total_tokens" => accumulated_total
+          })
+        end
+        fallback_total_remainder = [accumulated_total - accumulated_input - accumulated_output - accumulated_extra_total, 0].max
+        if result_usage
+          tokens = resolve_token_counts(
+            result_usage,
+            fallback: step_tokens,
+            fallback_extra_total: accumulated_extra_total,
+            fallback_total_remainder:
+          )
+        end
+        tokens ||= step_tokens
+
+        Response.new(
+          output: output,
+          exit_code: result.exit_code,
+          duration: duration,
+          provider: self.class.provider_name,
+          model: @config.model,
+          tokens: tokens,
+          error: error,
+          metadata: {
+            legitimate_exit_codes: execution_semantics[:legitimate_exit_codes]
+          }
+        )
+      end
+
       def default_timeout
         300
       end
+
+      private
+
+      def each_json_event(output)
+        return if output.nil? || output.empty?
+
+        output.each_line do |line|
+          line = line.strip
+          next if line.empty?
+
+          event = JSON.parse(line)
+          next unless event.is_a?(Hash)
+
+          yield event
+        rescue JSON::ParserError
+          next
+        end
+      end
+
+      def build_token_counts(usage)
+        input = coerce_token_count(usage["input_tokens"])
+        output = coerce_token_count(usage["output_tokens"])
+        total = coerce_total_token_count(usage, input:, output:)
+        return nil unless input || output || total
+
+        input ||= 0
+        output ||= 0
+
+        {input: input, output: output, total: total}
+      end
+
+      def resolve_token_counts(usage, fallback: nil, fallback_extra_total: 0, fallback_total_remainder: 0)
+        input = coerce_token_count(usage["input_tokens"])
+        output = coerce_token_count(usage["output_tokens"])
+        explicit_total = extract_explicit_total_token_count(usage)
+        usage_extra_total = usage_extra_token_total(usage)
+
+        input_from_fallback = input.nil? && fallback && !fallback[:input].nil?
+        output_from_fallback = output.nil? && fallback && !fallback[:output].nil?
+        fallback_total = fallback[:total] if fallback
+        input = fallback[:input] if input_from_fallback
+        output = fallback[:output] if output_from_fallback
+        return nil unless input || output || explicit_total || usage_extra_total || fallback_total
+
+        input ||= 0
+        output ||= 0
+
+        total = if explicit_total
+          explicit_total
+        elsif usage_extra_total
+          resolved_total = input + output + usage_extra_total
+          if (input_from_fallback || output_from_fallback) && fallback_total_remainder.positive?
+            [resolved_total, fallback_total].compact.max
+          else
+            resolved_total
+          end
+        elsif input_from_fallback || output_from_fallback
+          resolved_total = input + output + fallback_extra_total
+          fallback_total_remainder.positive? ? [resolved_total, fallback_total].compact.max : resolved_total
+        else
+          input + output
+        end
+
+        {input: input, output: output, total: total}
+      end
+
+      def usage_has_token_data?(usage)
+        input = coerce_token_count(usage["input_tokens"])
+        output = coerce_token_count(usage["output_tokens"])
+        explicit_total = extract_explicit_total_token_count(usage)
+        usage_extra_total = usage_extra_token_total(usage)
+
+        input || output || explicit_total || usage_extra_total
+      end
+
+      def merge_usage_data(previous_usage, current_usage)
+        return current_usage if previous_usage.nil?
+
+        merged_usage = previous_usage.slice(*TOKEN_USAGE_KEYS)
+        if usage_updates_explicit_total?(current_usage)
+          merged_usage.delete("total_tokens")
+          merged_usage.delete("total")
+        end
+
+        if usage_replaces_extra_fields?(current_usage)
+          merged_usage.delete("reasoning_tokens")
+          merged_usage.delete("cache_creation_input_tokens")
+          merged_usage.delete("cache_read_input_tokens")
+          merged_usage.delete("cache_write_input_tokens")
+        end
+
+        merged_usage.merge!(
+          current_usage.slice(*TOKEN_USAGE_KEYS).select { |key, value| usable_usage_token_field?(key, value) }
+        )
+
+        if usage_updates_non_total_fields?(current_usage) && !usage_updates_explicit_total?(current_usage)
+          merged_usage.delete("total_tokens")
+          merged_usage.delete("total")
+        end
+
+        merged_usage
+      end
+
+      def usable_usage_token_field?(key, value)
+        case key
+        when "input_tokens", "output_tokens", "total_tokens", "total", "reasoning_tokens",
+          "cache_creation_input_tokens", "cache_read_input_tokens", "cache_write_input_tokens"
+          !coerce_token_count(value).nil?
+        else
+          false
+        end
+      end
+
+      def usage_updates_non_total_fields?(usage)
+        %w[
+          input_tokens
+          output_tokens
+          reasoning_tokens
+          cache_creation_input_tokens
+          cache_read_input_tokens
+          cache_write_input_tokens
+        ].any? { |key| usable_usage_token_field?(key, usage[key]) }
+      end
+
+      def usage_updates_explicit_total?(usage)
+        %w[total_tokens total].any? { |key| usable_usage_token_field?(key, usage[key]) }
+      end
+
+      def usage_replaces_extra_fields?(usage)
+        usable_usage_token_field?("input_tokens", usage["input_tokens"]) &&
+          usable_usage_token_field?("output_tokens", usage["output_tokens"])
+      end
+
+      def extract_error_message(event)
+        error_payload = event["error"]
+        part = event["part"]
+        part_error_payload = part["error"] if part.is_a?(Hash)
+        candidates = [
+          extract_result_text(event["message"]),
+          extract_result_text(event["text"]),
+          extract_result_text(error_payload),
+          extract_result_text(error_payload.is_a?(Hash) ? error_payload["message"] : nil),
+          extract_result_text(error_payload.is_a?(Hash) ? error_payload["data"] : nil),
+          extract_result_text(part_error_payload),
+          extract_result_text(part_error_payload.is_a?(Hash) ? part_error_payload["message"] : nil),
+          extract_result_text(part_error_payload.is_a?(Hash) ? part_error_payload["data"] : nil),
+          extract_result_text(part.is_a?(Hash) ? nil : part),
+          extract_result_text(part.is_a?(Hash) ? part["text"] : nil),
+          extract_result_text(part.is_a?(Hash) ? part["message"] : nil)
+        ]
+
+        message = candidates.find { |value| value }
+        return message if message
+
+        JSON.generate(event)
+      end
+
+      def extract_result_text(payload)
+        case payload
+        when String
+          return if payload.strip.empty?
+
+          payload.strip
+        when Hash
+          extract_result_text(payload["text"]) || extract_result_text(payload["message"])
+        end
+      end
+
+      def extract_terminal_result_text(payload)
+        if payload.is_a?(String)
+          return if payload.strip.empty?
+
+          return payload
+        end
+
+        return unless payload.is_a?(Hash)
+
+        text = extract_terminal_result_text(payload["text"])
+        return text if text.is_a?(String) && !text.strip.empty?
+
+        extract_terminal_result_text(payload["message"]) || text
+      end
+
+      def extract_text_chunk(event, part)
+        scalar_part_chunk = extract_text_alias_chunk(part.is_a?(String) ? part : nil)
+        return scalar_part_chunk if scalar_part_chunk.is_a?(String) && !scalar_part_chunk.strip.empty?
+
+        part_text_chunk = extract_text_alias_chunk(part.is_a?(Hash) ? part["text"] : nil)
+        return part_text_chunk if part_text_chunk.is_a?(String) && !part_text_chunk.strip.empty?
+
+        part_message_chunk = extract_text_alias_chunk(part.is_a?(Hash) ? part["message"] : nil)
+        return part_message_chunk if part_message_chunk.is_a?(String) && !part_message_chunk.strip.empty?
+
+        text_chunk = extract_text_alias_chunk(event["text"])
+        return text_chunk if text_chunk.is_a?(String) && !text_chunk.strip.empty?
+
+        message_chunk = extract_text_alias_chunk(event["message"])
+        return message_chunk if message_chunk.is_a?(String) && !message_chunk.strip.empty?
+
+        scalar_part_chunk || part_text_chunk || part_message_chunk || text_chunk || message_chunk
+      end
+
+      def extract_text_alias_chunk(payload)
+        if payload.is_a?(String)
+          return if payload.empty?
+
+          return payload
+        end
+
+        return unless payload.is_a?(Hash)
+
+        text_chunk = extract_text_alias_chunk(payload["text"])
+        return text_chunk if text_chunk.is_a?(String) && !text_chunk.strip.empty?
+
+        extract_text_alias_chunk(payload["message"]) || text_chunk
+      end
+
+      def build_structured_error(result, structured_errors, unstructured_output:)
+        stderr = result.stderr.to_s.strip
+        error_lines = [stderr, *structured_errors, unstructured_output].compact.reject(&:empty?).uniq
+        return error_lines.join("\n") if error_lines.any?
+
+        return "Kilocode exited with code #{result.exit_code}" if result.failed?
+
+        nil
+      end
+
+      def extract_unstructured_output(output)
+        return if output.nil? || output.empty?
+
+        lines = output.each_line.filter_map do |line|
+          stripped_line = line.strip
+          next if stripped_line.empty?
+
+          parsed_line = JSON.parse(stripped_line)
+          next if parsed_structured_event?(parsed_line)
+          next if parsed_json_scalar?(parsed_line)
+
+          line.chomp
+        rescue JSON::ParserError
+          line.chomp
+        end
+
+        lines.empty? ? nil : lines.join("\n")
+      end
+
+      def structured_event?(event)
+        STRUCTURED_EVENT_TYPES.include?(event["type"])
+      end
+
+      def parsed_structured_event?(parsed_line)
+        parsed_line.is_a?(Hash) && structured_event?(parsed_line)
+      end
+
+      def parsed_json_scalar?(parsed_line)
+        !parsed_line.is_a?(Hash) && !parsed_line.is_a?(Array)
+      end
+
+      def coerce_token_count(value)
+        if value.is_a?(Integer)
+          return value if value >= 0
+
+          return nil
+        end
+
+        if value.is_a?(Float) && value.finite?
+          return nil unless value == value.to_i
+
+          coerced = value.to_i
+          return coerced if coerced >= 0
+
+          return nil
+        end
+
+        return if value.nil?
+
+        if value.is_a?(String)
+          return nil unless value.match?(/\A\d+\z/)
+
+          return value.to_i
+        end
+
+        nil
+      end
+
+      def coerce_total_token_count(usage, input:, output:)
+        explicit_total = extract_explicit_total_token_count(usage)
+        return explicit_total if explicit_total
+        return nil if input.nil? && output.nil?
+
+        (input || 0) + (output || 0)
+      end
+
+      def coerce_step_total_token_count(tokens)
+        explicit_total = extract_explicit_total_token_count(tokens)
+        return explicit_total if explicit_total
+
+        counts = [
+          coerce_token_count(tokens["input"]),
+          coerce_token_count(tokens["output"]),
+          coerce_token_count(tokens["reasoning"])
+        ]
+
+        cache = tokens["cache"]
+        if cache.is_a?(Hash)
+          counts << coerce_token_count(cache["read"])
+          counts << coerce_token_count(cache["write"])
+        end
+
+        counts.compact!
+        return nil if counts.empty?
+
+        counts.sum
+      end
+
+      def portable_step_extra_total(tokens, total)
+        return 0 unless step_component_tokens_present?(tokens)
+
+        input = coerce_token_count(tokens["input"]) || 0
+        output = coerce_token_count(tokens["output"]) || 0
+
+        [total - input - output, 0].max
+      end
+
+      def step_component_tokens_present?(tokens)
+        counts = [
+          coerce_token_count(tokens["input"]),
+          coerce_token_count(tokens["output"]),
+          coerce_token_count(tokens["reasoning"])
+        ]
+
+        cache = tokens["cache"]
+        if cache.is_a?(Hash)
+          counts << coerce_token_count(cache["read"])
+          counts << coerce_token_count(cache["write"])
+        end
+
+        counts.any?
+      end
+
+      def extract_explicit_total_token_count(usage)
+        coerce_token_count(usage["total_tokens"]) || coerce_token_count(usage["total"])
+      end
+
+      def usage_extra_token_total(usage)
+        counts = [
+          coerce_token_count(usage["reasoning_tokens"]),
+          coerce_token_count(usage["cache_creation_input_tokens"]),
+          coerce_token_count(usage["cache_read_input_tokens"]),
+          coerce_token_count(usage["cache_write_input_tokens"])
+        ]
+
+        counts.compact!
+        return nil if counts.empty?
+
+        counts.sum
+      end
     end
   end
 end

data/lib/agent_harness/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AgentHarness
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agent-harness
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Bart Agapinan