M45-2b: HARNESS als derde worker-runtime in scrum4me-mcp (claim, isHarnessJob, routering, kosten) #196

Merged
janpeter merged 21 commits from feat/m45-2b-harness into main 2026-10-06 23:18:55 +02:00
Owner

Aanleiding: M45 maakt de agent-harness (een LiteLLM-model) een derde worker-runtime HARNESS naast Claude en Codex. Deel 2a (shared 132656b + de tabellen product_harness_choices en job_cost_reports op de server-DB) is uitgerold; dit is deel 2b: één release van scrum4me-mcp. Er ontstaat nog geen enkele HARNESS-rij: productkeuzes zet pas 2c, de harness-dienst komt in 2d, de cutover in 2e.

Plan: docs/plans/M45-2b-harness-mcp.md (Scrum4Me, rev 3, dubbel GO in planronde 2), spec docs/superpowers/specs/2026-10-05-harness-runtime-design.md rev 9. Scrum4Me: sprint S-2026-10-06-m45-2b, PBI-184, story ST-1636, taken T-2026 t/m T-2031.

Wat

  • Plan-taak 1 — identiteit (T-2026, 8c0db26): shared-submodule naar 132656b, met het geregenereerde prisma/schema.prisma in dezelfde commit (+36/-0). WorkerRuntime = shared AgentRuntime. parseWorkerRuntime weigert een onbekende SCRUM4ME_WORKER_RUNTIME (UNKNOWN_AGENT_RUNTIME, het proces stopt met exitcode 1 vóór de registratie) in plaats van er stil CLAUDE van te maken. health meldt runtimes: ['CLAUDE','CODEX','HARNESS']. Een HARNESS-idee-chat krijgt geen Claude-prompt.
  • Plan-taak 2 — claim (T-2027 ac5ba43 d5158a8 dd93fa5, T-2028 e7812c9 46ae956):
    • claimtak HARNESS op alle gespiegelde plekken van het claimfilter, gekozen op de runtime van de worker vóór de capability-takken: alleen IDEA_CHAT/SYSTEM en een losse TASK_IMPLEMENTATION/COPILOT zonder sprint-run, zonder required_capability;
    • de idee-job-precheck telt harness-workers niet mee;
    • direct na de claim een runtimecontrole: wijkt de runtime van de job af, dan geeft releaseMismatchedClaim de claim terug in één transactie (FOR UPDATE, eigenaarscontrole, taakreset alleen als déze claim hem promoveerde) en volgt RUNTIME_MISMATCH;
    • het plafond van een HARNESS-job komt uit de productkeuze (readHarnessChoice, zonder terugval bij een leesfout); een onbruikbare configuratie zet de job op FAILED met de code, op beide claimpaden;
    • CI: de dispatch-testdatabase krijgt de twee 2a-migraties (Scrum4Me ae6483b2, gepind op pad en sha256) als additieve overlay met rechten gelijk aan de 2a-contracts.
  • Plan-taak 3 — git-bewaking (T-2029, 4121a09 1f52a77 ca9e608): één predicaat isHarnessJob / isHarnessJobRow (runtime HARNESS of required_capability = 'local_llm', gelezen uit de DB, de local_llm-tak blijft permanent) voor alle git-bescherming en de drie uitzonderingen in update_job_status.
  • Plan-taak 4 — routering en kosten (T-2030, 0c1cf4c 13e9492): losse taak, idee-chat en vervolgjob lezen de productkeuze binnen hun transactie (met keuze runtime: 'HARNESS' + configuratie, zonder keuze exact zoals nu); dispatch_job weigert elke required_capability; update_job_status krijgt een optioneel cost-veld, alleen voor een HARNESS-job van een HARNESS-soort bij een eindstatus, gevalideerd vóór elk neveneffect, bedrag naar boven afgerond op 6 decimalen, opgeslagen in job_cost_reports in dezelfde transactie als de statusupdate.
  • Plan-taak 5 — docs (T-2031, 10a42d6 5adc8c8): CLAUDE.md (AGENTS.md is een symlink), README en CHANGELOG.
  • Eindreview-fixronde (8f1b00e…cb611a2): merge van origin/main (PR #195; merge, geen rebase), correctie van de docker-teksten, kostenmelding alleen van een HARNESS-soort, neutrale repo-root-fout, één weigeringstekst in dispatch_job, lengtegrens in parseReportedCostUsd, runtime_mismatch-log vóór de teruggave, CHANGELOG-precisering.

Bewijs

  • Lokaal op cb611a2: npm run typecheck en npm run typecheck:tests schoon; vitest 265 bestanden groen + 10 overgeslagen, 2611 tests groen + 81 overgeslagen (baseline 654fb70: 2135 + 81).
  • Dispatch-integratiepoort lokaal (wegwerp-Postgres met hetzelfde image en dezelfde provisioner als CI): 29 bestanden, 355 tests, DISPATCH_CI_PASSED (baseline 27 / 295). Nieuw: harness-claim.integration.test.ts (claimfilter in beide richtingen met HARNESS-, Claude-, Codex- en local_llm-jobs in één tabel; de teruggave, ook onder concurrentie met twee verbindingen en pg_blocking_pids; enqueue → claim; een geweigerde kostenrij draait de statusupdate terug) en harness-overlay.integration.test.ts (eigenaar, geen restrecht CREATE, rechten per rol).
  • Elke nieuwe test is eerst rood gezien; regressiepinnen via tijdelijke mutaties (o.a. 55 voor plan-taak 2, 94 voor plan-taak 4, allemaal gevangen en teruggedraaid). Per taak een review op spec en kwaliteit, plus een eindreview van de hele branch.

Let op bij merge en uitrol

  • Mergen als echte merge-commit (twee ouders): de release-stap van CI eist dat; squash of rebase breekt de attestatie.
  • Na de uitrol stopt een MCP met een onbekende SCRUM4ME_WORKER_RUNTIME (voorheen stil CLAUDE); geldige waarden: leeg, CLAUDE, CODEX, HARNESS.
  • dispatch_job weigert vanaf deze release required_capability: 'local_llm'; de lokale idee-chat via web loopt door. Een lokale taak kan pas weer via HARNESS (2e).
  • De DB-rol van elke installatie heeft SELECT op product_harness_choices en SELECT/INSERT/UPDATE op job_cost_reports nodig (de enqueue leest de keuze ook zonder keuze). De uitrol (plan-taak 6, T-2032) controleert dat per installatie vóór de update en gebeurt alleen op JP's go.
  • Bekend: __tests__/create-transaction.test.ts heeft een bestaande timingflake (los van deze branch); bij een rode kandidaat alleen daarop: opnieuw draaien. CLAUDE.md verwijst naar de Scrum4Me-spec en -plan, die nog op de docs-branch docs/harness-runtime-spec staan.

🤖 Generated with Claude Code

Aanleiding: M45 maakt de agent-harness (een LiteLLM-model) een derde worker-runtime `HARNESS` naast Claude en Codex. Deel 2a (shared `132656b` + de tabellen `product_harness_choices` en `job_cost_reports` op de server-DB) is uitgerold; dit is deel 2b: één release van scrum4me-mcp. Er ontstaat nog geen enkele `HARNESS`-rij: productkeuzes zet pas 2c, de harness-dienst komt in 2d, de cutover in 2e. Plan: [`docs/plans/M45-2b-harness-mcp.md`](https://git.jp-visser.nl/janpeter/Scrum4Me/src/commit/bfa947db7ec3a01ca9c63e9b10c25e4d5b950d03/docs/plans/M45-2b-harness-mcp.md) (Scrum4Me, rev 3, dubbel GO in planronde 2), spec `docs/superpowers/specs/2026-10-05-harness-runtime-design.md` rev 9. Scrum4Me: sprint S-2026-10-06-m45-2b, PBI-184, story ST-1636, taken T-2026 t/m T-2031. ## Wat - **Plan-taak 1 — identiteit (T-2026, `8c0db26`):** shared-submodule naar `132656b`, met het geregenereerde `prisma/schema.prisma` in dezelfde commit (+36/-0). `WorkerRuntime` = shared `AgentRuntime`. `parseWorkerRuntime` weigert een onbekende `SCRUM4ME_WORKER_RUNTIME` (`UNKNOWN_AGENT_RUNTIME`, het proces stopt met exitcode 1 vóór de registratie) in plaats van er stil `CLAUDE` van te maken. `health` meldt `runtimes: ['CLAUDE','CODEX','HARNESS']`. Een `HARNESS`-idee-chat krijgt geen Claude-prompt. - **Plan-taak 2 — claim (T-2027 `ac5ba43` `d5158a8` `dd93fa5`, T-2028 `e7812c9` `46ae956`):** - claimtak `HARNESS` op alle gespiegelde plekken van het claimfilter, gekozen op de runtime van de worker vóór de capability-takken: alleen `IDEA_CHAT`/SYSTEM en een losse `TASK_IMPLEMENTATION`/COPILOT zonder sprint-run, zonder `required_capability`; - de idee-job-precheck telt harness-workers niet mee; - direct na de claim een runtimecontrole: wijkt de runtime van de job af, dan geeft `releaseMismatchedClaim` de claim terug in één transactie (`FOR UPDATE`, eigenaarscontrole, taakreset alleen als déze claim hem promoveerde) en volgt `RUNTIME_MISMATCH`; - het plafond van een `HARNESS`-job komt uit de productkeuze (`readHarnessChoice`, zonder terugval bij een leesfout); een onbruikbare configuratie zet de job op `FAILED` met de code, op beide claimpaden; - CI: de dispatch-testdatabase krijgt de twee 2a-migraties (Scrum4Me `ae6483b2`, gepind op pad en sha256) als additieve overlay met rechten gelijk aan de 2a-contracts. - **Plan-taak 3 — git-bewaking (T-2029, `4121a09` `1f52a77` `ca9e608`):** één predicaat `isHarnessJob` / `isHarnessJobRow` (runtime `HARNESS` of `required_capability = 'local_llm'`, gelezen uit de DB, de `local_llm`-tak blijft permanent) voor alle git-bescherming en de drie uitzonderingen in `update_job_status`. - **Plan-taak 4 — routering en kosten (T-2030, `0c1cf4c` `13e9492`):** losse taak, idee-chat en vervolgjob lezen de productkeuze binnen hun transactie (met keuze `runtime: 'HARNESS'` + configuratie, zonder keuze exact zoals nu); `dispatch_job` weigert elke `required_capability`; `update_job_status` krijgt een optioneel `cost`-veld, alleen voor een `HARNESS`-job van een `HARNESS`-soort bij een eindstatus, gevalideerd vóór elk neveneffect, bedrag naar boven afgerond op 6 decimalen, opgeslagen in `job_cost_reports` in dezelfde transactie als de statusupdate. - **Plan-taak 5 — docs (T-2031, `10a42d6` `5adc8c8`):** CLAUDE.md (AGENTS.md is een symlink), README en CHANGELOG. - **Eindreview-fixronde (`8f1b00e`…`cb611a2`):** merge van `origin/main` (PR #195; merge, geen rebase), correctie van de docker-teksten, kostenmelding alleen van een `HARNESS`-soort, neutrale repo-root-fout, één weigeringstekst in `dispatch_job`, lengtegrens in `parseReportedCostUsd`, `runtime_mismatch`-log vóór de teruggave, CHANGELOG-precisering. ## Bewijs - Lokaal op `cb611a2`: `npm run typecheck` en `npm run typecheck:tests` schoon; `vitest` 265 bestanden groen + 10 overgeslagen, 2611 tests groen + 81 overgeslagen (baseline `654fb70`: 2135 + 81). - Dispatch-integratiepoort lokaal (wegwerp-Postgres met hetzelfde image en dezelfde provisioner als CI): 29 bestanden, 355 tests, `DISPATCH_CI_PASSED` (baseline 27 / 295). Nieuw: `harness-claim.integration.test.ts` (claimfilter in beide richtingen met `HARNESS`-, Claude-, Codex- en `local_llm`-jobs in één tabel; de teruggave, ook onder concurrentie met twee verbindingen en `pg_blocking_pids`; enqueue → claim; een geweigerde kostenrij draait de statusupdate terug) en `harness-overlay.integration.test.ts` (eigenaar, geen restrecht CREATE, rechten per rol). - Elke nieuwe test is eerst rood gezien; regressiepinnen via tijdelijke mutaties (o.a. 55 voor plan-taak 2, 94 voor plan-taak 4, allemaal gevangen en teruggedraaid). Per taak een review op spec en kwaliteit, plus een eindreview van de hele branch. ## Let op bij merge en uitrol - **Mergen als echte merge-commit** (twee ouders): de release-stap van CI eist dat; squash of rebase breekt de attestatie. - **Na de uitrol stopt een MCP met een onbekende `SCRUM4ME_WORKER_RUNTIME`** (voorheen stil `CLAUDE`); geldige waarden: leeg, `CLAUDE`, `CODEX`, `HARNESS`. - **`dispatch_job` weigert vanaf deze release `required_capability: 'local_llm'`**; de lokale idee-chat via web loopt door. Een lokale taak kan pas weer via `HARNESS` (2e). - **De DB-rol van elke installatie** heeft `SELECT` op `product_harness_choices` en `SELECT`/`INSERT`/`UPDATE` op `job_cost_reports` nodig (de enqueue leest de keuze ook zonder keuze). De uitrol (plan-taak 6, T-2032) controleert dat per installatie vóór de update en gebeurt alleen op JP's go. - **Bekend:** `__tests__/create-transaction.test.ts` heeft een bestaande timingflake (los van deze branch); bij een rode kandidaat alleen daarop: opnieuw draaien. CLAUDE.md verwijst naar de Scrum4Me-spec en -plan, die nog op de docs-branch `docs/harness-runtime-spec` staan. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
scrum4me-shared gaat naar 132656b (M45-2a): HARNESS als derde lid van AgentRuntime, de
tabellen product_harness_choices en job_cost_reports, en de HARNESS-tak van de resolver.
prisma/schema.prisma is daarbij opnieuw gegenereerd (+36/-0: enum-lid, twee modellen, twee
back-relations) en de gitlink-pin in ppe-bundle1-parity volgt de nieuwe commit.

Waarom één commit: de bump zet drie typefouten aan (het HARNESS-lid heeft geen
thinking_budget en past niet in de lokale runtime-aliassen), en tot nu toe werd elke waarde
in SCRUM4ME_WORKER_RUNTIME behalve CODEX stil CLAUDE, dus ook HARNESS en elke typfout. Een
worker met een verkeerde runtime registreerde zich dan als Claude-worker en pakte Claude-jobs.

- WorkerRuntime is AgentRuntime uit shared; de vier lokale aliassen (eligibility, job-context,
  presence/worker, presence/heartbeat) verdwijnen.
- parseWorkerRuntime weigert een onbekende waarde met UNKNOWN_AGENT_RUNTIME in plaats van er
  CLAUDE van te maken (leeg of ontbrekend blijft CLAUDE). Bij het starten stopt het proces dan
  met exitcode 1 vóór authenticatie en registratie; in wait_for_job wordt het een toolfout.
  getWorkerRuntimeFromEnv houdt zijn signatuur.
- health meldt runtimes: ['CLAUDE', 'CODEX', 'HARNESS'] (één veld erbij, steeds een kopie).
- getKindPromptText en getIdeaPromptText geven voor HARNESS een lege prompt (geen Claude-
  prompt); de PLAN_CHAT- en IDEA_CHAT-aanroepen in getFullJobContext geven de effectieve
  runtime mee in plaats van de standaard CLAUDE.
- De twee typefouten zijn vernauwd, niet weggecast: getJobConfigSnapshot en enqueueManagedJob
  weigeren een HARNESS-config met UNKNOWN_AGENT_RUNTIME. Dat is onbereikbaar (beide
  resolven alleen CLAUDE of CODEX); managed dispatch blijft gesloten voor HARNESS.

Tests (eerst rood gezien): worker-runtime, stdio-runtime-startup, tools/health-runtimes,
kind-prompts-harness, dispatch-harness-guards en wait-for-job-runtime-env. De oude pin die
'gpt-5' op CLAUDE zette is uit wait-for-job-runtime-claim gehaald. Geen HARNESS-rij in een
gedeelde database: alleen mocks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De dispatch-poort draait tegen een wegwerp-Postgres die op de historische schema-pin 6dc581da wordt
opgezet. De claimtest van de HARNESS-tak (volgende commit) en de latere taken van M45-2b hebben het
enum-lid AgentRuntime.HARNESS en de tabellen product_harness_choices en job_cost_reports nodig, en
host-task.integration en selection.integration draaien dispatchTaskImplementation tegen dezelfde
database zodra die de productkeuze leest.

Naar het voorbeeld van de token-usage-overlay komen de twee 2a-migraties van Scrum4Me ae6483b2
erbovenop, elk met vast pad en sha256, gelezen met `git show` uit de schema-bron; een afwijkende hash
of een ontbrekende bron wordt geweigerd. De historische pin en zijn policy-bewijs blijven staan.

- Het schema public is van pg_database_owner, dus CREATE TABLE als scrum4me faalt zonder tijdelijk
  recht. applyHarnessOverlay doet op één admin-verbinding (SET ROLE leeft in de sessie) wat de
  provisioner voor een additieve migratie doet: GRANT CREATE + SET ROLE scrum4me, het enum-lid en de
  tabellen als twee aparte queries (eerst het enum-lid), dan RESET ROLE + REVOKE CREATE in een finally.
  Een fout halverwege laat dus geen CREATE-recht achter.
- De GRANTs zijn gelijk aan de 2a-contracts: web en prepared-web SELECT/INSERT/UPDATE/DELETE op de
  keuzes en SELECT/INSERT/UPDATE op de kostenrijen, de observer SELECT; de dispatch-, queue- en
  projector-rollen krijgen niets.
- De bron wordt gelezen vóór de provisioner de database aanraakt, en ook in `check`.

Tests (eerst rood gezien): token-usage-overlay (pinnen, bron en hash geweigerd, volgorde en finally
met een nepclient) en harness-overlay.integration in de echte database (enum-lid, eigenaar scrum4me,
geen CREATE meer op public, rechten per rol, constraints, en de web-rol die een keuze schrijft maar
geen kostenrij verwijdert). Alle bestaande integratietests blijven groen: geen niet-gecontracteerd
object en geen vingerafdruk. Het CREATE-recht dat achterblijft en elke afwijkende rol- of
eigenaarsstand zijn rood gezien door ze in de wegwerpdatabase na te bootsen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Een worker met runtime HARNESS claimt alleen HARNESS-jobs van twee soorten, en geen enkele andere
worker claimt ze (spec §5.3):

  cj.runtime = 'HARNESS' AND cj.required_capability IS NULL
  AND ((cj.kind = 'IDEA_CHAT' AND cj.source = 'SYSTEM')
    OR (cj.kind = 'TASK_IMPLEMENTATION' AND cj.source = 'COPILOT' AND cj.sprint_run_id IS NULL))

Zonder deze tak viel een harness-worker (standaard met de capabilities code_edit, planning en review)
terug op het generieke pad en claimde hij elke job van zijn runtime zonder required_capability, van
alle soorten: ook een taak in een sprint-run, een handmatige taak of een IDEA_GRILL. De tak wordt
gekozen op de runtime van de worker, vóór de capability-takken: zijn capabilities tellen niet mee.
Alleen letterlijke waarden, geen nieuwe gebonden waarden.

- eligibility.ts: (A) de string-SQL krijgt een vroege HARNESS-tak, (B) het Prisma-fragment slaat de
  algemene soortvoorwaarde ook voor HARNESS over, (D) het TS-predicaat en (E) de SQL-conditie krijgen
  dezelfde tak. (C) het tier-fragment blijft ongewijzigd: peers filteren al op w.runtime = <eigen
  runtime> en de harness geeft geen tier mee; dat is nu met tests gepind. De Claude-, Codex- en
  local_llm-takken blijven ongewijzigd (de local_llm-tak bedient de oude harness tot de cutover).
- idea-jobs.ts: de "is er een worker?"-precheck van IDEA_GRILL, IDEA_MAKE_PLAN en IDEA_MAKE_SPEC telde
  elke verse worker, ook een harness-worker die die soorten nooit claimt: de job bleef dan eeuwig
  QUEUED. De telling sluit runtime HARNESS uit, met NOT zodat de bestaande pin op where.runtime heel
  blijft. IDEA_REVIEW_PLAN filtert al op CODEX.
- tryClaimJob en de docker-signaturen veranderen niet: de runtime kwam er al in en wordt nu herkend.

Tests (eerst rood gezien): wait-for-job-harness-claim (fragment, string-SQL, tier-fragment, bedrading
in tryClaimJob), eligibility (predicaat), wait-for-job-runtime-claim (Claude en Codex binden nooit
HARNESS), de precheck, en harness-claim.integration tegen een echte Postgres: één tabel met HARNESS-,
Claude- en Codex-jobs. Een HARNESS-worker ziet en claimt precies de idee-chat en de losse taak, een
Claude-worker nooit een HARNESS-job, een Codex-worker alleen de Codex-job en de local_llm-worker
alleen zijn eigen job; verder het tier-fragment met HARNESS-peers en de precheck op de echte telling.
Regressiepins die al groen waren (tier-fragment, nooit HARNESS voor Claude en Codex, geen
tier-fragment voor de harness) zijn rood gezien met een tijdelijke mutatie; ook elke clausule van de
nieuwe tak is met een mutatie rood gezien.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Een test moet iets toetsen. Drie nieuwe tests uit de claim- en overlaytaak bleken dat niet te doen,
of herhaalden een andere test exact:

- wait-for-job-harness-claim: de []-case van "capabilities veranderen niets" vergeleek [] met "niet
  opgegeven", twee kanten die het filter vóór de evaluatie allebei tot [] maakt. Geen enkele zinnige
  mutatie kon hem rood maken. De test vergelijkt nu lijsten met inhoud met een harness-worker zonder
  capabilities, waaronder de standaardcapabilities van een worker (code_edit, planning, review, wat
  wait_for_job meegeeft zonder SCRUM4ME_WORKER_CAPABILITIES) en local_llm. Onder een HARNESS-tak die een
  capability wél meetelt was de oude case groen; de nieuwe is rood, ook voor de standaardlijst.
- eligibility: de []-case van "de capabilities ... tellen niet mee" was exact de test erboven (dezelfde
  executor met lege capabilities, dezelfde twee verwachtingen) en is geschrapt.
- token-usage-overlay: de eerste assertie van "houdt de overlay los ..." herhaalde de pin van
  DISPATCH_SCHEMA_COMMIT uit de eerste test van het bestand en is geschrapt. De twee not.toBe-assertions
  blijven: alleen zij vangen een token-usage-pin die op de 2a-commit wordt gezet.

Alleen testcode; geen productiecode gewijzigd. De drie bestanden en typecheck:tests zijn groen; het
aantal tests in eligibility daalt met één.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Het claimfilter laat een worker alleen jobs van zijn eigen runtime claimen. Gaat dat filter ooit fout, dan
kreeg een Claude-worker de payload van een HARNESS-job (en andersom) en liep hij naar de worktree. Nu controleert
getFullJobContext als eerste stap, vóór elke worktree of idee-voorbereiding en alleen als de aanroeper een
runtime meegeeft, of job.runtime die van de worker is. Zo niet, dan geeft hij de claim terug en gooit hij
RuntimeMismatchError; beide claimpaden van wait_for_job (de directe claim en de claim na het wachten) geven
toolError('RUNTIME_MISMATCH'). De docker-runner roept getFullJobContext(jobId) zonder runtime aan en valt
erbuiten; rollbackClaim blijft ongewijzigd voor de andere paden.

releaseMismatchedClaim doet de teruggave in één transactie, alleen database (er staat nog niets op schijf):
1. SELECT ... FROM claude_jobs WHERE id = $1 FOR UPDATE; is de job dan niet meer CLAIMED door deze token en
   deze instance (lease-verloop en een nieuwe claim, een sweep), dan verandert er niets. Zonder die lock kon
   de teruggave een geldige nieuwe claim van een andere worker overschrijven.
2. De taakstatus terug naar TO_DO, alleen als déze claim de taak promoveerde: t.updated_at = cj.claimed_at in
   SQL tegen de vergrendelde rij (de trigger claude_job_claim_to_task stempelt beide in dezelfde transactie,
   beide TIMESTAMP(3)). Een taak die al IN_PROGRESS was, blijft staan. Moet vóór stap 3, die claimed_at leegt.
3. De job terug naar QUEUED met lege claimvelden.
Zonder eigenaar-identiteit (geen ownerCtx) wordt de rij niet aangeraakt; de fout komt wel. Daarna
claimLog('runtime_mismatch', { jobId, jobRuntime, workerRuntime }).

RuntimeMismatchError staat naast TerminalJobError in on-demand-clone.ts en is er bewust geen subklasse van: de
job blijft QUEUED voor de juiste worker en wordt niet FAILED. De melding begint met de code en noemt job en
beide runtimes; de handler geeft de kale code, via een eigen tak die vóór de TerminalJobError-tak staat.

Tests (eerst rood gezien, 34 + 8 + 9 mislukt om de verwachte reden): wait-for-job-runtime-claim (de zes
runtime-combinaties; één transactie met lock, taak, job in die volgorde; niets op schijf en niets voorbereid; de
claimlog; geen controle zonder runtime-argument; het eigenaarschap onder de lock), wait-for-job-harness-context
(de handler over beide claimpaden, met de echte tryClaimJob en teruggave) en harness-claim.integration tegen een
echte Postgres: job QUEUED met lege claimvelden en taak weer TO_DO, een taak die al IN_PROGRESS was blijft staan,
een andere instance of token laat alles staan, en een tweede verbinding vergrendelt de jobrij en geeft de job
een nieuwe eigenaar: A wacht aantoonbaar op B (pg_blocking_pids) en verandert daarna niets. De drie nieuwe tests
die vóór de wijziging al groen waren (dezelfde runtime en het docker-pad) zijn rood gezien met een mutatie; 27
mutaties van de productiecode zijn gevangen, onder meer FOR UPDATE weghalen (de wachtcontrole faalt), de taakreset
zonder tijdstempelvergelijking, de volgorde van taak en job, en elke eigenaarsvergelijking.

Bestaande job-fixtures in elf testbestanden kregen hun runtime (CLAUDE, of CODEX/HARNESS waar de test die als
parameter meegeeft): ze beschreven een job zonder runtime die door een worker met een runtime werd geclaimd, een
toestand die de nieuwe controle terecht afwijst. Geen enkele assertie is gewijzigd.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Het kostenplafond van een HARNESS-job staat in product_harness_choices; de resolver uit shared 132656b
leest zelf geen database en krijgt het als zesde argument. getFullJobContext leest de rij nu bij de claim,
voor de effectieve runtime HARNESS en een HARNESS-soort (IDEA_CHAT, TASK_IMPLEMENTATION), en geeft de
resolveruitkomst als `config` in de payload: { runtime: 'HARNESS', model: <naam van de job>, max_cost_usd }.
De vorm van de payload is niet veranderd; voor Claude en Codex wordt de keuze niet gelezen.

- readHarnessChoice(db, productId, kind) (nieuw, src/lib/harness-choice.ts) geeft { configuration,
  max_cost_usd } met het plafond als gewone decimale string (de Decimal(10,4) '0.2000' wordt '0.2'), of null
  zonder rij. Er is bewust geen .catch: een leesfout gaat omhoog en geeft nooit de standaard van de soort,
  want een fout is niet "geen rij". Zonder rij geeft de resolver de standaard (0.05 voor IDEA_CHAT, 0.50 voor
  TASK_IMPLEMENTATION); de MCP verzint zelf geen bedrag. `db` is een Pick van de Prisma-client, dus de
  enqueue (Taak 4) kan hem met een transactieclient gebruiken.
- HarnessJobConfigError (src/git/on-demand-clone.ts) is een TerminalJobError met de code als reden. De vier
  codes waarmee de resolver een job afkeurt die nooit bruikbaar wordt (HARNESS_KIND_UNSUPPORTED,
  HARNESS_CONFIGURATION_INVALID, HARNESS_COST_LIMIT_INVALID en UNKNOWN_AGENT_RUNTIME) worden zo gegooid; elke
  andere fout van de resolver gaat ongewijzigd omhoog. Zonder dit bleef zo'n job CLAIMED tot het
  lease-verloop en werd hij twee keer opnieuw geclaimd.
- wait_for_job zet de job bij een HarnessJobConfigError met markJobTerminallyFailed op FAILED en geeft
  toolError(<code>), op beide claimpaden (direct en na het wachten). De tak staat vóór de bestaande
  TerminalJobError-tak: die vangt de subklasse anders eerst en geeft de repotekst
  "Job failed (unresolvable repo): ...". Een gewone TerminalJobError houdt zijn afhandeling.

Tests (eerst rood gezien, 23 + 1 bestand mislukt om de verwachte reden): harness-choice (de Decimal-omzetting, de
sleutel op product en soort, null zonder rij, een leesfout gaat door, het transactietype), wait-for-job-harness-context
(het plafond '0.2000' wordt '0.2' voor beide soorten, de standaard zonder rij, de naam uit de job in plaats van uit de
keuze, een leesfout geeft geen standaard, de vier terminale codes, en de handler over beide claimpaden met
FAILED en de kale code, een leesfout die de job laat staan en de bestaande TerminalJobError-tekst) en
harness-claim.integration tegen een echte Postgres: de echte Decimal uit product_harness_choices wordt een
korte string, zonder rij geldt de standaard en de keuze geldt per soort. Een plafond van 0 kan alleen met mocks
(CHECK > 0). De tests die vóór de wijziging al groen waren (zonder rij, Claude en Codex lezen niet, de
bestaande TerminalJobError-tak) zijn rood gezien met een mutatie; 30 mutaties van de productiecode zijn gevangen,
onder meer de lezing met .catch, de lezing voor elke runtime, een verzonnen bedrag zonder rij, elke van de vier
codes, en de volgorde van de takken per claimpad. Het hand-gemaakte prismamock van kind-prompts-harness (de enige
bestaande test die een HARNESS-job door getFullJobContext haalt) kreeg de twee stubs productHarnessChoice en
jobKindConfig (beide zonder rij); de laatste haalt ook de stacktraces uit de uitvoer. Geen assertie is gewijzigd.

(In de vorige commit staat "27 mutaties"; het waren er 25, allemaal gevangen.)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Alle git-bescherming las alleen required_capability = 'local_llm'. Een HARNESS-job (claude_jobs.runtime) kreeg
daardoor het gewone git-pad: een on-demand clone en `npm ci` op de host, `prepare:worktree`, git met hooks in een
worktree die een container beschrijft, en een backup-push vanuit die worktree.

- isLocalLlmJob(jobId) wordt isHarnessJob(jobId) en leest { runtime, required_capability } uit de database (nooit uit
  de worktree, bewust zonder statusfilter). Nieuw is de pure isHarnessJobRow(row): runtime === 'HARNESS' ||
  required_capability === 'local_llm'. De local_llm-tak blijft permanent (spec §5.6): een afgesloten local_llm-job
  laat een worktree achter die een volgende job als bezetter van de branch tegenkomt, en die map blijft bewaakt.
- De aanroepers volgen het predicaat: worktree.ts (geen prepare:worktree en .gitmodules-gate, de bezetter van een
  oude worktree bij een bestaande en bij een verse branch, opruimen zonder git), wait-for-job.ts attachWorktreeToJob
  (alleen een expliciete repo-root, geen clone), en in local-llm.ts isLocalLlmWorktree (de backup-push slaat over)
  en gitPrefixFor (SAFE_GIT_CONFIG en de gitlinkcontrole vóór elke git-aanroep: push met --no-verify, set-head,
  rev-parse, diff).
- De afgeleide namen (isLocalLlmWorktree, gitPrefixFor, SAFE_GIT_CONFIG, LocalLlmWorktreeRefused,
  removeWorktreeWithoutGit) houden hun naam en krijgen een JSDoc-regel dat ze isHarnessJob volgen; zo blijven alle
  imports en mocks van die namen in de testbestanden werken. De logsleutel backup-push.skip_local_llm en de
  foutteksten blijven ook staan.
- De vier git-paden die het predicaat bewust niet raadplegen (update-task-execution, de sprintclaim, de
  product-worktrees van idee-soorten, de sprint-batch-PR) zijn niet aangeraakt: een HARNESS-job bereikt ze niet.

Tests (eerst rood gezien, 33 mislukten om de verwachte reden): isHarnessJobRow en isHarnessJob bestaan nog niet
(14: de tabel van de pure functie, de select op beide velden, onbekende job, afgesloten job); voor een HARNESS-job
grijpt de bescherming niet in (18): gitPrefixFor geeft [] (geen SAFE_GIT_CONFIG, geen gitlinkcontrole, geen
--no-verify, ook niet bij verify_task_against_plan), de backup-push draait, de bezetter gaat via
`git worktree remove --force` en removeWorktreeForJob draait git in de worktree, `prepare:worktree` draait, een
afwijkende .gitmodules wordt niet geweigerd en de job krijgt een on-demand clone in plaats van FAILED; en de select
van de predicaat-lookup wijzigt bewust (1).

De bestaande local_llm-tests lopen nu per bescherming over twee fixtures (it.each, helper
__tests__/helpers/guarded-jobs.ts), met een controle met een gewone job waar de spy of de push de aanroep wél moet
zien. Nieuw zijn de bezetter van een oude worktree bij een verse branch en bij reuseBranch, het opruimen zonder git,
de backup-push in branch-safety en de bezetter van een afgesloten job (DONE) in git/local-llm.test.ts. De ene
bestaande assertie die wijzigt is de select van de predicaat-lookup in worktree-gitlink.test.ts ({ runtime,
required_capability }); verder is er geen bestaande assertie gewijzigd. In vijf testbestanden is alleen commentaar
aangepast (de naam isLocalLlmJob bestaat niet meer).

De tests die vóór de wijziging al groen waren (de local_llm-varianten, waaronder de bezetter van een afgesloten
local_llm-job) zijn rood gezien met een mutatie die de local_llm-tak uit isHarnessJobRow haalt (21 mislukten in
deze commit, alle local_llm-varianten). Daarnaast is elke aanroeper apart gemuteerd en steeds door beide fixtures
gevangen: prepareWorktree (4), opruimen (4), bezetter bij reuseBranch (6), bezetter bij een verse branch (2) en de
repo-rootkeuze (6). Een predicaat dat altijd waar is wordt door de gewone-job-controles gevangen (12), een CODEX-job
die bewaakt zou raken door de tabel (1) en een select zonder runtime door de selectassertie (2).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Drie plekken in update_job_status sloegen een losse taakjob over op `job.required_capability !== 'local_llm'`: de
auto-PR, de doorwerking naar task, story, PBI en sprint (propagateStatusUpwards) en de PBI-faalcascade
(cancelPbiOnFailure). De harness beheert de taakstatus van zo'n job zelf en de branch wordt met de hand gemerged.
Een HARNESS-taakjob zou daardoor een auto-PR krijgen, de taakstatus dubbel doorwerken en bij een mislukking de
siblings onder dezelfde PBI annuleren.

Elk van de drie wordt `!isHarnessJobRow(job)` (commit ervoor): de jobselect van de handler bevat runtime en
required_capability al, dus er is geen extra lezing. De drie voorwaarden blijven verder gelijk (kind
TASK_IMPLEMENTATION, bron niet MANUAL, een task_id). De legacy-erving van required_capability in de vervolgjob van
een idee-chat is niet aangeraakt: die volgt in Taak 4.

Tests (eerst rood gezien met alleen de vorige commit, 5 mislukten om de verwachte reden: createPullRequest,
propagateStatusUpwards of cancelPbiOnFailure werd voor de HARNESS-job aangeroepen): update-job-status-local-llm draait de
done- en de failed-test nu voor een local_llm- en een HARNESS-job (de twee regressietests met een gewone job blijven);
de ketentests met echte git en een omgebogen gitlink (het failed-pad, en het done-pad met het reviewer-scenario en
het groene pad met --no-verify) draaien voor beide soorten. Elk van de drie voorwaarden is apart gemuteerd (terug naar "nooit
uitgezonderd") en steeds door beide fixtures gevangen: auto-PR (2), doorwerking (4) en cascade (2).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De case "gebruikt SAFE_GIT_CONFIG voor de submodule update --init --recursive van een <job>" droeg de naam van een
bescherming die hij niet toetste. Hij controleerde alleen dat de submodule-inhoud na createWorktreeForJob bestond (dezelfde
bewering als de init-case ervoor) en dat SAFE_GIT_CONFIG.length > 0, een constante. SAFE_GIT_CONFIG is functioneel
onschadelijk voor een gewone submodule-update, dus een update zonder die config geeft dezelfde inhoud: het weghalen van
hooks, fsmonitor en submodule-verwerking uit de bewaakte `git submodule update` werd door geen enkele test gevangen (het
testbestand bleef 11/11 groen en de volledige suite groen). Dat gat bestond al voor local_llm (Taak 4) en is in deze taak
voor HARNESS meegenomen via it.each zonder dat het opviel; de reviewfix voor constraint 9 bracht het aan het licht.

Wat verandert (alleen dit testbestand):
- een delegerende execFile-spy (zelfde patroon als git/local-llm.test.ts) en een helper submoduleUpdateArgs(worktreePath)
  die de argumenten van de `git ... submodule update` met cwd = de worktree uit de spy leest;
- de case toetst voor een local_llm- en een HARNESS-job dat die aanroep exact
  [...SAFE_GIT_CONFIG, 'submodule', 'update', '--init', '--recursive'] is, en houdt de controle dat de inhoud van de
  submodule er staat; de lege assertie op SAFE_GIT_CONFIG.length is weg;
- nieuw: een controle met een gewone job, dezelfde aanroep zonder SAFE_GIT_CONFIG, zodat de spy niet leeg slaagt;
- de submodule-opzet staat nu in een helper addSubmodule(naam) in de describe, voor de case en zijn controle.

Eerst rood gezien met een tijdelijke mutatie van de productiecode (SAFE_GIT_CONFIG weg uit de bewaakte
`git submodule update` in worktree.ts): beide bewaakte fixtures mislukken met
`expected [ [ 'submodule', 'update', ...(2) ] ] to deeply equal [ [ '-c', ...(13) ] ]`, de controle met de gewone job blijft
groen; teruggedraaid (bytes gelijk aan HEAD, git diff leeg) en weer groen (12/12). Volledige suite: 2501 tests (2420 groen,
81 overgeslagen), één meer dan voorheen: de nieuwe controle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Routering (spec §5.2). De drie plekken die een job aanmaken lezen nu de productkeuze met readHarnessChoice, binnen de
transactie, na de guards en vóór de create: de losse taak (dispatchTaskImplementation, kind TASK_IMPLEMENTATION), de
idee-chat (send_idea_chat_message, na de coalescing-check) en de vervolgjob die update_job_status bij de afronding van
een idee-chat maakt. Met een keuze krijgt de job runtime HARNESS en de gekozen configuratie als requested_model, zonder
Claude-snapshot en nooit met required_capability. Zonder keuze (er is echt geen rij) blijft het create-object exact zoals
vóór M45; een leesfout gaat omhoog en is nooit "geen keuze". De vervolgjob volgt de keuze van dat moment, ook als de
voorganger een andere runtime had; zonder keuze erft hij nog de legacy-local_llm-capability, en een HARNESS-voorganger
zonder keuze geeft dus een gewone Claude-vervolgjob (de keuze is ook de toestemming).

dispatch_job weigert required_capability vanaf nu, vóór authenticatie en database; de sleutel blijft in het schema zodat
zod hem niet stil weggooit. Voor een andere soort dan TASK_IMPLEMENTATION blijft de bestaande weigering gelden.
dispatchTaskImplementation verliest de optie requiredCapability en de tak ervoor.

Kostenmelding (spec §6.2). update_job_status krijgt het optionele, strikte veld cost (bedrag als string of null, bron uit
HARNESS_COST_SOURCES, aanbieder). Alleen een job met runtime HARNESS meldt kosten (dus geen local_llm-job) en alleen bij
done, failed of skipped. Het hele object wordt gevalideerd vóór elk neveneffect: vóór de verify-gate, de push en de eigen
eindpaden van DOCS_AUDIT en DEPLOY, zodat een weigering geen gepushte branch achterlaat bij een job die RUNNING blijft.
Regels per bron: none heeft geen bedrag, local vraagt 0, provider_reported en litellm_computed een bedrag >= 0. De
configuratie is requested_model van de job, nooit iets uit de melding. Nieuw in src/lib/harness-cost.ts: de pure
parseReportedCostUsd (alleen string en BigInt, naar boven afgerond op 6 decimalen, past in Decimal(12,6); een float of
een weigering van 0.00031200000000000005 zou de eindstatus verknoeien of te weinig melden) en checkCostReport (wie mag
melden en klopt de melding). De kostenrij wordt in dezelfde transactie geschreven als de statusupdate (upsert op job_id,
reported_at = nu): op het idee-chat-pad in de bestaande transactie direct na de update, op het gewone pad als
prisma.$transaction([update, upsert]) en alleen mét kosten; zonder kosten blijft het de losse update.

Tests: 146 nieuwe of gewijzigde unit-tests (144 erbij, 2 vervangen) in twee nieuwe en vier bestaande bestanden; de
bestaande exacte vormtests blijven ongewijzigd (zonder keuze verandert er niets). In drie bestaande bestanden kregen de
handgemaakte mocks alleen extra stubs (de productkeuze bestaat niet, de kostenrij, en PermissionDeniedError in de
auth-mock voor de foutpaden); de twee local_llm-doorgiftecases zijn nu een weigering. Elke test is rood gezien tegen de
code van vóór deze commit, en elke test ook onder minstens één tijdelijke mutatie van de productiecode (94 mutaties, alle
gevangen).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De mock-tests van T4 bewijzen de bedrading; deze tests bewijzen het gedrag in een echte Postgres, met de rol van de
MCP-installaties (scrum4me_web_runtime). Aangevuld in harness-claim.integration.test.ts, met zijn bestaande hulpfuncties:

- enqueue: dispatchTaskImplementation en send_idea_chat_message met een keuze maken een HARNESS-job zonder
  Claude-snapshot of capability die alleen een HARNESS-worker ziet en claimt; zonder keuze (of met een keuze voor de
  andere jobsoort) een gewone Claude-job die geen HARNESS-worker ziet.
- kostenmelding op het gewone pad en op het idee-chat-pad: de kostenrij staat er met het naar boven afgeronde bedrag en de
  configuratie van de job. Een kostenrij die de database zelf weigert (provider langer dan 200 tekens, buiten het schema
  van de tool omdat de handler direct wordt aangeroepen) draait de statusupdate mee terug: de job blijft CLAIMED en het
  antwoord, de IdeaLog en de kostenrij ontbreken. Een Claude-job met cost wordt geweigerd zonder schrijven.
- de vervolgjob van een idee-chat is met een keuze een HARNESS-job die de claim vindt, zonder keuze een Claude-job.

De seed-gebruiker en -token gaan via een mock van requireWriteAccess naar de tools (zoals host-task.integration), en
dropWorld ruimt nu ook idea_chat_messages op.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De docs beschreven nog de toestand van vóór M45-2b. Wie ze las, schatte vier dingen verkeerd
in: een onbekende SCRUM4ME_WORKER_RUNTIME werd stil CLAUDE (nu start het proces niet meer),
alle git-bewaking en de uitzonderingen in update_job_status gingen alleen over local_llm (nu
over isHarnessJob: een HARNESS-job of een local_llm-job), dispatch_job nam required_capability
nog aan, en update_job_status kende geen kostenmelding. De dispatch-poort heeft bovendien een
volledige Scrum4Me-kloon met ae6483b2 nodig, en dat stond nergens.

- CLAUDE.md: de twee local_llm-uitzonderingen (auto-PR, doorwerking en faalcascade; de
  expliciete repo-root zonder clone) zeggen nu "een HARNESS-job of een local_llm-job
  (isHarnessJob)". Nieuwe sectie "HARNESS runtime (M45-2b)": runtime-identiteit en het
  opstartfalen (UNKNOWN_AGENT_RUNTIME, exitcode 1), health.runtimes, de claimtak met
  RUNTIME_MISMATCH, de payload (config, lege prompt_text) en de terminale HARNESS_*-fouten, het
  ene predicaat met zijn beschermingen en de grep-lijst, de routering via de productkeuze en de
  kostenmelding (alleen HARNESS, alleen done/failed/skipped, naar boven afgerond op 6
  decimalen, in dezelfde transactie). De dispatch-poort beschrijft de overlay van de twee
  2a-migraties en eist een volledige schema-kloon; Key source files kent de nieuwe bestanden.
  AGENTS.md is een symlink naar CLAUDE.md en volgt vanzelf: cmp geeft geen verschil.
- README.md: tooltabel (health.runtimes, update_job_status met cost, send_idea_chat_message en
  de vervolgjob, nieuwe rij dispatch_job die required_capability weigert), de repo-root-
  uitzondering en een sectie "Worker runtime and HARNESS jobs" voor operators: de geldige
  waarden van SCRUM4ME_WORKER_RUNTIME, het opstartfalen, de toolfouten van wait_for_job en de
  uitrolvoorwaarden (migraties, DB-rechten, lockstep van de Prisma-client).
- CHANGELOG.md: één Unreleased-entry voor M45-2b.

Alleen documentatie; geen code en geen test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De review van 10a42d6 vond twee onjuiste beweringen en een reeks te brede formuleringen. Een doc
die iets stelt wat de code niet doet is erger dan een ontbrekende doc, dus elke nieuwe zin is
opnieuw tegen src/ nagelopen (bestand:regel staat in het fixrapport).

Onjuist:
- prompt_text is niet voor elke HARNESS-job leeg: alleen de IDEA_CHAT-payload heeft prompt_text ''
  (wait-for-job.ts:1883 via kind-prompts.ts:63); de payload van een losse TASK_IMPLEMENTATION
  (wait-for-job.ts:2149-2184) heeft geen prompt_text-sleutel, ook niet bij een Claude-job.
- De rechtenlijst voor job_cost_reports noemde INSERT en UPDATE. De upsert geeft de weggeschreven
  rij terug (geen select-optie, update-job-status.ts:1192-1196), dus de rol heeft ook SELECT nodig,
  en het 2a-contract geeft SELECT, INSERT en UPDATE (scripts/dispatch-test-db.mjs:49). De
  voorcontrole in plan-taak 6 noemt alleen INSERT en UPDATE.

Onnauwkeurig:
- "Zonder productkeuze verandert er niets" geldt voor de routering en de claim van Claude- en
  Codex-jobs. De opstartcontrole van SCRUM4ME_WORKER_RUNTIME, de dispatch_job-weigering en de
  SELECT op product_harness_choices gelden juist zonder keuze.
- De dispatch_job-rij zei source COPILOT voor alle soorten; DEPLOY en DOCS_AUDIT maken source
  MANUAL (deploy-dispatch.ts:40, docs-audit-dispatch.ts:35).
- "Geen backup push" is "geen backup push vanuit de worktree": maybeBackupPushBranch
  (worktree.ts:334) draait vanuit de repo-root en raadpleegt het predicaat niet.
- De legacy capability-erving van de vervolgjob (update-job-status.ts:1319-1322) bevat geen
  local_llm-literal; alleen het commentaar op :1315 matcht. Ze staat nu apart van de grep-lijst.
- De update_job_status-rij noemt ook skipped (update-job-status.ts:56), en "de harness stopt op
  RUNTIME_MISMATCH" is een eis aan de harness (increment 2d), geen gedrag van deze repo.

Bij het nalopen erbij gevonden: de canary leest SCRUM4ME_WORKER_RUNTIME niet
(stdio-server.ts:163-168); "alle git-bescherming" werd "de git-bescherming van een bewaakte job"
(update-task-execution heeft geen eigen predicaatcontrole); "submodule recursion" werd
"submodule processing" zoals SAFE_GIT_CONFIG het noemt; en de enqueue-paden geven een HARNESS-job
nooit een required_capability, in plaats van dat zo'n job er nooit een "draagt".

Alleen documentatie: CLAUDE.md, README.md en CHANGELOG.md (AGENTS.md is een symlink).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Brengt de branch op de actuele main (6d4eada) zodat de CI-stap
"Refuse a PR head that is behind its base" de PR niet weigert. Een merge,
geen rebase: de commit-SHA's in de commitberichten en het bewijs blijven geldig.
PR #195 raakt alleen src/tools/update-task-status.ts en
__tests__/update-task-status-input.test.ts; geen overlap met deze branch en
geen wijziging in vendor/scrum4me-shared of prisma/schema.prisma.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Het plan ging ervan uit dat scrum4me-docker getFullJobContext(jobId) zonder
runtime aanroept en dus buiten de runtimecontrole valt. Dat klopt niet: docker
master 77a00a7 (bin/run-one-job.ts) roept getFullJobContext(jobId, runtime,
ownerCtx) aan met de runtime uit getWorkerRuntimeFromEnv(). Een
RuntimeMismatchError valt daar in de generieke catch, die
rollbackClaim(jobId, { tokenId, instanceId }) aanroept. Die is
eigenaar-bewaakt (refreshOwnership): na releaseMismatchedClaim raakt hij 0
rijen (claimlog rollback.ownership_lost) en stopt, dus een no-op.

Alleen tekst, geen gedragswijziging:
- CLAUDE.md (en AGENTS.md, een symlink) en de opmerkingen in wait-for-job.ts
  en on-demand-clone.ts zeggen nu wat docker vandaag doet, en dat docker
  RUNTIME_MISMATCH in deel 2d expliciet hoort af te handelen;
- de twee testtitels "het docker-pad" heten nu "geen productie-aanroeper":
  de tests blijven, want een aanroep zonder runtime-argument bestaat nog als
  code, alleen niet meer als productie-aanroeper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
checkCostReport keek alleen naar runtime en status. Een HARNESS-job van een
andere soort dan IDEA_CHAT en TASK_IMPLEMENTATION kreeg dus een geldig
verklaarde melding, terwijl de eigen eindpaden van DOCS_AUDIT en DEPLOY nooit
een rij in job_cost_reports schrijven: de melding verdween stil. Zo'n job
bestaat vandaag niet (onbereikbaar), maar de handler hoort er niet op te
rekenen.

checkCostReport krijgt de soort van de job mee en weigert elke soort die
isHarnessJobKind (shared harness-config) niet kent met
VALIDATION_ERROR: COST_REPORT_NOT_ALLOWED, ook bij runtime HARNESS. De
soortgrens komt voor de inhoudelijke controle (een ongeldige melding van een
andere soort is NOT_ALLOWED, niet INVALID). De opmerking in
update_job_status over "waar een melding anders stil verloren ging" beloofde
meer dan er gebeurde en is nu feitelijk; de tooltekst, CLAUDE.md, README en
CHANGELOG noemen de soortgrens.

Tests: harness-cost.test.ts toetst alle andere ClaudeJobKind-waarden (een
nieuwe soort valt vanzelf onder "geweigerd") en de volgorde; de handlertest
voor DOCS_AUDIT en DEPLOY had een CLAUDE-fixture en bewees dus alleen de
runtimeweigering. Die heeft nu HARNESS-fixtures waarvan de eigen eindpaden
slagen (zonder de fix komt de job op DONE en verdwijnt de melding), plus een
controletest zonder cost.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
attachWorktreeToJob schrijft bij een bewaakte job zonder expliciete
SCRUM4ME_REPO_ROOT_* de tekst "local_llm vereist een expliciete
SCRUM4ME_REPO_ROOT_*" in claude_jobs.error, ook voor een HARNESS-job. Wie de
fout van een HARNESS-job leest, werd naar een local_llm-route verwezen die er
niet voor geldt. De tekst is nu neutraal voor beide soorten.

De twee tests die de tekst vastpinnen lopen al via GUARDED_JOBS over beide
varianten (local_llm en HARNESS); alleen de verwachte tekst is bijgewerkt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Het plan zegt dat elke waarde van required_capability wordt geweigerd met
"required_capability local_llm wordt niet meer aangenomen; kies per product
een HARNESS-configuratie.". Bij een andere soort dan TASK_IMPLEMENTATION kreeg
een aanroeper nog de oude tekst "required_capability is alleen toegestaan bij
TASK_IMPLEMENTATION.", die suggereert dat de route daar nog bestaat. Nu is het
één weigering voor elke soort, nog steeds vóór authenticatie en database.

- het schema krijgt een .describe() op required_capability: niet meer
  aangenomen, een HARNESS-configuratie kies je per product;
- de tooltekst noemt de weigering, de HARNESS-routering van een losse
  TASK_IMPLEMENTATION via de productkeuze, en de bron (COPILOT, behalve DEPLOY
  en DOCS_AUDIT: MANUAL);
- CLAUDE.md volgt.

Tests: de bestaande test voor een andere soort pint nu de nieuwe tekst (enige
gewijzigde assertie, controller-ruling 11); nieuw is een test per soort uit
KIND_VALUES (weigering, geen dispatcher aangeroepen, geen auth of toegang) en
een test op het schema en de tooltekst.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
De parser deed BigInt- en stringwerk over een invoer van willekeurige lengte
en de opmerking noemde dat lineair. Het zod-schema van update_job_status
(reported_cost_usd: z.string().nullable()) begrenst de lengte niet, en blijft
ongewijzigd (controller-ruling 12). De parser begrenst nu zelf: als allereerste
stap geeft elke invoer langer dan 64 tekens null, dus een lange invoer kost
geen patroon en geen BigInt, en checkCostReport meldt hem als
COST_REPORT_INVALID. Een geldig bedrag is veel korter (een float-som geeft 22
tekens); precies 64 tekens wordt nog gewoon verwerkt. De opmerking klopt nu.

Tests: de grens (64 wel, 65 niet), een lange invoer van 100/1000/100000 tekens
met spionnen op BigInt en RegExp.prototype.test (deterministisch, geen
tijdmeting) en de doorwerking in checkCostReport. Eén bestaande test pinde dat
invoer van 100.000 tekens nog werd verwerkt ('0.000001', '5', '1.5'): die
verwacht nu null, want precies dat is de bedoelde gedragswijziging; zijn doel
(geen kwadratisch terugloopt patroon) blijft gedekt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
getFullJobContext schreef claimLog('runtime_mismatch') pas ná
releaseMismatchedClaim. Gooit de teruggave (een databasefout), dan was de logregel
er niet, terwijl het plan juist op die regel rekent om een fout in het
claimfilter op te merken. Nu: eerst loggen met dezelfde payload, dan teruggeven,
dan RuntimeMismatchError gooien. Een databasefout van de teruggave gaat nog
steeds omhoog (de aanroeper moet weten dat de claim niet is teruggegeven).

Tests: per runtimecombinatie een teruggave die faalt (de logregel staat er toch
en de databasefout komt omhoog) en een volgordetest (de log vóór de
transactie).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
docs(changelog): de keuze wordt gelezen door de drie routeringspaden, niet door elk enqueue-pad (M45-2b, eindreview)
All checks were successful
CI / Final merge attestation and immutable publication (pull_request) Has been skipped
CI / PR candidate (never published) (pull_request) Successful in 5m42s
cb611a2184
De CHANGELOG zei dat product_harness_choices "op elk enqueue-pad" wordt gelezen,
dus ook bij dispatch_job voor andere soorten, sprint-runs en managed dispatch.
Dat klopt niet: alleen een losse TASK_IMPLEMENTATION (dispatchTaskImplementation),
send_idea_chat_message en de idee-chat-vervolgjob van update_job_status lezen de
rij, en wait_for_job leest hem bij de claim van een HARNESS-job. De CHANGELOG
en de gelijkluidende zin in de README (Updating an installation) noemen nu die
paden, zodat een operator de SELECT-rechten niet te ruim of te krap zet.

Alleen tekst.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
s4m-codex-reviewer left a comment

COMMENT

Geen aangetoonde blokkerende codefout gevonden. De wijzigingen voor runtime-identiteit, claimisolatie, routering, gedeelde gitbescherming en transactionele kostenopslag passen bij de beoordeelde PR-scope en productpatronen. Goedkeuring blijft achterwege omdat het volledige verificatiebewijs nog ontbreekt.

Findings:

  • WARNING — .forgejo/workflows/ci.yml:107 — De vereiste kandidaatcheck op cb611a2 staat in Forgejo nog op pending / Waiting to run. De dispatch-integratiepoort met echte Postgres is hier niet uitgevoerd. Het lokale integratiebewijs in de PR-beschrijving is auteursrapportage; bevestig de groene kandidaat- en integratiepoort vóór merge.
  • INFO — tests/update-job-status-local-llm-chain.test.ts:334 — De volledige lokale suite is niet groen bevestigd en is afgebroken na omgevingsfouten. Git-markerproeven falen bij hun positieve controle onder /tmp (noexec), waaronder ook de legacy-fixture; proces-/git-lifecycle-tests ondervinden eveneens beperkingen. Dit levert geen aangetoonde productregressie op.

Verificatie op de exacte PR-head cb611a218488db97b34a5f3906576d9c3984cc0f: beide TypeScript-configs slagen; Prisma-generatie via Node slaagt en laat het schema ongewijzigd; CLAUDE.md en AGENTS.md zijn gelijk. Negen gerichte testbestanden voor runtime, claim, context, routering en kosten: 317 tests geslaagd. De tests dekken onder meer de twee runtime-richtingen, resolverfouten, kostenvalidatie en beide transactionele schrijfpaden.

plan gekoppeld via pr_refs (product Scrum4Me). Referenties: T-2026, T-2031, T-2027, T-2028, T-2029, T-2030, T-2032, ST-1636 en PBI-184 (alle Scrum4Me). omitted is leeg. Het meegeleverde plan-document was afgekapte tekst; het volledige plan op de gepinde PR-verwijzing bfa947db7ec3a01ca9c63e9b10c25e4d5b950d03 is aanvullend gelezen.

De implementatie van plan-taak 1–4 en de repositorydocumentatie is conform de onderzochte contracten. CI, merge als echte merge-commit, uitrol en “Status 2b” zijn nog latere stappen; deze PR beweert de uitrol niet af te ronden en die ontbrekende stappen zijn geen blokkerende codefinding.

# COMMENT Geen aangetoonde blokkerende codefout gevonden. De wijzigingen voor runtime-identiteit, claimisolatie, routering, gedeelde gitbescherming en transactionele kostenopslag passen bij de beoordeelde PR-scope en productpatronen. Goedkeuring blijft achterwege omdat het volledige verificatiebewijs nog ontbreekt. Findings: - **WARNING — .forgejo/workflows/ci.yml:107** — De vereiste kandidaatcheck op `cb611a2` staat in Forgejo nog op `pending / Waiting to run`. De dispatch-integratiepoort met echte Postgres is hier niet uitgevoerd. Het lokale integratiebewijs in de PR-beschrijving is auteursrapportage; bevestig de groene kandidaat- en integratiepoort vóór merge. - **INFO — __tests__/update-job-status-local-llm-chain.test.ts:334** — De volledige lokale suite is niet groen bevestigd en is afgebroken na omgevingsfouten. Git-markerproeven falen bij hun positieve controle onder `/tmp` (`noexec`), waaronder ook de legacy-fixture; proces-/git-lifecycle-tests ondervinden eveneens beperkingen. Dit levert geen aangetoonde productregressie op. Verificatie op de exacte PR-head `cb611a218488db97b34a5f3906576d9c3984cc0f`: beide TypeScript-configs slagen; Prisma-generatie via Node slaagt en laat het schema ongewijzigd; CLAUDE.md en AGENTS.md zijn gelijk. Negen gerichte testbestanden voor runtime, claim, context, routering en kosten: **317 tests geslaagd**. De tests dekken onder meer de twee runtime-richtingen, resolverfouten, kostenvalidatie en beide transactionele schrijfpaden. **plan gekoppeld via pr_refs (product Scrum4Me)**. Referenties: T-2026, T-2031, T-2027, T-2028, T-2029, T-2030, T-2032, ST-1636 en PBI-184 (alle Scrum4Me). `omitted` is leeg. Het meegeleverde plan-document was afgekapte tekst; het volledige plan op de gepinde PR-verwijzing `bfa947db7ec3a01ca9c63e9b10c25e4d5b950d03` is aanvullend gelezen. De implementatie van plan-taak 1–4 en de repositorydocumentatie is conform de onderzochte contracten. CI, merge als echte merge-commit, uitrol en “Status 2b” zijn nog latere stappen; deze PR beweert de uitrol niet af te ronden en die ontbrekende stappen zijn geen blokkerende codefinding.
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference
janpeter/scrum4me-mcp!196
No description provided.