Codex Harness-contextengineport

Status

Concept-implementatiespecificatie.

Doel

Laat de gebundelde Codex app-server-harness hetzelfde OpenClaw context-engine-levenscycluscontract respecteren dat ingebedde OpenClaw-beurten al respecteren.

Een sessie die provider/model agentRuntime.id: "codex" of een codex/*-model gebruikt, moet de geselecteerde context-engine-plugin, zoals lossless-claw, nog steeds contextassemblage, ingest na de beurt, onderhoud en OpenClaw-niveau Compaction-beleid laten beheren voor zover de Codex app-server-grens dat toestaat.

Niet-doelen

• Implementeer Codex app-server-internals niet opnieuw.
• Laat native Codex-thread-Compaction geen lossless-claw-samenvatting produceren.
• Vereis niet dat niet-Codex-modellen de Codex-harness gebruiken.
• Wijzig het gedrag van ACP/acpx-sessies niet. Deze specificatie is alleen voor het niet-ACP-pad van de ingebedde agent-harness.
• Laat externe plugins geen Codex app-server-extensiefabrieken registreren; de bestaande vertrouwensgrens voor gebundelde plugins blijft ongewijzigd.

Huidige architectuur

De ingebedde run-loop lost de geconfigureerde context-engine eenmaal per run op voordat een concrete low-level harness wordt geselecteerd:

• src/agents/embedded-agent-runner/run.ts
  • initialiseert context-engine-plugins
  • roept resolveContextEngine(params.config) aan
  • geeft contextEngine en contextTokenBudget door aan runEmbeddedAttemptWithBackend(...)

runEmbeddedAttemptWithBackend(...) delegeert naar de geselecteerde agent-harness:

• src/agents/embedded-agent-runner/run/backend.ts
• src/agents/harness/selection.ts

De Codex app-server-harness wordt geregistreerd door de gebundelde Codex Plugin:

• extensions/codex/index.ts
• extensions/codex/harness.ts

De Codex-harnessimplementatie ontvangt dezelfde EmbeddedRunAttemptParams als ingebouwde OpenClaw-pogingen:

• extensions/codex/src/app-server/run-attempt.ts

Dat betekent dat het vereiste hookpunt in door OpenClaw beheerde code zit. De externe grens is het Codex app-server-protocol zelf: OpenClaw kan beheren wat het naar thread/start, thread/resume en turn/start stuurt, en kan notificaties observeren, maar het kan Codex' interne threadopslag of native compactor niet wijzigen.

Huidige kloof

Ingebouwde OpenClaw-pogingen roepen de context-engine-levenscyclus direct aan:

• bootstrap/onderhoud vóór de poging
• assemble vóór de modelaanroep
• afterTurn of ingest na de poging
• onderhoud na een geslaagde beurt
• context-engine-Compaction voor engines die Compaction beheren

Relevante OpenClaw-code:

• src/agents/embedded-agent-runner/run/attempt.ts
• src/agents/embedded-agent-runner/run/attempt.context-engine-helpers.ts
• src/agents/embedded-agent-runner/context-engine-maintenance.ts

Codex app-server-pogingen voeren momenteel generieke agent-harness-hooks uit en spiegelen het transcript, maar roepen params.contextEngine.bootstrap, params.contextEngine.assemble, params.contextEngine.afterTurn, params.contextEngine.ingestBatch, params.contextEngine.ingest of params.contextEngine.maintain niet aan.

Relevante Codex-code:

• extensions/codex/src/app-server/run-attempt.ts
• extensions/codex/src/app-server/thread-lifecycle.ts
• extensions/codex/src/app-server/event-projector.ts
• extensions/codex/src/app-server/compact.ts

Gewenst gedrag

Voor Codex-harnessbeurten moet OpenClaw deze levenscyclus behouden:

1. Lees het gespiegelde OpenClaw-sessietranscript.
2. Bootstrap de actieve context-engine wanneer er een vorig sessiebestand bestaat.
3. Voer bootstraponderhoud uit wanneer beschikbaar.
4. Assembleer context met de actieve context-engine.
5. Converteer de geassembleerde context naar Codex-compatibele invoer.
6. Start of hervat de Codex-thread met ontwikkelaarsinstructies die eventuele context-engine-systemPromptAddition bevatten.
7. Start de Codex-beurt met de geassembleerde gebruikersgerichte prompt.
8. Spiegel het Codex-resultaat terug naar het OpenClaw-transcript.
9. Roep afterTurn aan indien geïmplementeerd, anders ingestBatch/ingest, met de gespiegelde transcriptsnapshot.
10. Voer beurtonderhoud uit na geslaagde, niet-afgebroken beurten.
11. Behoud native Codex-Compaction-signalen en OpenClaw-Compaction-hooks.

Ontwerpbeperkingen

Codex app-server blijft canoniek voor native threadstatus

Codex beheert zijn native thread en eventuele interne uitgebreide geschiedenis. OpenClaw moet niet proberen de interne geschiedenis van de app-server te muteren, behalve via ondersteunde protocolaanroepen.

OpenClaw's transcriptspiegel blijft de bron voor OpenClaw-functies:

• chatgeschiedenis
• zoeken
• /new- en /reset-boekhouding
• toekomstige model- of harnesswissels
• context-engine-pluginstatus

Context-engineassemblage moet naar Codex-invoer worden geprojecteerd

De context-engine-interface retourneert OpenClaw AgentMessage[], geen Codex-threadpatch. Codex app-server turn/start accepteert een huidige gebruikersinvoer, terwijl thread/start en thread/resume ontwikkelaarsinstructies accepteren.

Daarom heeft de implementatie een projectielaag nodig. De veilige eerste versie moet vermijden te doen alsof die Codex' interne geschiedenis kan vervangen. Ze moet geassembleerde context injecteren als deterministisch prompt-/ontwikkelaarsinstructiemateriaal rond de huidige beurt.

Prompt-cachestabiliteit is belangrijk

Voor engines zoals lossless-claw moet de geassembleerde context deterministisch zijn voor ongewijzigde invoer. Voeg geen tijdstempels, willekeurige id's of niet-deterministische ordening toe aan gegenereerde contexttekst.

Runtime-selectiesemantiek verandert niet

Harnessselectie blijft zoals die is:

• runtime: "openclaw" selecteert de ingebouwde OpenClaw-harness
• runtime: "codex" selecteert de geregistreerde Codex-harness
• runtime: "auto" laat plugin-harnesses ondersteunde providers claimen
• niet-gematchte auto-runs gebruiken de ingebouwde OpenClaw-harness

Dit werk verandert wat er gebeurt nadat de Codex-harness is geselecteerd.

Implementatieplan

1. Exporteer of verplaats herbruikbare context-engine-poginghelpers

Vandaag staan de herbruikbare levenscyclushelpers onder de ingebedde agentrunner:

• src/agents/embedded-agent-runner/run/attempt.context-engine-helpers.ts
• src/agents/embedded-agent-runner/run/attempt.prompt-helpers.ts
• src/agents/embedded-agent-runner/context-engine-maintenance.ts

Codex moet harness-neutrale helpers importeren in plaats van in runnerimplementatiedetails te grijpen.

Maak een harness-neutrale module, bijvoorbeeld:

• src/agents/harness/context-engine-lifecycle.ts

Verplaats of herexporteer:

• runAttemptContextEngineBootstrap
• assembleAttemptContextEngine
• finalizeAttemptContextEngineTurn
• buildAfterTurnRuntimeContext
• buildAfterTurnRuntimeContextFromUsage
• een kleine wrapper rond runContextEngineMaintenance

Werk de aanroeppunten van de ingebouwde harness in dezelfde PR bij.

De neutrale helpernamen mogen de ingebouwde harness niet noemen.

Voorgestelde namen:

• bootstrapHarnessContextEngine
• assembleHarnessContextEngine
• finalizeHarnessContextEngineTurn
• buildHarnessContextEngineRuntimeContext
• runHarnessContextEngineMaintenance

2. Voeg een Codex-contextprojectiehelper toe

Voeg een nieuwe module toe:

• extensions/codex/src/app-server/context-engine-projection.ts

Verantwoordelijkheden:

• Accepteer de geassembleerde AgentMessage[], oorspronkelijke gespiegelde geschiedenis en huidige prompt.
• Bepaal welke context in ontwikkelaarsinstructies hoort en welke in de huidige gebruikersinvoer.
• Behoud de huidige gebruikersprompt als het laatste uitvoerbare verzoek.
• Render eerdere berichten in een stabiel, expliciet formaat.
• Vermijd vluchtige metadata.

Voorgestelde API:

export type CodexContextProjection = {  developerInstructionAddition?: string;  promptText: string;  assembledMessages: AgentMessage[];  prePromptMessageCount: number;}; export function projectContextEngineAssemblyForCodex(params: {  assembledMessages: AgentMessage[];  originalHistoryMessages: AgentMessage[];  prompt: string;  systemPromptAddition?: string;}): CodexContextProjection;

Aanbevolen eerste projectie:

• Plaats systemPromptAddition in ontwikkelaarsinstructies.
• Plaats de geassembleerde transcriptcontext vóór de huidige prompt in promptText.
• Label die duidelijk als door OpenClaw geassembleerde context.
• Houd de huidige prompt als laatste.
• Sluit dubbele huidige gebruikersprompt uit als die al aan het einde voorkomt.

Voorbeeldpromptvorm:

OpenClaw assembled context for this turn: <conversation_context>[user]... [assistant]...</conversation_context> Current user request:...

Dit is minder elegant dan native Codex-geschiedenischirurgie, maar het is implementeerbaar binnen OpenClaw en behoudt context-engine-semantiek.

Toekomstige verbetering: als Codex app-server een protocol beschikbaar maakt voor het vervangen of aanvullen van threadgeschiedenis, wijzig deze projectielaag dan om die API te gebruiken.

3. Sluit bootstrap aan vóór Codex-threadopstart

In extensions/codex/src/app-server/run-attempt.ts:

• Lees gespiegelde sessiegeschiedenis zoals vandaag.
• Bepaal of het sessiebestand vóór deze run bestond. Geef de voorkeur aan een helper die fs.stat(params.sessionFile) controleert vóór spiegelingswrites.
• Open een SessionManager of gebruik een smalle sessiemanageradapter als de helper die vereist.
• Roep de neutrale bootstraphelper aan wanneer params.contextEngine bestaat.

Pseudo-flow:

const hadSessionFile = await fileExists(params.sessionFile);const sessionManager = SessionManager.open(params.sessionFile);const historyMessages = sessionManager.buildSessionContext().messages; await bootstrapHarnessContextEngine({  hadSessionFile,  contextEngine: params.contextEngine,  sessionId: params.sessionId,  sessionKey: sandboxSessionKey,  sessionFile: params.sessionFile,  sessionManager,  runtimeContext: buildHarnessContextEngineRuntimeContext(...),  runMaintenance: runHarnessContextEngineMaintenance,  warn,});

Gebruik dezelfde sessionKey-conventie als de Codex-toolbrug en transcriptspiegel. Vandaag berekent Codex sandboxSessionKey uit params.sessionKey of params.sessionId; gebruik dat consistent, tenzij er een reden is om ruwe params.sessionKey te behouden.

4. Sluit assemble aan vóór thread/start / thread/resume en turn/start

In runCodexAppServerAttempt:

1. Bouw eerst dynamische tools, zodat de context-engine de daadwerkelijk beschikbare toolnamen ziet.
2. Lees gespiegelde sessiegeschiedenis.
3. Voer context-engine assemble(...) uit wanneer params.contextEngine bestaat.
4. Projecteer het geassembleerde resultaat naar:
   • toevoeging aan ontwikkelaarsinstructies
   • prompttekst voor turn/start

De bestaande hookaanroep:

resolveAgentHarnessBeforePromptBuildResult({  prompt: params.prompt,  developerInstructions: buildDeveloperInstructions(params),  messages: historyMessages,  ctx: hookContext,});

moet contextbewust worden:

1. bereken basisontwikkelaarsinstructies met buildDeveloperInstructions(params)
2. pas context-engineassemblage/-projectie toe
3. voer before_prompt_build uit met de geprojecteerde prompt/ontwikkelaarsinstructies

Deze volgorde laat generieke prompthooks dezelfde prompt zien die Codex zal ontvangen. Als strikte OpenClaw-pariteit nodig is, voer context-engineassemblage dan uit vóór hookcompositie, omdat de ingebouwde harness context-engine-systemPromptAddition toepast op de uiteindelijke systeemprompt na de promptpipeline. De belangrijke invariant is dat zowel context-engine als hooks een deterministische, gedocumenteerde volgorde krijgen.

Aanbevolen volgorde voor de eerste implementatie:

1. buildDeveloperInstructions(params)
2. context-engine assemble()
3. voeg systemPromptAddition toe aan ontwikkelaarsinstructies, vooraf of achteraf
4. projecteer geassembleerde berichten naar prompttekst
5. resolveAgentHarnessBeforePromptBuildResult(...)
6. geef uiteindelijke ontwikkelaarsinstructies door aan startOrResumeThread(...)
7. geef uiteindelijke prompttekst door aan buildTurnStartParams(...)

De specificatie moet in tests worden vastgelegd zodat toekomstige wijzigingen de volgorde niet per ongeluk veranderen.

5. Behoud prompt-cache-stabiele opmaak

De projectiehelper moet byte-stabiele uitvoer produceren voor identieke invoer:

• stabiele berichtvolgorde
• stabiele rollabels
• geen gegenereerde tijdstempels
• geen lekkage van object-sleutelvolgorde
• geen willekeurige scheidingstekens
• geen per-run-id's

Gebruik vaste scheidingstekens en expliciete secties.

6. Sluit post-turn aan na transcriptspiegeling

Codex' CodexAppServerEventProjector bouwt een lokale messagesSnapshot voor de huidige beurt. mirrorTranscriptBestEffort(...) schrijft die momentopname naar de OpenClaw-transcriptspiegel.

Nadat spiegelen slaagt of faalt, roep je de context-enginefinalizer aan met de best beschikbare berichtmomentopname:

• Geef de voorkeur aan volledige gespiegelde sessiecontext na de schrijfactie, omdat afterTurn de sessiemomentopname verwacht, niet alleen de huidige beurt.
• Val terug op historyMessages + result.messagesSnapshot als het sessiebestand niet opnieuw kan worden geopend.

Pseudoflow:

const prePromptMessageCount = historyMessages.length;await mirrorTranscriptBestEffort(...);const finalMessages = readMirroredSessionHistoryMessages(params.sessionFile)  ?? [...historyMessages, ...result.messagesSnapshot]; await finalizeHarnessContextEngineTurn({  contextEngine: params.contextEngine,  promptError: Boolean(finalPromptError),  aborted: finalAborted,  yieldAborted,  sessionIdUsed: params.sessionId,  sessionKey: sandboxSessionKey,  sessionFile: params.sessionFile,  messagesSnapshot: finalMessages,  prePromptMessageCount,  tokenBudget: params.contextTokenBudget,  runtimeContext: buildHarnessContextEngineRuntimeContextFromUsage({    attempt: params,    workspaceDir: effectiveWorkspace,    agentDir,    tokenBudget: params.contextTokenBudget,    lastCallUsage: result.attemptUsage,    promptCache: result.promptCache,  }),  runMaintenance: runHarnessContextEngineMaintenance,  sessionManager,  warn,});

Als spiegelen mislukt, roep dan nog steeds afterTurn aan met de fallbackmomentopname, maar log dat de context engine gegevens inneemt uit fallbackbeurtgegevens.

7. Gebruik en prompt-cache-runtimecontext normaliseren

Codex-resultaten bevatten genormaliseerd gebruik uit app-servertokenmeldingen wanneer beschikbaar. Geef dat gebruik door aan de context-engine-runtimecontext.

Als de Codex-app-server uiteindelijk cachelees-/schrijfdetails beschikbaar stelt, map die dan naar ContextEnginePromptCacheInfo. Laat tot die tijd promptCache weg in plaats van nullen te verzinnen.

8. Compaction-beleid

Er zijn twee Compaction-systemen:

1. OpenClaw context-engine compact()
2. Codex app-server native thread/compact/start

Voeg ze niet stilzwijgend samen.

/compact en expliciete OpenClaw-Compaction

Wanneer de geselecteerde context engine info.ownsCompaction === true heeft, moet expliciete OpenClaw-Compaction de voorkeur geven aan het compact()-resultaat van de context engine voor de OpenClaw-transcriptspiegel en Plugin-status.

Wanneer de geselecteerde Codex-harness een native threadbinding heeft, kunnen we daarnaast Codex-native Compaction aanvragen om de app-serverthread gezond te houden, maar dit moet in details als een afzonderlijke backendactie worden gerapporteerd.

Aanbevolen gedrag:

• Als contextEngine.info.ownsCompaction === true:
  • roep eerst context-engine compact() aan
  • roep daarna best-effort Codex-native Compaction aan wanneer er een threadbinding bestaat
  • retourneer het context-engineresultaat als het primaire resultaat
  • neem de status van Codex-native Compaction op in details.codexNativeCompaction
• Als de actieve context engine geen eigenaar is van Compaction:
  • behoud het huidige gedrag voor Codex-native Compaction

Dit vereist waarschijnlijk een wijziging in extensions/codex/src/app-server/compact.ts of een wrapper vanuit het generieke Compaction-pad, afhankelijk van waar maybeCompactAgentHarnessSession(...) wordt aangeroepen.

In-turn Codex-native contextCompaction-events

Codex kan tijdens een beurt contextCompaction-itemevents uitsturen. Behoud de huidige emissie van before/after-Compaction-hooks in event-projector.ts, maar behandel dat niet als een voltooide context-engine-Compaction.

Voor engines die eigenaar zijn van Compaction, emit je een expliciete diagnostische melding wanneer Codex toch native Compaction uitvoert:

• stream-/eventnaam: bestaande compaction-stream is acceptabel
• details: { backend: "codex-app-server", ownsCompaction: true }

Dit maakt de splitsing controleerbaar.

9. Sessiereset en bindingsgedrag

De bestaande Codex-harness reset(...) wist de Codex-app-serverbinding uit het OpenClaw-sessiebestand. Behoud dat gedrag.

Zorg er ook voor dat opschoning van context-engine-status via bestaande OpenClaw-sessielevenscycluspaden blijft verlopen. Voeg geen Codex-specifieke opschoning toe, tenzij de context-enginelevenscyclus momenteel reset-/delete-events mist voor alle harnesses.

10. Foutafhandeling

Volg ingebouwde OpenClaw-semantiek:

• bootstrapfouten waarschuwen en gaan door
• assemble-fouten waarschuwen en vallen terug op niet-geassembleerde pipelineberichten/prompt
• afterTurn-/ingest-fouten waarschuwen en markeren post-turn-finalisatie als onsuccesvol
• onderhoud draait alleen na geslaagde, niet-afgebroken beurten zonder yield
• Compaction-fouten mogen niet opnieuw worden geprobeerd als nieuwe prompts

Codex-specifieke aanvullingen:

• Als contextprojectie mislukt, waarschuw dan en val terug op de oorspronkelijke prompt.
• Als transcriptspiegeling mislukt, probeer dan nog steeds context-enginefinalisatie met fallbackberichten.
• Als Codex-native Compaction mislukt nadat context-engine-Compaction is geslaagd, laat dan niet de hele OpenClaw-Compaction falen wanneer de context engine primair is.

Testplan

Unittests

Voeg tests toe onder extensions/codex/src/app-server:

1. run-attempt.context-engine.test.ts

   • Codex roept bootstrap aan wanneer er een sessiebestand bestaat.
   • Codex roept assemble aan met gespiegelde berichten, tokenbudget, toolnamen, citatiemodus, model-id en prompt.
   • systemPromptAddition wordt opgenomen in developer-instructies.
   • Geassembleerde berichten worden vóór het huidige verzoek in de prompt geprojecteerd.
   • Codex roept afterTurn aan na transcriptspiegeling.
   • Zonder afterTurn roept Codex ingestBatch of per-bericht ingest aan.
   • Beurtonderhoud draait na geslaagde beurten.
   • Beurtonderhoud draait niet bij promptfout, afbreken of yield-afbreken.

2. context-engine-projection.test.ts

   • stabiele uitvoer voor identieke invoer
   • geen dubbele huidige prompt wanneer geassembleerde geschiedenis die bevat
   • verwerkt lege geschiedenis
   • behoudt rolvolgorde
   • neemt systeem-prompttoevoeging alleen op in developer-instructies

3. compact.context-engine.test.ts

   • primair resultaat van eigenaar-context engine wint
   • status van Codex-native Compaction verschijnt in details wanneer die ook is geprobeerd
   • Codex-native fout laat eigenaar-context-engine-Compaction niet falen
   • niet-eigenaar context engine behoudt huidig native Compaction-gedrag

Bestaande tests om bij te werken

• extensions/codex/src/app-server/run-attempt.test.ts indien aanwezig, anders de dichtstbijzijnde Codex-app-serverruntests.
• extensions/codex/src/app-server/event-projector.test.ts alleen als details van Compaction-events wijzigen.
• src/agents/harness/selection.test.ts zou geen wijzigingen nodig moeten hebben, tenzij configuratiegedrag wijzigt; die moet stabiel blijven.
• Ingebouwde harness-context-enginetests moeten ongewijzigd blijven slagen.

Integratie-/livetests

Voeg live Codex-harness-smoketests toe of breid ze uit:

• configureer plugins.slots.contextEngine naar een testengine
• configureer agents.defaults.model naar een codex/*-model
• configureer provider/model agentRuntime.id = "codex"
• verifieer dat de testengine het volgende observeerde:
  • bootstrap
  • assemble
  • afterTurn of ingest
  • onderhoud

Vermijd dat lossless-claw vereist is in OpenClaw-coretests. Gebruik een kleine in-repo fake context-engine-Plugin.

Observeerbaarheid

Voeg debuglogs toe rond Codex context-engine-levenscyclusaanroepen:

• codex context engine bootstrap started/completed/failed
• codex context engine assemble applied
• codex context engine finalize completed/failed
• codex context engine maintenance skipped met reden
• codex native compaction completed alongside context-engine compaction

Log geen volledige prompts of transcriptinhoud.

Voeg gestructureerde velden toe waar nuttig:

• sessionId
• sessionKey geredigeerd of weggelaten volgens bestaande loggingpraktijk
• engineId
• threadId
• turnId
• assembledMessageCount
• estimatedTokens
• hasSystemPromptAddition

Migratie / compatibiliteit

Dit moet achterwaarts compatibel zijn:

• Als er geen context engine is geconfigureerd, moet legacy context-enginegedrag gelijkwaardig zijn aan het huidige Codex-harnessgedrag.
• Als context-engine assemble mislukt, moet Codex doorgaan met het oorspronkelijke promptpad.
• Bestaande Codex-threadbindingen moeten geldig blijven.
• Dynamische toolfingerprinting mag geen context-engine-uitvoer bevatten; anders kan elke contextwijziging een nieuwe Codex-thread afdwingen. Alleen de toolcatalogus mag invloed hebben op de dynamische toolfingerprint.

Open vragen

1. Moet geassembleerde context volledig in de gebruikersprompt worden geïnjecteerd, volledig in developer-instructies, of gesplitst?

   Aanbeveling: splitsen. Plaats systemPromptAddition in developer-instructies; plaats geassembleerde transcriptcontext in de wrapper voor de gebruikersprompt. Dit sluit het best aan bij het huidige Codex-protocol zonder native threadgeschiedenis te muteren.

2. Moet Codex-native Compaction worden uitgeschakeld wanneer een context engine eigenaar is van Compaction?

   Aanbeveling: nee, aanvankelijk niet. Codex-native Compaction kan nog steeds nodig zijn om de app-serverthread actief te houden. Maar het moet worden gerapporteerd als native Codex-Compaction, niet als context-engine-Compaction.

3. Moet before_prompt_build vóór of na context-engine-assembly draaien?

   Aanbeveling: na context-engineprojectie voor Codex, zodat generieke harnesshooks de daadwerkelijke prompt/developer-instructies zien die Codex zal ontvangen. Als pariteit met ingebouwde harnesses het tegenovergestelde vereist, leg dan de gekozen volgorde vast in tests en documenteer die hier.

4. Kan de Codex-app-server in de toekomst een gestructureerde context-/geschiedenisoverride accepteren?

   Onbekend. Als dat kan, vervang dan de tekstprojectielaag door dat protocol en houd de levenscyclusaanroepen ongewijzigd.

Acceptatiecriteria

• Een codex/* embedded harnessbeurt roept de assemble-levenscyclus van de geselecteerde context engine aan.
• Een context-engine systemPromptAddition beïnvloedt Codex developer-instructies.
• Geassembleerde context beïnvloedt de invoer van de Codex-beurt deterministisch.
• Geslaagde Codex-beurten roepen afterTurn of ingest-fallback aan.
• Geslaagde Codex-beurten draaien context-engine-beurtonderhoud.
• Mislukte/afgebroken/yield-afgebroken beurten draaien geen beurtonderhoud.
• Context-engine-owned Compaction blijft primair voor OpenClaw-/Plugin-status.
• Codex-native Compaction blijft controleerbaar als native Codex-gedrag.
• Bestaand ingebouwd harness-context-enginegedrag is ongewijzigd.
• Bestaand Codex-harnessgedrag is ongewijzigd wanneer geen non-legacy context engine is geselecteerd of wanneer assembly mislukt.