Kjell Tore Guttormsen
9232f94041
F3 and F4, the two findings the S7 acid test (session 98) reported and left. The order required both descriptions to be treated as PREMISES. One held; the other was felled before anything was built on it. F3 -- premise FELLED, asymmetry real. The order read arm C's two refused calls as "the path names a document that EXISTS". Measured against the base that ran: its root holds 27 directories named del-ii-bilag-N-... and 12 documents named inbox-del-ii-bilag-N-....md, and the requested path matches NEITHER -- it is the directory naming convention applied to a document whose real name carries an inbox- prefix. So the two live rounds were the UNKNOWN-path class, and this delivery does NOT recover them (gated). What IS real: read_file on a directory has named read_dir since session 95, while read_dir on a document named neither the rung nor the path. okf.DocumentPathRefused closes that one direction -- a ValueError, a SIBLING of BundlePathNotFound rather than a subclass, built from context_files (never files) and through the same in_dimension predicate the listing uses, quoting the document's REAL name so what it hands back resolves. F4 -- premise HELD, option (c) felled by measurement. All four live artefacts stamped cost_baseline_anchored: False and each arm invented its cost codes. derive_cost_baseline refuses against the delivered base: K2's price schedule is a pandoc SIMPLE table with ONE column header, so making --derive-cost-baseline reachable there would mean inventing a rule for an unmeasured form -- MAJOR-4's own honesty limit. Chose (b) over (a): --require-cost-baseline / run_project(require_cost_baseline=...), OPT-IN and never default, so every bundle without a cost-baseline.json runs unchanged. The gate sits where both branches have bound baseline and ABOVE the dry-run cut, so it fires on the free trip too and, on the paid one, before the first model call. Three CLI refusals by name, each with an rc-0 control. 12 mutations, all red against the WHOLE suite. Green control 1493/5 -> 1511/5 (+18 node-ids, 0 removed); golden demo-transcript.stdout BYTE-UNCHANGED (shasum -a 1 of the CONTENT = ea8c534773acdbe41ae68f2c55724d69aaf8be4f). No paid run: both findings measured offline. Measurement: docs/2026-09-08-f3-f4-nekten-og-forankringen.md Order: 20260908T020419Z-5837110336-from-portfolio-optimiser Co-Authored-By: Claude <Opus 5>
2179 lines
207 KiB
Markdown
2179 lines
207 KiB
Markdown
# portfolio-optimiser
|
||
|
||
> **Note for visitors — what this file is.** This is the working agreement between the repository
|
||
> and the AI coding agent that builds it (the [Claude Code](https://claude.com/claude-code)
|
||
> convention), and it is written in Norwegian because that is the maintainer's working language.
|
||
> It doubles as the repository's **invariant ledger**: each block below records a design decision,
|
||
> the measurement that forced it, and the test that turns red when the decision is undone.
|
||
>
|
||
> **You need none of it to use the framework** — start with the [README](README.md). It is
|
||
> published anyway, because the reasoning behind a decision is worth more than the decision, and
|
||
> because a rule kept out of sight is a rule that drifts without anyone noticing.
|
||
|
||
## Kontekst
|
||
Generisk, åpent Python-rammeverk på **Microsoft Agent Framework (MAF)** som finner kostnadsbesparelser INNI hvert prosjekt i en portefølje av uavhengige prosjekter. Multi-agent samarbeid genererer kandidat-tiltak; en obligatorisk deterministisk validator avgjør verdiene; fageksperter vurderer via HITL, og systemet lærer av dommene. Publiseres på Forgejo for alle som har MAF.
|
||
|
||
Bakgrunn og beslutninger: [research](docs/research/2026-06-23-prior-art-platform.md) (§15 implementeringsregister), [plan](docs/plan/2026-06-23-incremental-plan.md). Løpende state: `STATE.md` (local-only).
|
||
|
||
## Stack
|
||
Python ≥3.10. MAF (`agent-framework-core` 1.16.0, `-orchestrations` 1.1.1 — F15, 02.09). Pakkehåndtering: `uv`. To backend-profiler: Azure/Foundry (full) + lokal (fallback).
|
||
|
||
## Konvensjoner
|
||
- Type hints overalt (`mypy` der mulig). Pydantic for validering/IR.
|
||
- `ruff` for lint+format. `pytest` for test.
|
||
- Modell-valg som konfig (modell-map rolle→Foundry-deployment), ikke spredt i kode.
|
||
- Metode kodifiseres som **Agent Skill** (`agentskills.io`: `SKILL.md` + `scripts/` + `references/`).
|
||
- Datatilgang: in-process `FunctionTool` er default-sømmen i kjørestien. **MCP er wiret som opt-in i kjørestien** (`mcp_tools.py` + `--mcp-config`, Trekk B 2026-08-05): konkrete eksterne servere blir verktøy agentene kan kalle UNDER debatten. Uten konfig gjøres null nettverkskall og verktøylista er uendret. Tre regler er load-bearing: **allowlist er påkrevd** (tom liste ville latt motparten bestemme hva agentene får kalle), **hver server og hvert tillatte verktøy navngis i kunngjøringen før første kall** (også uten `--mandate` — ingen udeklarert egress), og `--live-dry-run` åpner **ingenting**. Egen søm fra `ingest_mcp.py` (kildedokumenter FØR kjøring, null-argument-tools) — samme protokoll, ulik jobb. `build_mcp_server` (`datasource.py`) er fortsatt kun demo. Data-source-konfig JSON-Schema-validert, fail-fast.
|
||
- `shared/` er en **git subtree** av [`portfolio-optimiser-commons`](https://git.fromaitochitta.com/open/portfolio-optimiser-commons) (source of truth, R1 realisert 2026-07-03; publisert i `open/` 2026-08-04 — `commons`-remoten peker fortsatt på den private namespacen og virker uendret). Synk er **pull-only**: endringer committes i commons og hentes med `git subtree pull --prefix=shared commons main --squash`. ALDRI `git subtree push` fra konsument — re-split lekker hele konsument-historikken inn i commons (observert + opprydd 2026-07-03). Se `shared/README.md`. Wheelen bærer treet som pakkede data siden Fase 4a — se invarianten under.
|
||
|
||
## Kommandoer
|
||
- Sync: `uv sync` — installerer to konsoll-kommandoer: `portfolio-optimiser` (CLI, `run:main`) og
|
||
`portfolio-optimiser-demo` (offline-beviset, `simulation:main`). `python -m`-formene virker
|
||
uendret og er byte-identiske på stdout (målt). Bevisst KUN to av fem `main()` —
|
||
`costsim`/`hitl`/`preflight` er operatørverktøy, ikke produktets inngang, og hvert navn her er et
|
||
navn frysen må bære. Pinnet av `tests/test_console_entry_points.py` mot den INSTALLERTE
|
||
distribusjonens metadata, ikke mot TOML-en: en `[project.scripts]`-linje som aldri er `uv sync`-et
|
||
er en påstand, ikke en kommando.
|
||
- Test: `uv run pytest`
|
||
- Lint: `uv run ruff check .` + `uv run ruff format .`
|
||
- Type: `uv run mypy src`
|
||
|
||
## Arbeidsflyt (invarianter)
|
||
- **Rent teknisk rammeverk:** deployer eier DPIA/ROS/behandlingsformål. Bygg IKKE compliance-funksjoner — kun tekniske forutsetninger (lokal-only, provenance, ingen stille egress) + disclaimer.
|
||
- **90%-prinsipp:** bygg den generiske kjernen + tydelige extension points; jakt IKKE de siste 10 %.
|
||
- **Deterministisk validator er obligatorisk og blokkerende** — aldri valgfri plugin.
|
||
- **Framework-nøytral kontekst-søm:** OKF-bundle-navigasjon (`okf.py`) og den delte
|
||
`shared/`-kjernen er ren stdlib — null `agent_framework`/`mcp`-import, så samme bundles
|
||
konsumeres uendret av begge stacker (D7-portabel). Håndhevet av
|
||
`tests/test_okf.py::test_okf_is_maf_free`; importér aldri MAF inn i kontekst-laget.
|
||
- **OKF-navigert bundle-kontekst (ikke stuffing):** på bundle-stien bygges agent-lese-konteksten
|
||
ved å NAVIGERE bundelen (`okf.bundle_context`: index + frontmatter + cross-links, progressiv
|
||
disclosure) — aldri keyword-chunk-stuffing (målbilde §2/§4). `type: verdict`-laget ekskluderes
|
||
fra denne konteksten: tidligere dommer når hypotese-prompten KUN via den gatede ExpeL-folden.
|
||
Load-bearing: `test_bundle_context_excludes_verdict_layer` + empty-store-kontrollen i
|
||
`test_step1_expel_loadbearing.py` (realiseringssignalet lekker aldri inn via kontekst).
|
||
- **Navigasjons-kontrakten er hierarkisk, og escape — ikke dybde — er forbudt** (`method-spec`
|
||
§3 Steg 1): `navigate_bundle` følger cross-links REKURSIVT, dybde-først i først-sett-rekkefølge;
|
||
ledende `/` betyr **bundle-rot** (aldri filsystem-absolutt), alt annet er relativt til den
|
||
LENKENDE filas katalog; dedup skjer på **resolvert** sti (så `./a.md` == `a.md`, og sykler
|
||
termineres). `safe_resolve` er den ENESTE inn-/ut-av-bundle-testen (fail-closed) — den erstattet
|
||
den pensjonerte «separator = utenfor bundelen»-heuristikken, som forvekslet dybde med escape.
|
||
Manglende `index.md` er feil KUN i bundle-rota (navigasjon følger lenker, aldri katalog-enumerering).
|
||
Rendering er FLAT uansett dybde; nestede `index.md` er navigasjon, ikke innhold. Gaten er
|
||
commons-eide nav-goldens (`shared/examples/nav-golden-*/expected-read-context.md`, byte-nivå
|
||
fasit): `test_nav_golden_hierarchy_*` (positiv) + `test_nav_golden_escape_*` (negativ — en gate
|
||
som bare kan bli grønn beviser ingenting).
|
||
**Et hopp er TOLERERT, men ikke lenger TAUST (21.08):** `_walk` registrerer hver lenke den ikke
|
||
fulgte på `Bundle.skipped` — hvilken fil lenken sto i, lenketeksten ORDRETT (operatøren redigerer
|
||
den teksten, ikke den resolverte stien), og hvilken av de TO grunnene som gjaldt: `outside-bundle`
|
||
(escape — ofte bevisst, en lenke til nabobasen) eller `missing` (inne i basen, ingen lesbar fil —
|
||
nesten alltid en skrivefeil). Den tredje grenen, `canonical in seen`, er DEDUP og registreres
|
||
ALDRI — den er korrekt navigasjon og dét som terminerer sykler; en implementasjon som logget hvert
|
||
`continue` ville rapportert en frisk base som halvlest. Toleransen er URØRT (§4 krever at det ikke
|
||
kastes) — dette er synlighet, ikke en ny nekt. **Feltet DEFAULTER til tom tuppel, og det er
|
||
MOTSATT av `cost_baseline_anchored`s «påkrevd uten default»:** en tom trace er et ærlig POSITIVT
|
||
utsagn («hver lenke ble fulgt», `external_calls`-presedensen), mens en manglende bool måtte påstå
|
||
noe om en hendelse og begge påstandene ville iblant vært usanne. Sporet forlater kjøringen på
|
||
`RunResult.skipped_links` (RUN-nivå — navigasjonen skjer ÉN gang per kjøring, før noe forslag
|
||
finnes) og `DryRunReport.skipped_links`, aldri på `ProvenanceStamp`, som beskriver gaten som dømte
|
||
ÉN kandidat. `run.skipped_links_notice` er ENESTE renderer, tar den alt oppløste tuppelen og
|
||
returnerer `None` når ingenting ble hoppet over (omisjon, aldri tom rad — `announce`-regelen);
|
||
reason-TOKENET printes rått, så det finnes ingen andre display-vokabular å drifte fra feltet.
|
||
Ingenting av dette når `bundle_context` (som bygges av `index_summary` + `context_files` alene) —
|
||
dét er hva som holder nav-goldenene byte-uendret, og `Bundle(` har fortsatt ÉN konstruksjons-sted
|
||
(`okf.py`, i `navigate_bundle`). Load-bearing MÅLT
|
||
(`tests/test_navigation_visibility_loadbearing.py`), åtte mutasjoner alle røde mot HELE suiten +
|
||
grønn kontroll 897/5: detach `missing`-registreringen (6 røde) · detach `outside-bundle` (2 røde) ·
|
||
kollaps de to grunnene til én (2 røde) · registrer dedup-grenen (1 rød) · renderer returnerer alltid
|
||
linja (3 røde — inkl. kontrollene, altså er omisjonen selv gatet) · detach dry-run-printen (1 rød) ·
|
||
detach full-run-printen (1 rød) · konstant tom trace ut av `run_project` (4 røde).
|
||
- **Kuraterte skrivere kan ikke forfalske ingest-stempelet** (`ingest-spec` §3): `write_concept_file`
|
||
er repoets ene authoring-primitiv som materialiserer en konseptfil fra CALLER-oppgitt frontmatter,
|
||
og avviser derfor det KOMPLETTE eierskaps-stempelet (`generated: true` + `ingest_manifest`) med
|
||
`IngestStampError` — mens hver halvdel alene er lovlig (kuratert innhold kan bære ett
|
||
provenance-felt). Validering, ALDRI reparasjon: ingenting skrives. Uten dette kunne en kuratert fil
|
||
bli stille slettet av en senere re-materialisering, som fjerner nøyaktig det som bærer stempelet.
|
||
**`generated`-verdien er FAIL-CLOSED på YAML-1.1-sannhetsformer, ikke bare literalen `"true"`**
|
||
(funn 21.08, økt 52): `_YAML_TRUE_LITERALS` (`{"true", "yes", "on"}`, case-insensitivt) er
|
||
ENESTE vokabular, målt mot PyYAML sin `safe_load`-resolver — bare `1`/bare `y`/`n` er BEVISST
|
||
UTELATT (resolves til int/streng, aldri bool, så en YAML-leser ville uansett ikke lest dem som
|
||
stempelet). Uten dette var sjekken inert kun i kraft av at pinnet `llm-ingestion-okf v0.3.2`
|
||
skriver strengen `"true"` — en fremtidig `uv sync` mot en skrivemåte som `yes`/`on` ville latt
|
||
vakten slutte å vokte uten én lokal diff. Load-bearing MÅLT
|
||
(`tests/test_ingest_stamp_fail_closed_loadbearing.py`), fire mutasjoner alle røde mot HELE
|
||
suiten: revert til literalen `"true"` (2 røde — de nye sannhetsformene alene) · over-widen til å
|
||
inkludere `1`/`y` (1 rød) · `and`→`or` (4 røde, halv-stempel-lovligheten brutt) · detach gaten
|
||
helt (4 røde).
|
||
- **`IngestError` må overleve anyio-task-gruppene (kø-(x), 2026-08-03):** `stdio_client` og
|
||
`ClientSession` er hver sin task group, og anyio pakker ALT som forlater en av dem i en
|
||
`BaseExceptionGroup`. Derfor nådde `stdio_call_tool`s egne feil (`mcp_tool_error`,
|
||
`mcp_non_text_content`) kalleren som en exception group — aldri som `IngestError`, som er typen
|
||
hele Door A fanger og switcher på via `code`. `_unwrap_ingest_error` pakker ut og re-raiser den
|
||
eide feilen; alt annet re-raises URØRT (innsnevring, aldri blanket re-raise). Duck-typet på
|
||
`.exceptions`, fordi `except*`/`ExceptionGroup` er 3.11+ og repoet er `>=3.10`. **Ingen
|
||
canned-tool-test kunne fanget dette** — de går aldri inn i en task group; defekten dukket opp
|
||
første gang koden faktisk ble kjørt. En MCP-server på ingest-stien må eksponere en
|
||
**null-argument-tool** (URL-en bærer begge koordinatene, tool kalles med `{}`), så
|
||
`datasource.build_mcp_server` kan IKKE serve den — `retrieve_cost_docs(query)` har et påkrevd
|
||
argument og returnerer et error-result. De to er separate sømmer med vilje. Load-bearing MÅLT
|
||
(`tests/test_ingest_golden_mcp.py`), fem mutasjoner alle røde: detach unwrappingen · detach
|
||
`initialize()` · gjør feilkoden generisk · detach `isError`-grenen · endre ett byte av bodyen.
|
||
- **MCP-timeouten må komponeres MED anyios eget cancel scope, ikke `asyncio.wait_for` utenfra
|
||
(kø-(z), 2026-08-03):** STATE-premisset ("en utypet `TimeoutError` re-raises urørt") var FEIL —
|
||
målt mot en EKTE hengende server ga `asyncio.wait_for(run(), timeout=...)` aldri en
|
||
`TimeoutError` i det hele tatt; den kansellerer `run()` UTENFRA strukturen anyio selv eier
|
||
(`stdio_client`/`ClientSession`), og de to kansellerings-mekanismene komponerer ikke — målt
|
||
utfall var en `anyio.BrokenResourceError` inni en `BaseExceptionGroup` (en bakgrunns-reader-task
|
||
mistet skrive-enden midt i nedrigging). Fiksen er `anyio.fail_after(timeout_seconds)` NESTET
|
||
INNI begge task-gruppene, der anyio rigger ned sin egen struktur rent og raiser en ren
|
||
`TimeoutError`. **Innsnevringen dekker IKKE bare typen:** builtin `TimeoutError` er også
|
||
`socket.timeout` (≥3.10) og `asyncio.TimeoutError` (≥3.11), så et ubetinget `except TimeoutError`
|
||
ville mislabelt en HVILKEN SOM HELST `TimeoutError` som `mcp_timeout` — reviewet FØR commit
|
||
(advisor) fant nøyaktig dette. Retteslen er `anyio.CancelScope.cancelled_caught`: kun scopet som
|
||
faktisk traff SIN EGEN deadline tjener `mcp_timeout`-koden, ellers re-raises urørt (speiler
|
||
`_unwrap_ingest_error`s eierskaps-regel). **Ingen levende utløser finnes i dag** for en
|
||
"fremmed" `TimeoutError` på denne stien — MÅLT: MCPs eget per-request read-timeout
|
||
(`ClientSession.send_request`) konverterer sin `anyio.fail_after` til `McpError` FØR den når oss,
|
||
og en tool som raiser `TimeoutError` server-side blir et ordinært `isError`-resultat (samme
|
||
som enhver annen tool-exception) — begge verifisert empirisk, ikke antatt. Diskriminatoren er
|
||
likevel pinned med en syntetisk test (raiser fra `StdioServerParameters`-konstruksjon, inni
|
||
fail_after-scopet men FØR noen task group), fordi defektklassen ellers ikke har en nåbar sti å
|
||
bevise den mot. Load-bearing MÅLT (`tests/test_ingest_golden_mcp.py`) mot HELE 625-suiten, fire
|
||
mutasjoner alle røde: detach hele oversettelsen · revert til `asyncio.wait_for` · relabel koden ·
|
||
detach `cancelled_caught`-gaten (behold kun scope-presence). `anyio` promotert fra transitiv
|
||
(via `mcp`) til deklarert direkte dep (`pyproject.toml`) — modulen importerer den nå direkte.
|
||
- **Door A-innholdsgaten kan IKKE bo i `materialize` — den bor rundt den (P2/S1.b, 2026-08-09):**
|
||
`materialize` er en REN delegasjon til det pinnede `llm_ingestion_okf` v0.3.2s
|
||
`materialize_bundle`, som stager i minnet og utfører sin EGEN disk-fase; **det finnes ingen
|
||
callback mellom de to**, så en gate plassert «i skrivepunktet» kunne bare kjørt ETTER at bytene
|
||
hadde landet — en opprydding, ikke en gate (planens premiss, felt ved måling FØR bygging).
|
||
`materialize_gated` er derfor: **kopier bundelen → materialiser inn i kopien → skann det som ble
|
||
generert → publiser eller forkast.** **Kopien er BÆRENDE:** bibliotekets §3 eierskaps-skann,
|
||
kollisjons-gaten mot kuratert innhold og §6 index-merge leser alle den EKSISTERENDE bundelen —
|
||
staging i en tom katalog mister alle tre og publiserer en bundle uten kuraterte naboer og deres
|
||
index-lenker (datatap forkledd som sikkerhetsfiks; MÅLT av kun ÉN test, 809 andre merket
|
||
ingenting). `materialize` forblir UGATET med vilje — fire golden-suiter pinner bytene, og en
|
||
kaller som vil ha gaten ber om den ved navn. **Utfall per BUNDLE, diagnostikk per DOKUMENT:**
|
||
delvis publisering ville etterlatt bundle + index som svarer til INTET manifest, men
|
||
`import_bundle` itererer forbi første avvisning så hvert funn rapporteres. **Trust følger ORIGIN,
|
||
aldri channel** (`Origin.EXTERNAL`/`Channel.AUTOMATIC` = UNTRUSTED) — ikke et av guardens to
|
||
`Policy`-preset: `PRESET_USER_UPLOAD` bærer `quarantine_default=True` som Door A ikke har.
|
||
**Den laveste dispositionen er `warn`, ikke `allow`** (`warn < quarantine_review < fail_secure`;
|
||
`allow` finnes ikke) — en gate skrevet mot `== allow` ville avvist hvert dokument noensinne.
|
||
**Funnene til `log.md` (OKF §7), ALDRI konsept-frontmatter** — der ville de brutt fire goldener.
|
||
Guarden shipper ingen `py.typed`: mypy-override ALENE gjør sømmen type-BLIND, så `_stamp_line` +
|
||
koersering stopper `Any` ved grensen. Load-bearing MÅLT
|
||
(`tests/test_ingest_content_gate_loadbearing.py`), fem mutasjoner alle røde + grønn kontroll:
|
||
detach gaten · la den fyre ETTER publisering · `Origin.INTERNAL` · tom staging-katalog ·
|
||
rapporter kun første avvisning. **Målingen felte en VAKUØS test først:** en hard injeksjon
|
||
scorer `fail_secure` under BEGGE tierene, så `Origin.INTERNAL`-mutasjonen lot alle tre
|
||
avvisningstestene stå grønne — beslutningen så dekket ut uten å være testet. Båndet der tieren
|
||
faktisk avgjør er høy-entropi-innhold (`quarantine_review` vs `warn`), og testen ble skrevet mot
|
||
nøyaktig det.
|
||
- **`shared/` leses som PAKKEDE DATA, med arbeidstreet som overstyring (Fase 4a):** wheelen bærer
|
||
en byte-identisk speiling av hele `shared/`-treet under `portfolio_optimiser/_shared/`
|
||
(hatchling force-include i `pyproject.toml`), og `shared_root()` løser ved KALL-tid i fast
|
||
rekkefølge: `PORTFOLIO_SHARED_ROOT` → arbeidstreets `shared/` når det finnes → pakket kopi.
|
||
**Arbeidstreet er autoritativt i en checkout** — det er dét som holder pull-only-subtree-
|
||
kontrakten og de byte-eksakte goldenene urørt (målt: goldens shasum-identiske før/etter, og
|
||
`shared/` selv urørt). Den pakkede kopien er dét som gjør wheel og container mulig uten klone
|
||
(målt før: 1.0.0-wheelen bar 58 filer, null under `shared/`; etter: 122, hvorav 64 under
|
||
`_shared/`, og sdist→wheel-kjeden bærer treet). Speilingen er ALDRI en redigert derivat —
|
||
byte-identitet er egenskapen som lar commons-goldenene fortsatt gate den pakkede kopien.
|
||
Load-bearing MÅLT (`tests/test_shared_packaged_data_loadbearing.py`, ekte `uv build` i
|
||
fixturen — pakkekonfigen er selv en søm), tre mutasjoner alle røde mot hele suiten: detach
|
||
fallbacken (1 rød) · detach force-include (3 røde) · snu rekkefølgen (1 rød — ordnings-testen
|
||
var grønn før fiksen; dens kontroll på at pakket kopi FINNES er det som gjør flippen målbar).
|
||
- **AZURE-profilen leser MILJØET sitt ved kall-tid, ikke operatørens laptop (Fase 4b):** endepunktet
|
||
løses som første IKKE-TOMME av `_ENDPOINT_ENVS` — vårt eget `PORTFOLIO_FOUNDRY_PROJECT_ENDPOINT`
|
||
FØRST, deretter Foundrys injiserte `FOUNDRY_PROJECT_ENDPOINT`. **Vårt vinner** (det er dét enhver
|
||
doc, recipe og test setter, så en eksport av det er en bevisst handling; en plattformverdi som
|
||
stille overstyrte den ville vært uforklarlig utenfra), og fallbacken er dét som lar samme image
|
||
kjøre hostet uten ekstra wiring. **Presedensen gjelder VERDIER, ikke deklarasjoner** — et
|
||
eksportert-men-tomt eget navn faller igjennom i stedet for å skygge et ekte injisert inn i en
|
||
fail-fast. Feilmeldingen navngir BEGGE: operatøren i en container og operatøren på en laptop
|
||
leter etter hver sin variabel. Credential velges av samme miljø: `AzureCliCredential` lokalt
|
||
(konstruksjon henter INGEN token — `az login` er operatørens manuelle steg),
|
||
`ManagedIdentityCredential` når `FOUNDRY_HOSTING_ENVIRONMENT` er satt, fordi containeren ikke har
|
||
noen Azure CLI og plattformen mynter den en egen Entra-identitet ved deploy. **Ikke
|
||
`DefaultAzureCredential`:** Learns egen MAF-veiledning sier «prefer a specific credential such as
|
||
`ManagedIdentityCredential` to avoid unintended credential probing» — probing ville vandret en
|
||
kjede som ikke KAN lykkes der, og gjort en konfigfeil om til en treg en. Markøren leses på
|
||
**truthiness, ikke presence**: en eksportert tom verdi er et shell-uhell, ikke et hosting-signal.
|
||
Klienten eksponerer INGEN credential-attributt (målt), så testene observerer via en
|
||
`FoundryChatClient`-recorder — med én UPATCHET arm, ellers ville de kun bevist at vi sender
|
||
*noe* som heter `credential`. Load-bearing MÅLT
|
||
(`tests/test_hosted_backend_loadbearing.py`), fire mutasjoner alle røde mot hele suiten + grønn
|
||
kontroll: detach credential-valget · presence i stedet for truthiness · detach fallbacken · snu
|
||
presedensen. **Fail-fast-testen ble skrevet VAKUØS først** (repoets 08-09-klasse):
|
||
`PORTFOLIO_FOUNDRY_PROJECT_ENDPOINT` INNEHOLDER `FOUNDRY_PROJECT_ENDPOINT`, så asserten på det
|
||
injiserte navnet var oppfylt av vårt eget; den fjerner nå vårt navn før den sjekker.
|
||
- **Hostet inngang er en WRAPPER rundt `run_project` på ÉN asyncio-løkke (Fase 4d):** `main.py` →
|
||
`hosting.py` serverer hosting-kontrakten (port 8088/`PORT` på truthiness, `GET /readiness`,
|
||
`POST /invocations`, SIGTERM → exit 0) med stdlib asyncio — ALDRI `as_agent()` (validator,
|
||
baseline-forankring, checker-gate og ledger ligger UTENFOR grafen, spike §5) og ALDRI tråder
|
||
(NG1-guarden: `http.server`s trådvariant ville lagt samtidige kjøringer på OS-tråder der
|
||
S3.3-resonnementet ikke holder; samtidige invocations interleaver som koroutiner — samme modell
|
||
som `run_portfolio`s bølger, og `/readiness` svarer mens en kjøring venter på modell-I/O, målt).
|
||
**Formen er MÅLT, ikke valgt:** hosting-pakkas `InvocationsHostServer` finnes kun i bygg som
|
||
krever core>=1.13.0 (treet låser 1.9.0; eneste 1.9-kompatible bygg er en forlatt alfa med defekt
|
||
metadata — importerer `mcp` udeklarert), og et gjenbrukt bygget workflow er SINGLE-USE på 1.9.0
|
||
(målt kall-serie [2, 0, 0] — rundetaket persisterer i objektet, så gjenbruk gir TOMME kjøringer;
|
||
ferskt objekt per kall er ren kontroll). Payloaden whitelistes på `run_project`s signatur —
|
||
ukjente felt NEKTES ved navn (400), aldri stille droppet (valg-doc §0-fella anvendt på vår egen
|
||
flate); `profile` defaulter til `azure` KUN her (containeren har ingen lokal endpoint;
|
||
`run_project`s egen default forblir LOCAL). Feilmapping ærlig: `ValueError` (pydantic-kontrakter
|
||
subklasser den) → 400, `BudgetExceeded` → 429 (EGEN rad under, 14.08), alt annet → 500
|
||
`{error_type, error}` (speiler `RunFailure`), og en
|
||
`Rejection` er en VELLYKKET kjøring → 200 — det negative utfallet tilhører payloaden, aldri
|
||
transporten. `outbox.outcome_payload` er den ENE kopien av validated/rejected-forgreningen
|
||
(delt av fil-skriveren og HTTP-responsen — to kopier drifter, kø-(p)-regelen). **Container-innpakningen
|
||
(`Dockerfile`/`azure.yaml`) ER FJERNET 14.08** — se python-only-invarianten under; resten av
|
||
denne raden står, for `main.py` startes nå direkte (`python main.py`). Load-bearing MÅLT (`tests/test_hosting_loadbearing.py`), seks mutasjoner alle
|
||
røde mot hele suiten på riktig test: detach felt-mappingen · dropp ukjente felt stille · flipp
|
||
400/500 · detach azure-defaulten · detach SIGTERM-handleren · detach main.py-shimen (de to
|
||
siste fanges KUN av subprosess-testen — P4-presedensen). Chunked request-bodies støttes ikke, og under CPU-bundne strekk (CBC-solven)
|
||
står readiness — uttalt, ikke skjult.
|
||
- **Whitelisten må komponere med den EKTE `run_project`, og artefaktene gates som RÅ TEKST
|
||
(Fase 4e):** alle 4d-testene ga `invoke` en stand-in som sluker `**kwargs`, så whitelisten kunne
|
||
navngi et felt `run_project` ikke tar — eller sende samme argument to ganger — uten at én test
|
||
merket det, mens en levende container svarte 500. **Sømmen er `run._default_factory`, ikke
|
||
payloaden:** `client_factory` NEKTES av whitelisten med vilje (en kaller av en hostet agent skal
|
||
aldri velge serverens modellklient), så å patche factory-defaulten er eneste injeksjonspunkt
|
||
flaten etterlater (samme argument `test_run_cli_loadbearing` gjør for `main()`). Testen sender
|
||
HVERT whitelistet felt og asserterer dekningen mot `_ALLOWED_FIELDS`, så et felt lagt til senere
|
||
ikke kan gli forbi uøvet. Profilen er **LOCAL, ikke den hostede defaulten**: AZURE-armen slår opp
|
||
et Foundry-deployment-navn i modell-mappet FØR noen klient bygges (`run.py` stempler provenance
|
||
med det), så den kan ikke fullføre offline — **containeren trenger altså `PORTFOLIO_MODEL_MAP`
|
||
eller et utfylt `data/model_map.json`, ikke bare et endepunkt** (målt her, ikke antatt).
|
||
**Artefakt-halvdelen av denne raden er PENSJONERT 14.08** sammen med `Dockerfile`/`azure.yaml`
|
||
(rå-tekst-gaten pinnet `--platform linux/amd64` + ÉN kopi av startkommandoen; to av radens fem
|
||
mutasjoner traff nettopp den). Whitelist-halvdelen står URØRT. Load-bearing MÅLT
|
||
(`tests/test_hosting_loadbearing.py`), de tre gjenværende mutasjonene alle røde på riktig test og
|
||
på INGEN annen: send `project_id` to ganger · whitelist et felt `run_project` ikke tar · fjern
|
||
`bundle_dir` fra whitelisten.
|
||
- **Et tak som fyrer er IKKE en krasj — `BudgetExceeded` får sin EGEN kanal (429), og trippelen
|
||
bæres som STRUKTUR (1b-køen, 14.08):** prosjektets første levende kjøring døde på
|
||
`rounds limit=12 observed=13`, og den hostede flaten svarte `500 {error_type, error}` — altså
|
||
nøyaktig det samme den sier når modell-endepunktet faller. **Beslutningen er S3.4-invarianten
|
||
anvendt på transporten:** `budget_stop` ble holdt UTENFOR `stop_reason` fordi de to stoppene
|
||
betyr motsatte ting, og å svare ressurs-utmattelse på krasj-kanalen gjør «det gikk ikke»
|
||
uleselig på nøyaktig samme måte. **IKKE 200, og det er dét som skiller den fra `Rejection`:**
|
||
en `Rejection` er en kjøring som KONKLUDERTE (og hører derfor i payloaden), mens et uttømt
|
||
budsjett produserte ingen `proposal` i det hele tatt — en 2xx ville latt en automatisk kaller
|
||
bokføre «analysert» for en kjøring som analyserte ingenting. **429 fordi betingelsen oppstår av
|
||
en TILDELING** (`max_rounds`/`max_tokens` er whitelistede request-felt, og å heve dem er
|
||
kallerens egen botemiddel), aldri av en serverfeil — derfor 4xx, ikke 5xx.
|
||
`kind`/`limit`/`observed` legges ut som felt, ALDRI `str(exc)` (kø-(y): de beskriver ÉN ledger,
|
||
og «hvilket tak bandt, og hvor langt forbi» er hele det operative spørsmålet); `error_type`
|
||
holdes UTE — den nøkkelen tilhører feilkanalen, og en kaller som switcher på dens
|
||
tilstedeværelse skal ikke finne den her. `budget_exhausted` er IKKE foldet inn i `outcome_type`,
|
||
og kunne ikke vært det: `outbox.outcome_payload` er den ENE kopien av den forgreningen og tar
|
||
`ValidatedProposal | Rejection`, som en uttømt kjøring ikke har noen av. **Ærlighets-grense,
|
||
uttalt:** ingen `Retry-After` — å vente endrer ingenting, botemiddelet er et større tak eller å
|
||
akseptere stoppet, og en header som lover tid ville vært en løgn. Load-bearing MÅLT
|
||
(`tests/test_hosting_loadbearing.py`), fem mutasjoner alle røde mot HELE suiten, hver med sin
|
||
egen signatur + grønn kontroll 867/4: detach armen (2 røde) · flat streng i stedet for struktur
|
||
(1 rød — struktur-testen ALENE, altså rir den ikke på status-asserten) · ekko `limit` som
|
||
`observed` (1 rød) · utvid armen til `Exception` (6 røde, inkl. 400-armen) · stemple
|
||
`error_type` på budsjett-kroppen (1 rød). **500-armens vitne ble byttet, ikke slettet:** den
|
||
eksisterende testen brukte `BudgetExceeded` som sin 500-prøve, så å bare legge til en ny arm
|
||
ville etterlatt krasj-kanalen uten vitne — den bærer nå en ekte ikke-budsjett-`RuntimeError`,
|
||
og er dét som holder den nye armen SMAL.
|
||
- **Påstander flaten gjør om SEG SELV gates som rå tekst, linjeforankret (Fase 3, A5):** to påstander
|
||
bodde i prosa der ingen test kunne se dem, og begge drev. (1) `env.template` sa at credential
|
||
resolves via `DefaultAzureCredential` — den har ALDRI gjort det; gaten leser de klassene
|
||
`backends.py` faktisk konstruerer **fra selve tilordningslinja**, ikke fra modulen, fordi
|
||
kommentarene NAVNGIR `DefaultAzureCredential` fire ganger for å begrunne hvorfor den ikke brukes —
|
||
en fil-bred substring-gate ville vært rød på nøyaktig den prosaen den beskytter (repoets
|
||
08-09-klasse, fjerde gang). (2) README-ens wheel-filnavn bærer versjonen bygget stempler på fila,
|
||
så en versjonsbump ville stille etterlatt en publisert install-kommando som peker på en fil som
|
||
ikke finnes. **Hver positiv assert er paret med en KONTROLL** på at det søkes etter noe som finnes
|
||
— en ekstraktor som stille finner null lager en gate som bare kan bli grønn. Load-bearing MÅLT
|
||
(`tests/test_public_surface_claims_loadbearing.py`) mot HELE suiten, begge røde på riktig test og
|
||
på INGEN annen: gjeninnfør credential-påstanden (2 røde, 844 grønne) · la wheel-filnavnet drifte
|
||
(1 rød, 845 grønne). Bumpen selv var den tredje målingen — `pyproject` 1.0.0 → 1.1.0 gjorde
|
||
README-gaten rød alene, FØR README ble rettet. **`repo-standard`-gaten kan IKKE verifisere denne
|
||
fasen:** den var OK/20 sjekker før arbeidet startet, og `RELEASE-STALE` er strukturelt blind for
|
||
repo med null utgivelser (org-ops hovedbok #18). Bevisene er Forgejo-APIet, filinnholdet og
|
||
ren-klon-kjøringen.
|
||
- **GOVERNANCE er en LENKE, aldri en kopi (org-ops D11):** én kanonisk `GOVERNANCE.md` bor i
|
||
`repo-standard` og hvert repo lenker den fra README. Å skrive vår egen ville gjort oss til kopi
|
||
nr. 12 av en fil D11-bølgen holder på å rydde vekk. Bus-faktor 1 står uttalt i den kanoniske
|
||
teksten, ikke i vår.
|
||
- **Stoppkriterier + budsjett-tak påkrevd ved oppstart** (fail-fast, aldri ubegrenset loop).
|
||
- **Group Chat maker-checker** som debatt-default (IKKE Magentic, som er eksperimentell).
|
||
- **To falsifiserere, samme kandidat (Steg 3/4, målbilde §2/§6):** den deterministiske validatoren
|
||
gater *tallene* (blokkerende), checkeren gater *resonnementet*. Checkeren avslutter turen med en
|
||
`VERDICT: APPROVE` / `VERDICT: REJECT — <grunn>`-linje; et eksplisitt avslag blokkerer et ellers
|
||
validert forslag (`run_project` overflater begge debatt-deltakere via `output_from=agents` og
|
||
overstyrer utfallet til en checker-kilde-`Rejection`). Gaten er opt-in-reject (fail-open ved
|
||
manglende markør), og `provenance.validator_decision` forblir ærlig — den speiler KUN validatoren,
|
||
aldri checkeren (de to falsifisererne blandes aldri). Load-bearing:
|
||
`tests/test_checker_gate_loadbearing.py` blir rød ved BEGGE detach-punkt (revert `output_from`,
|
||
eller fjern override). Checkeren «må faktisk gate, ELLER vi slutter å kalle det maker-checker».
|
||
- **Informert forbedring, bundet (Steg 5, målbilde §5/§7):** `generate_via_llm`s ytre
|
||
`max_attempts`-løkke er ikke lenger blind — validatorens *forrige* `Rejection.reason` mates inn i
|
||
neste forsøks prompt (`_build_messages(prior_rejection=...)`), så proposeren korrigerer i stedet
|
||
for å gjenta. Kun den mest-nylige falsifiseringen (`last`, ikke akkumulert), kun grunnen (aldri
|
||
forrige proposal-JSON), under EKSISTERENDE tak (`meter.tick_round` + `max_attempts` — ingen ny
|
||
løkke; «forbedre til god nok» uten tak er forbudt). Eneste *per-forsøk*-falsifiserer her er
|
||
validatoren; å seede generering med checker-*kritikken* er run-nivå og separat scoped (IKKE bygget
|
||
her) — så koden påstår ikke mer enn den gjør. Load-bearing:
|
||
`tests/test_step5_refine_loadbearing.py` blir rød når reason-injeksjonen detaches (utfallet
|
||
flipper aldri + reason-verbatim-asserten faller); kontrollen beviser at løkka forblir bundet.
|
||
- **Falsifiserings-historikken FORLATER generate-løkka som typet returverdi (Steg 5, del 2):**
|
||
`generate_via_llm` returnerer `GenerationResult(outcome, refinements)` — ikke lenger bare
|
||
`ValidatedProposal | Rejection`. Før dette forbrukte løkka hver `Rejection` internt (`last`) og
|
||
DROPPET den, så Steg 5 var det ene av åtte steg uten observerbart utfall. **Returverdi, ikke
|
||
out-parameter/callback:** en returnert verdi kan ikke bli stille tapt av en kaller som glemmer å
|
||
sende en samler, og mypy tvinger hvert kallsted til å ta stilling. **`refinements` bærer KUN
|
||
avvisninger som faktisk ble matet tilbake** i et senere forsøks prompt — ved uttømt budsjett ER
|
||
den siste avvisningen `outcome`, den informerte ingenting, og å telle den med ville vært
|
||
dobbeltføring (en «samle alt»-implementasjon består den positive testen og faller på kontrollen).
|
||
Taket er URØRT: `max_attempts` + `meter.tick_round` står, og `last` driver fortsatt prompten alene
|
||
(prompt-veksten er uendret). `run.py` akkumulerer på tvers av `_evaluate`-kallene, så
|
||
`_evaluate_mandate` er urørt; `RunResult.refinements` er defaultet (`coverage`-presedensen), og
|
||
med mandat er den KONKATENERT på tvers av tiltak, ikke nøklet per tiltak (uttalt ærlighets-grense).
|
||
`scripted_factory` tar nå `str | reply_selector` per rolle, så simuleringens proposer korrigerer
|
||
seg innholds-nøklet uten en andre scriptet kropp. Load-bearing MÅLT
|
||
(`tests/test_step5_history_loadbearing.py`), fire mutasjoner: detach returneringen · samle-alt ·
|
||
detach run-wiringen · reverter simuleringens proposer til konstant svar.
|
||
- **Lang/async fil-løkke (Steg 7, målbilde §3/§7):** `run_project(verdict_dir=...)` er den lange
|
||
tilbakemeldings-tidsskalaen — en ekspert/persona dropper en verdict-fil (vanlig JSON, RAW-laget
|
||
per §10 R2) i en inbox-mappe ETTER en kjøring, og en separat, senere kjøring `load_verdicts_from_dir`
|
||
→ `store.add` **merger** den inn FØR Steg-1-folden (ingen endring i folden), så dommen når neste
|
||
hypotese. **Rolledeling (§3, ufravikelig):** systemet LESER mappa; eksperten/personaen SKRIVER den
|
||
— `run_project` persisterer ALDRI sin egen fangede dom tilbake (det er outbox/Steg 8). Merge, aldri
|
||
erstatt (`run_portfolio`-tråding intakt); tolerant last (manglende mappe / fremmede / halvskrevne
|
||
filer hoppes over, ikke raises — RAW-lag, kontrast `okf.load_ir_projection`s fail-fast); `id` leses
|
||
verbatim, re-mintes aldri. `write_verdict` er den offentlige authoring-primitiven (persona/test +
|
||
framtidig Steg 8), men wires IKKE inn i `run_project`. Load-bearing:
|
||
`tests/test_step7_async_loop_loadbearing.py` — en dom droppet etter Run A MÅ nå Run B's prompt
|
||
(Run B bruker FERSK store → overføringen er fil-løkka, ikke in-memory-carryover); tom-inbox-kontroll
|
||
beviser kausalitet. Markør = realiseringsverdi som finnes ingen steder i bundelen (ikke frøets 0.82).
|
||
- **Gated wiki-promotering (Steg 8, målbilde §3/§6/§7):** når en ekspert/persona GODKJENNER et
|
||
utfall, løfter `verdicts.promote_verdict` det fra RAW output-laget inn i kontekst-laget (OKF-bundelen)
|
||
som en `type: verdict`-konseptfil, navigerbar av neste kjørings `seed_store_from_bundle`. **Gaten er
|
||
fail-closed:** en ikke-godkjent dom (`decision ∉ {approved, approved_with_adjustment}`) raiser
|
||
`PromotionRefused` og skriver/linker INGENTING — kun menneske/persona-godkjent kunnskap når wikien,
|
||
aldri rå agent-output (selv-forurensning). Provenance-stemplet (hvem/eksperiment/når; `timestamp` er
|
||
påkrevd keyword, ingen wall-clock-default → deterministisk). **OKF-skriveren bor i `okf.py` og er ren
|
||
stdlib** (D7-portabel, MAF-fri — håndhevet av `test_okf_is_maf_free`); navigasjon følger KUN
|
||
index-cross-links, så `promote_verdict` linker filen i `index.md` via en NØYTRAL label (ellers lekker
|
||
signalet inn i `index_summary`→`bundle_context` utenom gaten). **R4 = valgfri+gated:** `promote_verdict`
|
||
er en offentlig opt-in-primitiv, wires IKKE inn i `run_project` (speiler `write_verdict` — systemet
|
||
leser; gaten/personaen promoterer). Ærlighets-grenser: promotert fil er MINIMAL (læringssignal kun som
|
||
`description`/body-prosa, reproduserer ikke seedens strukturerte `realization_rate` o.l.); id =
|
||
læringsnøkkel, så to godkjenninger om samme kandidat deler filnavn (last-write-wins, som `write_verdict`)
|
||
— wikien vokser én kuratert fil per distinkt kandidat, ikke per dom-hendelse. Load-bearing-trio
|
||
(`tests/test_step8_promotion_loadbearing.py`): gaten avviser ikke-godkjent dom (RØD uten gate); godkjent
|
||
dom er navigerbar (RØD når `link_in_index` detaches); promotert signal holdes ute av `bundle_context`
|
||
(RØD når en beskrivende index-label lekker det inn). Index-RMW er ikke-atomisk (enprosess-MVP).
|
||
- **En dom nøkles på SIN kandidat, ikke bundelens ene IR-projeksjon (S3.2):** `seed_store_from_bundle`
|
||
leser hver `type: verdict`-fils EGNE strukturelle felt fra frontmatter (`affected_codes` /
|
||
`measure_type` / `claimed_saving_nok`); mangler de, faller nøklingen tilbake til
|
||
`bundle_candidate_features` — så hver pre-S3.2-seed står uendret (fallbacken er BÆRENDE: fjernes
|
||
den, brekker step1-suiten ved collection). Uten dette kollapset en bundle med dommer om flere
|
||
kandidater dem på ÉN nøkkel, og en dom om kandidat B scoret perfekt strukturell match mot
|
||
kandidat As query. **ALLE TRE felt eller ingen:** en delvis erklæring raiser
|
||
`VerdictFrontmatterError` i stedet for å slås sammen med bundle-kandidaten — sammenslåingen ville
|
||
myntet en nøkkel som tilhører INGEN av kandidatene. Validering, ALDRI reparasjon (speiler
|
||
`write_concept_file`); den tolerante hopp-over-regelen hører til RAW-innboks-laget.
|
||
`claimed_saving_nok` parses med `json.loads` — SAMME literal-regel IR-projeksjonen gikk gjennom —
|
||
og skrives tilbake som `str()` av råverdien, fordi `_mint_id` hasher den (`30000` ≠ `30000.0`; en
|
||
normaliserende skriver ville splittet én kandidats signal på to id-er). `promote_verdict` skriver
|
||
de tre feltene, så en promotert dom ikke utgir seg for målbundelens kandidat; nøkkelen er
|
||
signal-fri, så Steg-8s no-leak-egenskap står. **Semantikken er bestemt HER** — commons' seeding-regel
|
||
(`method-spec` §3 Steg 1) hadde ikke kommet; D7-speiling forblir ÅPEN. Load-bearing MÅLT
|
||
(`tests/test_step32_multicandidate_loadbearing.py` + `test_step8_promotion_loadbearing.py`), fem
|
||
mutasjoner alle røde: detach per-dom-nøklingen · detach feltene `promote_verdict` skriver · gjør en
|
||
delvis/uparsebar nøkkel tolerant · normaliser magnituden ved skriving · fjern fallbacken (kontroll).
|
||
- **Den deterministiske gaten er FORANKRET i prosjektets faktiske kostbaseline (S4.0, F3/F8):** før
|
||
S4.0 resonnerte HVER stage kun om tall forslaget selv oppga, så en internt konsistent hallusinasjon
|
||
klarerte hele gaten. `validate_proposal(..., baseline=...)` avstemmer nå hvert `affected_item` mot
|
||
`CostBaseline` (`ir.py`) i en **stage 0 — FØR løseren** (billigst, og den eneste som skiller en
|
||
oppdiktet linje fra en ekte; å bruke en CBC-solve på tall som ikke tilhører prosjektet er arbeid på
|
||
et krav som uansett ikke kan valideres). To uavhengige avvisninger: ukjent kostkode, og ekte kode
|
||
med `quantity`/`unit_cost` utenfor `tolerance` (default 5 %, **konfig**) relativt til BASELINE-verdien.
|
||
Validering, ALDRI reparasjon — forslaget avvises, aldri stilltiende korrigert til baselinen.
|
||
**Argumentet er VALGFRITT** (`None` = pre-S4.0-oppførsel), men begge run-stier SETTER det: road-stien
|
||
fra `project.cost_items` (alltid — estimatet ER prosjektet), bundle-stien KUN når bundelen shipper
|
||
`cost-baseline.json` (`load_optional_cost_baseline`) — en pre-amendment-bundle er legitimt
|
||
uforankret, og det er dét som holder commons-goldenene byte-identiske. **Toleransen stopper ved
|
||
fravær:** en baseline som FINNES men er malformed raiser på BEGGE loaderne (å lese korrupt som
|
||
«ingen baseline» ville gitt en uforankret gate i forkledning — samme resonnement som `read_spend`).
|
||
**F8:** metode-cap-en slås opp i `METHOD_CAPS`-registeret (måletype→brøk, injiserbart), ikke mot
|
||
`energy_efficiency`-literalen — en andre metode er nå data, ikke en redigering av validatoren.
|
||
Format- og toleranse-semantikken er bestemt LOKALT (commons-amendmentet D-A pkt. 2 kom aldri, som i
|
||
S3.2); **D7-speiling ÅPEN.** Load-bearing MÅLT (`tests/test_s40_cost_baseline_loadbearing.py`), seks
|
||
mutasjoner alle røde: detach avstemmings-stagen · detach magnitude-toleransen · detach road-wiringen ·
|
||
detach bundle-wiringen · ignorer det injiserte cap-registeret · gjør den valgfrie loaderen tolerant.
|
||
**En UFORANKRET kjøring sier det nå — og BEGGE utsagn stammer fra kjøringens ENE oppslag, aldri
|
||
en andre lesing av bundelen (21.08):** `ProvenanceStamp.cost_baseline_anchored` er PÅKREVD uten
|
||
default (begge defaults lyver: `True` lar en glemsom konstruktør påstå en ankring som ikke skjedde,
|
||
`False` underrapporterer en ekte — en binær kjensgjerning om en falsifiserer har ingen ærlig
|
||
default), og `DryRunReport` bærer det samme fordi en dry-run stopper før noe stempel finnes.
|
||
`run.cost_baseline_notice(anchored)` er ENESTE renderer, tar den alt oppløste BOOLEANEN, og
|
||
returnerer `None` når kjøringen ER forankret — omisjon, aldri en tom rad (`announce`-regelen).
|
||
**IKKE foldet inn i `mandate.announce`, og det er en MÅLING:** den fyrer kun med `--mandate`, så
|
||
nettopp de bare bundle-dry-runsene defekten ble målt på ville fortsatt sagt ingenting — og den
|
||
renderes FØR `run_project`, altså før noen har oppløst baselinen. Utboksen trengte ingen endring
|
||
(`write_proposal` dumper hele stempelet). Ankeringen forblir VALGFRI: dette er synlighet, ikke en
|
||
ny nekt, og golden-transkriptet er byte-uendret fordi demoen kjører en base som HAR fila.
|
||
Portefølje-armen er DEFENSIV og uttalt (ingen referanse-prosjekt setter `bundle_dir`, så den er
|
||
unåbar i dag — `budget_stop`-presedensen; testen driver en crafted `PortfolioResult`). Load-bearing
|
||
MÅLT (`tests/test_baseline_visibility_loadbearing.py`), seks mutasjoner alle røde mot HELE suiten +
|
||
grønn kontroll 885/5: konstant stamp-wiring (3 røde) · konstant dry-run-wiring (1 rød) · detach
|
||
dry-run-printen (1 rød) · renderer returnerer alltid linja (2 røde — inkl. den forankrede
|
||
kontrollen, altså er omisjonen selv gatet) · detach full-run-printen (1 rød) · detach
|
||
portefølje-printen (1 rød). Det PÅKREVDE feltet tvang fem eksisterende test-konstruktører til å ta
|
||
stilling — det er egenskapen, ikke friksjonen.
|
||
- **Globalt token-tak håndheves FØR kall, aldri bare etterpå (S3.4, F10):** `PortfolioBudget` +
|
||
`PortfolioMeter` er ÉN ledger over hele porteføljepasset (og — seedet av `read_spend` — på tvers
|
||
av pass), mens per-run `Budget`/`TokenMeter` er uendret. Taket har tre tenner, med hver sin jobb:
|
||
(1) **oppstartsnekt** — en rest som ikke kan finansiere én kjøring raiser `BudgetRefused` FØR noe
|
||
lastes (et pass som har råd til null prosjekter er en caller-feil, ikke et resultat);
|
||
(2) **wave-assembly** — et prosjekt som ikke kan finansieres blir ALDRI STARTET, og passet stopper
|
||
strukturert (`budget_stop` + `stopped_early`, fullførte runs bevart). Aldri-startet er poenget:
|
||
et ufinansiert prosjekt som bare avbrytes har allerede kostet kall. Fordi hele bølgen sjekkes mot
|
||
SAMME før-bølge-rest, **reserverer** admission hver members krav — ellers overforplikter en bølge
|
||
av k taket med inntil k kjøringer; (3) **pre-call-guard** i `BudgetMiddleware` — et kall resten
|
||
ikke kan betale for NEKTES i stedet for å gjøres (post-charge-sjekken består: ekte usage kjennes
|
||
først etterpå, så guarden stopper NESTE kall, aldri det som er i lufta). `budget_stop` er et EGET
|
||
felt, aldri `stop_reason`: et mål-stopp er suksess, dette er ressurs-utmattelse — å slå dem sammen
|
||
ville gjort «vi stoppet» uleselig. `record`/`check` er SPLITTET i `PortfolioMeter` fordi tokens
|
||
leverandøren allerede har fakturert må nå ledgeren selv når samme charge bryter run-taket.
|
||
Spend-fila er vår EGEN regnskapstilstand: `read_spend` raiser på korrupt innhold (kontrast det
|
||
tolerante RAW-inbox-laget — å lese korrupt som null ville gitt tilbake et allerede brukt budsjett),
|
||
og `write_spend` tar et PÅKREVD `stamp` uten wall-clock-default (byte-determinisme, speiler
|
||
`promote_verdict`). `portfolio_meter` og `meter_factory` er gjensidig utelukkende — en
|
||
factory-meter er ubundet, så begge sammen ville gitt et pass som SER capped ut uten å være det.
|
||
Load-bearing MÅLT (`tests/test_portfolio_budget_loadbearing.py` + `tests/test_budget.py`), seks
|
||
mutasjoner alle røde: detach wave-sjekken · detach pre-call-guarden · detach bølge-reservasjonen ·
|
||
sjekk run-taket før global kreditering · detach oppstartsnekten · gjør `read_spend` tolerant.
|
||
- **`BudgetExceeded`s tre felt beskriver ÉN og samme ledger (kø-(y)):** `kind`/`limit`/`observed`
|
||
er ett strukturert stopp-event, og `observed` var det udefenderte tredje feltet — MÅLT: fire av
|
||
fem raise-steder (`TokenMeter.charge`, `tick_round`, og BEGGE armene i `exhausted()`) kunne
|
||
rapportere hvilken som helst verdi uten at 621 tester merket det; bare `PortfolioMeter.check`
|
||
var dekket. **Fellen som skjulte det:** `spikes/_harness.py:41` har sin EGEN kopi av
|
||
`BudgetExceeded`/`TokenMeter`, så `spikes/test_harness.py`s `observed`-assert dekker IKKE den
|
||
shippede modulen — produksjonens `tick_round` hadde null direkte test. `exhausted()` er det
|
||
ENESTE stedet som VELGER ledger (S3.4-guarden), så en refusal som sier `portfolio_tokens` mens
|
||
den rapporterer runets eget forbruk ville villedet enhver leser. **Testene bygges med
|
||
`observed != limit`**: ved nøyaktig-uttømt sammenfaller de to, og en test skrevet der kan ikke
|
||
skille dem — den ville passert på en implementasjon som ekkoet taket tilbake som forbruket.
|
||
Ingen defekt funnet i verdiene selv (kontrast (x)/(p)): trippelen var koherent alle fem steder,
|
||
gapet var rent dekning. Load-bearing MÅLT (`tests/test_budget.py`), ni mutasjoner alle røde:
|
||
fem `observed`-mutasjoner (inkl. kontrollen) + fire ekko-mutasjoner.
|
||
- **Pengetall kvantiseres i ÉN orden, fra ÉN kilde (kø-(p)):** `ledger.to_ore` er rammeverkets ENE
|
||
NOK→øre-konvertering (Decimal, ROUND_HALF_UP), og den brukes **per pengebeløp — deretter summeres
|
||
HELTALL**. `run.py` importerer den; aldri en egen kopi (to kopier av en penge-konvertering drifter,
|
||
og en driftet kopi setter de to sidene av en mål-sammenligning på hver sin skala — S4.0s
|
||
`REPLIES`-presedens). Før dette summerte `run.py`s mål-baseline `Project.total_cost`-FLOATS og
|
||
kvantiserte totalen ÉN gang, mens `SavingsLedger` summerte per-kandidat-heltall — og de to ordenene
|
||
møttes i nøyaktig ETT punkt: `_goal_limit_if_reached`, der et prosent-mål avgjør om et
|
||
porteføljepass stopper tidlig. **Målt divergens:** tre linjer à `60000.005` NOK er `18000003` øre
|
||
kvantisert først, men `18000001` summert først (float-drift til `180000.01499999998`) — nok til å
|
||
vippe et mål. **Kvantiser-først valgt fordi hver `CostItem` ER et beløp** (S4.0 gjorde per-linje
|
||
`quantity`/`unit_cost` til validatorens grunnsannhet), og fordi heltallsaddisjon er assosiativ →
|
||
rekkefølge-uavhengig under D-D-bølgemodellen, som float-folden ikke er. **To kallsteder, ikke ett:**
|
||
portefølje- og per-prosjekt-baselinen er separate, og en fiks på bare den ene OVERLEVDE hele suiten
|
||
(målt). Load-bearing MÅLT (`tests/test_money_quantization_loadbearing.py`), fem mutasjoner alle
|
||
røde: detach portefølje-baselinen · detach per-prosjekt-baselinen · gjeninnfør en privat kopi i
|
||
`run.py` · endre avrundingsmodus · la `realize` gå utenom `to_ore`. **Ærlighets-grense:**
|
||
`sum_claimed_saving_nok` (`run.py:_aggregate`) er BEVISST urørt — et float-NOK-rapportfelt som
|
||
aldri kvantiseres og aldri sammenlignes mot ledgeren, altså utenfor ordens-defekten.
|
||
- **En BETALT test får sin EGEN opt-in, og instrumentet bevises GRATIS (Fase 1b, siste trinn):**
|
||
`tests/test_full_run_live.py` kjører hele `run_project`-stien mot et ekte Foundry-deployment, og
|
||
gates på **fire** ting — de to Foundry-variablene, `PORTFOLIO_MODEL_MAP`, og et TREDJE, distinkt
|
||
`PORTFOLIO_LIVE_FULL_RUN` lest på **truthiness** (4b-invarianten). **Den tredje variabelen er
|
||
load-bearing, ikke pynt:** `test_foundry_profile_live.py` (klient-probe) og `test_portfolio_live.py`
|
||
(fan-out) gatet på nøyaktig SAMME to variabler, så å gjenbruke det paret ville betydd at en
|
||
operatør som eksporterer dem for den BILLIGE ett-ords-proben også fyrer den dyre fullkjøringen —
|
||
altså at måleprotokollens stige («bevis så mye som mulig før det dyre trinnet, så en feil er
|
||
attribuerbar») kollapser til ett trinn. **MÅLT:** med begge Foundry-variablene satt SKIPPET den
|
||
dyre, og den billige var grønn. **Regelen gjelder HVER betalt arm, ellers er den ingen regel:**
|
||
`test_portfolio_live.py` passerer ingen `client_factory` og er derfor selv en betalt kjøring — den
|
||
fyrte på to-variabel-paret fra et bart `uv run pytest`, og ble gatet på den TREDJE variabelen i
|
||
samme slengen. Å la den stå ville gjort denne raden halvt usann den dagen den ble skrevet; en
|
||
invariant som beskriver én av to armer er en påstand flaten gjør om seg selv uten dekning, som er
|
||
nøyaktig Fase 3-klassen. Den billige klient-proben beholder to-variabel-gaten med vilje — den ER
|
||
det billige trinnet. `PORTFOLIO_MODEL_MAP` er med av en annen grunn — attribusjon: uten
|
||
den feiler kjøringen av en KONFIGURASJONS-årsak som ser ut som en modell-feil.
|
||
**Asserten bor i ÉN kopi** (`conftest.assert_full_run_contract`, kø-(p)) og er smal med vilje:
|
||
fraværet av `{run_id}-parse-failures.json` (økt 35-invarianten «filens tilstedeværelse er
|
||
signalet») + at `validator_decision` avgjorde. **En `rejected` BESTÅR** — påstanden som felles er
|
||
at det strukturerte skjemaet ER akseptert av det levende endepunktet, ikke at modellen resonnerer
|
||
godt; å kreve `validated` ville vært en modell-dømmekraft-påstand ingen enkelt kjøring kan bære.
|
||
**Iron Law uten å betale to ganger:** et betalt kall kan ikke kjøres rødt-så-grønt, så
|
||
diskrimineringen bevises OFFLINE av `tests/test_live_full_run_contract.py` — to armer over samme
|
||
helper (én parse-feil → kontrakten MÅ feile; alle parser → MÅ passere). Load-bearing MÅLT, to
|
||
mutasjoner med hver sin distinkte signatur: detach artefakt-sjekken (T1 rød ALENE — kontrakten
|
||
degraderer da til `test_portfolio_live.py`s `len(runs)==1`-klasse) · raise ubetinget (T2 rød
|
||
ALENE — den motsatte vakuiteten, en live-test som bare kan bli rød). **Det betalte kallet er
|
||
MÅLINGEN, aldri beviset på at måleinstrumentet virker.**
|
||
- **Kostnadsdisiplin:** utvikle primært på lokal profil (gratis); Foundry/Azure (privat tenant finnes) kun til målrettet, minimal verifisering; billigste modeller + små syntetiske data + harde token-tak. Ingen tunge test-kjøringer.
|
||
- **Offline simulering = primært metode-bevis (kostnadsdrevet, erstatter §11.8):** operatøren kjører
|
||
IKKE MAF mot ekte modell (verken Azure/Foundry eller Ollama — API for begge repoene er for kostbart
|
||
privat). `portfolio_optimiser.simulation` driver `run_project` med en SKRIPTET syntetisk chat-klient
|
||
(`ScriptedChatClient` på `OpenAIChatCompletionClient` — IKKE bare `BaseChatClient`, ellers no-op-er
|
||
`BudgetMiddleware`) over to kjøringer adskilt av en promotering, og viser at læringssløyfa lukkes:
|
||
Run A's godkjente persona-dom (markør fraværende fra bundelen) → `promote_verdict` → re-seed → Run B's
|
||
hypotese-prompt bærer markøren (tom-wiki-kontroll på Run A beviser kausalitet). **Ærlighet (§1,
|
||
ufravikelig):** beviser plumbing + deterministisk ryggrad + at dataflyten lukkes — IKKE at en levende
|
||
LLM ville produsert forslaget/dommen (skriptede stand-ins). Den genuine modell-atferd-sammenligningen
|
||
lever på Claude-SDK-siden (minimal API-kjøring). Skriptet klient = MAF-side stillas, IKKE delt
|
||
(`shared/` forblir framework-nøytralt). Kjøres `uv run python -m portfolio_optimiser.simulation`.
|
||
Load-bearing: `tests/test_simulation_loadbearing.py` blir RØD når promoteringen detaches.
|
||
- **Demoen KJØRER begge tidsskalaer, og de bæres av HVER SIN markør (P1/S1.a):** Steg 7-linja sa
|
||
«lang fil-løkke», men `simulate_learning_loop` kalte `run_project` UTEN `verdict_dir` — dommen kom
|
||
som funksjonsargument (`verdict_input`, den KORTE i-kjøring-fangsten). Nå skriver en ekspert en
|
||
faktisk fil (`write_verdict`) i en innboks MELLOM kjøringene, og Run B får `verdict_dir=`.
|
||
**Hvorfor en ANDRE markør og ikke persona-dommen gjennom innboksen:** Steg 7 (innboks) og Steg 8
|
||
(promotering) er to ULIKE mekanismer som begge ender i Run B's hypotese-prompt — med én delt
|
||
markør kunne hver av dem båret den alene, og `test_simulation_loadbearing.py`s promoterings-assert
|
||
ville stått GRØNN med promoteringen detached, altså blitt vakuøs. `simulate_learning_loop` raiser
|
||
derfor `ValueError` når `inbox_marker == marker`. Innboksen ligger VED SIDEN AV bundle-kopien,
|
||
aldri inni: en dom-fil inne i bundelen når neste kjøring som navigerbar kontekst, som er en annen
|
||
mekanisme i denne sin forkledning. Sentinel-`id` (aldri myntet) — `_mint_id` hasher kandidat-
|
||
featurene, så en myntet id kolliderer med den promoterte dommens, og `VerdictStore.add` er
|
||
first-write-wins per id. Load-bearing MÅLT (`tests/test_step7_demo_inbox_loadbearing.py`), tre
|
||
mutasjoner røde + grønn kontroll: detach `verdict_dir=` · la Run B lese en TOM mappe · sett
|
||
innboks-markøren til en verdi som FINNES i bundelen.
|
||
- **Det skriptede manuset nøkles på PROSJEKT-ID-en, og det er MÅLT:** `scripted_proposer(candidates)`
|
||
bygger simuleringens proposer fra et `ScriptedCandidate`-register, så et nytt prosjekt er en
|
||
data-oppføring (demo-uke-plan §4 risiko 2) — ikke et andre håndskrevet manus. **Hvorfor ikke
|
||
kostkode/tiltaksnavn:** to prompt-former når selectoren — debatt-prompten bærer hele
|
||
bundle-konteksten, mens genererings-prompten (`generate._build_messages`) bærer
|
||
`Project: {id} - {name}` pluss *debatt-outputen* som kontekst, altså selectorens EGET tidligere
|
||
svar. Kostkode og tiltaksnavn står derfor i genererings-prompten kun fordi manuset selv la dem
|
||
der; å nøkle på dem ville nøklet manuset på sin egen output. Prosjekt-ID-en er den ene
|
||
identifikatoren BEGGE former bærer og som RAMMEVERKET stempler. **Validering, ALDRI reparasjon:**
|
||
null treff — eller mer enn ett — raiser `ScriptedCandidateError`; et default-svar ville besvart et
|
||
uregistrert prosjekt med et ANNET prosjekts tall, som på skjermen er umulig å skille fra en riktig
|
||
kjøring, og en tvetydig blob er et DATA-problem som skal falle på generalprøven, ikke avgjøres av
|
||
register-rekkefølgen. `flip_key` MÅ være fraværende fra bundelen (ellers bærer forsøk 1s prompt
|
||
den allerede). `simulate_learning_loop` tar `project_id` ved siden av `bundle_dir`. Load-bearing
|
||
MÅLT (`tests/test_content_keyed_script_loadbearing.py`), fem mutasjoner alle røde + grønn
|
||
kontroll: detach nøklingen · én global flip-key · fallback ved ukjent prosjekt · første-treff ved
|
||
tvetydighet · detach `project_id`-argumentet. **Flip-key-testen ble skrevet om under målingen** —
|
||
første form asserterte på FØRSTE register-oppføring, der «den matchede kandidatens nøkkel» og
|
||
«`candidates[0]`s nøkkel» sammenfaller; den kunne ikke skille de to implementasjonene.
|
||
- **Demoen kjører FORANKRET, og baselinen DERIVERES fra manuset (P4 pkt. 0):** før dette regnet
|
||
validatoren i demoen kun på tall forslaget selv oppga — S4.0-forankringen aktiveres bare når
|
||
kunnskapsbasen shipper `cost-baseline.json`, og ingen bundle under `shared/` har den. Reserven kan
|
||
aldri få fila DER (pull-only subtree + kriterium 8 krever goldenene byte-uendret), men det er en
|
||
*plasserings*-begrensning: `materialize_anchored_bundle` KOPIERER bundelen og legger fila til
|
||
utenfor `shared/`, og kjørestien (`run.py` → `load_optional_cost_baseline`) er da NØYAKTIG samme
|
||
søm en levert bundle ville brukt. **Retningen på avledningen er bærende:** reservens tall er
|
||
syntetiske, så manus-registeret er eneste grunnsannhet — `baseline_from_scripted_candidate`
|
||
avleder i KODE, aldri en andre håndskrevet kopi av de samme tallene (to kilder drifter, og drift
|
||
er nøyaktig det 10 %-prøven modellerer). På GO-dagen snus retningen (plan P3 b: registeret skrives
|
||
FRA levert fil). Begge skriptede svar må oppgi SAMME kostlinjer (`ValueError` ellers): var de
|
||
ulike, ville hypotese #1 blitt avvist av stage 0 istedenfor av P90 — samme REJECTED-linje på
|
||
skjermen, annen mekanisme. **Forankringen er usynlig i alt annet stdout** (målt: eneste diff mot
|
||
uforankret er KUNNSKAPSBASE-blokka), derfor printes den erklærte baselinen, og derfor er
|
||
`provenance` et PÅKREVD argument til `_baseline_lines` — kallstedet som velger bundelen er det
|
||
eneste som vet hvor tallene kom fra. Load-bearing MÅLT
|
||
(`tests/test_anchored_reserve_loadbearing.py`), fem mutasjoner røde + grønn kontroll: detach
|
||
main-wiringen · detach fil-skrivingen · la filnavnet drifte · detach to-svars-enigheten · returner
|
||
et literal i stedet for det avledede. **Målingen felte TESTEN først** (samme klasse som 08-06):
|
||
«ingen kostbaseline erklært» INNEHOLDER «kostbaseline erklært», og `ENERGI-TOTAL-EL` står allerede
|
||
i Steg 2-linja — begge assertene overlevde detach-mutasjonen. De to grenene deler nå ingen ordlyd.
|
||
- **Demoens stderr: rund-taket dempes, `ExperimentalWarning`-paret PINNES (P4 pkt. 2):** målt 08-09
|
||
var stderr seks linjer. `quiet_expected_round_cap_notice()` dropper KUN
|
||
«reached max_rounds=…; forcing completion» — en hendelse demoen selv provoserer (maker/checker
|
||
kjører til taket) — via et filter på den EMITTERENDE loggeren (`ROUND_CAP_LOGGER`, lest ut av MAFs
|
||
kilde). Logger-filtre gjelder kun loggeren posten ble logget GJENNOM; en forfars filtre konsulteres
|
||
aldri. Filteret installeres i `main()`, ALDRI ved import — en bibliotek-modul skal ikke
|
||
omkonfigurere loggingen til en konsument. **De to `ExperimentalWarning`-linjene dempes IKKE:** de
|
||
fyrer mens `portfolio_optimiser/__init__.py` importerer `run` → `agent_framework`, altså alltid FØR
|
||
`simulation` sin egen importblokk, under BEGGE kjøreformer — så å dempe dem ville krevd et
|
||
warnings-filter inne i bibliotekpakken, dvs. at rammeverket bestemmer hva MAF får si til enhver
|
||
konsument. En wrapper bak konsoll-kommandoen ble avvist av en andre grunn: da ville de to
|
||
kjøreformene skrevet ULIK stderr, og en byte-fasit ville pinnet kommandoen i stedet for programmet.
|
||
**Dempingen er smal ved konstruksjon** — nøklet på meldingen, ikke loggeren — nettopp så pkt. 3-pinnen
|
||
fortsatt kan felles av en NY advarsel. Load-bearing MÅLT
|
||
(`tests/test_demo_stderr_quiet_loadbearing.py`), fem mutasjoner røde + grønn kontroll: detach
|
||
`main()`-kallet (subprosess-testen er ENESTE som fanger det — de tre filter-testene installerer
|
||
filteret selv) · la filteret droppe alt · installer ved import · pluss de to entry-point-mutasjonene.
|
||
- **Demo-transkriptet er sjekket inn som fasit, og masken er SPANN-avgrenset (P4 pkt. 3):**
|
||
kriterium 6 er selv-identitet — to kjøringer av en REGREDERT demo er like enige som to kjøringer av
|
||
en riktig, så fasiten må forlate prosessen. `tests/golden/demo-transcript.stdout` er stdout ORDRETT
|
||
(målt byte-identisk over kjøringer OG i fersk klon), og er derfor også demoens abortsti: feiler
|
||
live-kjøringen, ER fila transkriptet. `….stderr` er normalisert på nøyaktig to MÅLTE miljø-spann —
|
||
`site-packages`-prefikset og temp-katalogen bak `(arbeidskopi: …)`, der `po-sim-`-prefikset holdes
|
||
SYNLIG fordi det er en egenskap ved programmet (`mkdtemp(prefix=…)`), ikke ved miljøet; pinnet
|
||
stderr er TO linjer (var fire til og med core 1.9.0 — se F15-raden). **Masken må ikke kunne vokse:** P4 pkt. 2 betalte for at en NY advarsel
|
||
fortsatt når stderr, og en normalisering som maskerte hele linjer ville opphevet det i ett trekk —
|
||
derfor er `test_normalisation_does_not_mask_a_new_warning` kontrollen som forbyr det (MÅLT: en
|
||
droppende normaliserer med fasiten regenerert under seg holder BEGGE likhets-testene grønne og
|
||
felles kun av kontrollen). `PYTHONIOENCODING` pinnes, ellers måler sammenligningen operatørens
|
||
locale i stedet for programmet. **Regenerering er en beslutning, aldri rydding** — fasiten kan ikke
|
||
bevise sin egen kjøring, den pinner outputen P3-kriteriene ble målt mot.
|
||
**Hashen radene under fører er `shasum -a 1` av INNHOLDET, aldri git-blob-id-en (S7a-3 pkt. 4).**
|
||
De to er ulike av konstruksjon — git hasher over `blob <len>\0` + innhold — så
|
||
`ea8c534773acdbe41ae68f2c55724d69aaf8be4f` er sha1 av fila, mens `git hash-object` på samme fil
|
||
gir `55bdea3ad20616480d81b9e7544604b248a541c9` (stderr-goldenen: `ede3e2f…` innhold /
|
||
`12893ec…` blob). MÅLT etter at en økt søkte uttømmende etter `ea8c534…` som git-objekt, ikke fant
|
||
det, og leste fraværet som at ni invariant-rader siterte en fantomverdi — Verifiseringsloven
|
||
ansikt 4 mot ens eget instrument: et negativt resultat fra feil spørring er ikke et faktum.
|
||
Radene var RIKTIGE hele veien; det som manglet var etiketten, og den står nå i hver av dem.
|
||
- **Frø-setningen AVLEDES fra kjøringen (P4 pkt. 4):** demoen sier høyt hvor Kjøring B's tidligere
|
||
dommer kommer fra, og splitten (`_verdict_origin_line`) regnes ut — linja rett over printer allerede
|
||
antallet, så en håndskrevet «én av tre» ville vært den andre kopien som drifter (samme regel som
|
||
pkt. 0-baselinen), og ville blitt sagt uendret etter at en framtidig bundle shipper en ANDRE frøsatt
|
||
dom. Klassifisereren er de to markørene demoen alt sporer; den hviler på at den frøsatte dommen
|
||
bærer INGEN av dem, som MÅLES på levert bundle. **Planens forhåndsskrevne ordlyd var FEIL mot
|
||
levert innhold** («én av de TO») — målt henter Kjøring B TRE: én fulgte med kunnskapsbasen, to er
|
||
demoens egne (én per tidsskala). Load-bearing MÅLT
|
||
(`tests/test_p4_honesty_sentences_loadbearing.py` + golden-transkriptet), fem mutasjoner alle røde
|
||
+ grønn kontroll: ett byte i en stdout-linje · detach dempingen · over-normaliser stderr · literal
|
||
splitt (fanget av INGENTING i 800 tester bortsett fra skille-testen) · detach frø-setningens print.
|
||
- **Delt ekspert-persona som Agent Skill (§8, framework-nøytral):** ekspert-reviewer-personaen bor i
|
||
`shared/skills/expert-reviewer/` (`SKILL.md` + `references/example-verdict.json`) og er den ENE
|
||
delte artefakten begge stacker instansierer reviewer-en fra. `shared/` forblir REN DATA — MAF-siden
|
||
leser den via `portfolio_optimiser.persona.load_persona_example` (call-time, fail-fast), Claude-SDK-
|
||
søskenet med sin egen loader mot samme JSON. Dette AV-STUBBER simuleringen: persona-dommen (decision
|
||
+ rationale + sporet markør) hentes nå fra artefaktet ved call-time, ikke en inline-literal — så
|
||
personaen er genuint konsumert og kan ikke råtne stille. **Decision er binær** (`approved`/`rejected`
|
||
— `FeedbackContract` run-stien tar; `approved_with_adjustment` avvises der, bor kun i bundle-seedens
|
||
frontmatter + promoterings-gaten); realiseringskorreksjonen lever i rationale-prosaen, ikke et tredje
|
||
enum. SKILL.md-prosaen nevner ALDRI en konkret framework (maf-guarden er import-formet). Load-bearing-
|
||
trio (`tests/test_persona_skill_loadbearing.py`): struktur+framework-nøytralitet (RØD på framework-
|
||
import), eksempelet er gyldig pipeline-input inkl. `FeedbackContract` (RØD på skjema-/kontrakt-drift,
|
||
på en throwaway-kopi — aldri den git-tracked fixturen), og sim-ens markør følger artefakt-fila (RØD i
|
||
det øyeblikk personaen re-inlines).
|
||
- **Den råe svarteksten fanges i en KALLER-EID SINK, ikke i en returverdi (Fase 1b, funn 1):**
|
||
`generate._fetch_parsed` kastet hvert uparsebart modellsvar i `except: continue`, så prosjektets
|
||
første levende kjøring brant tolv runder på formatfeil og etterlot **null tegn** av det modellen
|
||
faktisk sa — enhver videre betalt kjøring ville vært gjetning. **HVOR teksten overflates er avgjort
|
||
av en MÅLING, ikke av symmetri med Steg 5:** `meter.tick_round()` raiser `BudgetExceeded` INNE i
|
||
`_fetch_parsed`, og uten mandat fanger ingen den (`run.py`s ene `except BudgetExceeded` er
|
||
mandat-armen) — så på nøyaktig den stien fangsten finnes for, RETURNERER `generate_via_llm`
|
||
ingenting. Et felt på `GenerationResult` (Steg 5-formen) er derfor blindt for den, og et
|
||
outbox-artefakt skrevet ETTER kjøringen likeså. Sinken speiler i stedet `meter`: en kaller-eid
|
||
akkumulator løkka muterer, hvis innhold kalleren holder uansett hvordan løkka endte. Steg 5s
|
||
«returverdi, ikke out-parameter» gjelder en verdi som NÅR kalleren; her gjør den ikke det, og å
|
||
kopiere regelen blindt ville gjenoppbygd defekten ett lag opp. Artefaktet
|
||
`{run_id}-parse-failures.json` skrives fra en **`finally`**, ikke `except BudgetExceeded` — enhver
|
||
exception ut av genereringen ødelegger samme bevis, og en liste over exception-typer er en liste
|
||
som blir foreldet. **Teksten er VERBATIM** (en forkortelse gjør beviset om til en parafrase), og
|
||
fila skrives KUN når noe faktisk feilet, så dens tilstedeværelse ER signalet. Byte-determinisme
|
||
påstås IKKE for dette ene artefaktet — innholdet er en levende modells prosa. Load-bearing MÅLT
|
||
(`tests/test_parse_failure_capture_loadbearing.py`), seks mutasjoner alle røde mot HELE suiten +
|
||
grønn kontroll 859/4: detach fangsten (3 røde) · flytt skrivingen ut av `finally` (1 rød, KUN
|
||
budsjett-testen) · detach run-wiringen (2 røde, generate-testen grønn) · skriv artefaktet alltid
|
||
(kontrollen + den eksisterende `a5`-inerthetstesten) · trunker teksten til 40 tegn (3 røde) ·
|
||
trunker til 100 tegn slik at sentinelen OVERLEVER (1 rød — verbatim-asserten alene, den skarpe
|
||
diskriminatoren). Ærlighets-grense: `_charge_usage` kan raise FØR parse, og et svar tapt der er
|
||
ikke en parse-feil og fanges ikke.
|
||
- **Proposeren får en GRAMMATIKK, og skjemaet er DERIVERT + fail-closed (Fase 1b, funn 1b):**
|
||
`generate_via_llm` sender `options={"response_format": proposal_response_format()}` på hvert
|
||
genererings-kall. **Formen er MÅLT, ikke valgt:** `ChatOptions.response_format` tar
|
||
`type[BaseModel] | Mapping`, og BEGGE profiler ærer den — LOCAL
|
||
(`OpenAIChatCompletionClient`) sender en Mapping ordrett til Chat Completions, AZURE
|
||
(`FoundryChatClient` → `RawFoundryChatClient` → `RawOpenAIChatClient`) konverterer SAMME
|
||
envelope til Responses-APIets `text.format`. **Klassen er AVVIST på bevis:** gitt en klasse
|
||
konverterer klienten med `type_to_response_format_param`, som (målt) emitterer `minimum` /
|
||
`exclusiveMinimum` / `minItems` / `prefixItems` og et `assumptions`-node hvis
|
||
`additionalProperties` er et SKJEMA — fire ting Azures publiserte subset utelukker
|
||
(Learn: «Unsupported type-specific keywords» + `additionalProperties: false` i hvert objekt).
|
||
Vår egen mapping er eneste måte å styre hva som når tråden. **Å stripe beskrankningene koster
|
||
ingenting:** skjemaets jobb er FORM, validatorens jobb er VERDIER — `minItems`/`gt=0` gjenreises
|
||
av pydantic i `_parse_ir` og av `validate_proposal`. **Skjemaet DERIVERES fra `SavingsProposal`**
|
||
(`strict_json_schema`), aldri håndskrevet: en andre kopi av en form som alt bor i `ir.py` drifter
|
||
stille, og modellen ville fortsatt blitt bestilt for den gamle. **`assumptions` KAN IKKE bare
|
||
droppes, og det er en MÅLING:** feltet er det ene uttrykksløse (fri-form map av 2-tupler), men
|
||
`validator._monte_carlo` faller tilbake på `item.unit_cost` for hver kode uten bånd — uten bånd
|
||
i det hele tatt er alle 512 samples IDENTISKE og P10 == P50 == P90. Den stokastiske
|
||
falsifisereren ville gått inert mens den fortsatt rapporterte persentiler: repoets kardinalklasse
|
||
(en gate som bare kan bli grønn). Derfor bærer WIRE-en et array av navngitte entries og
|
||
`_parse_ir` folder det tilbake til IR-ens map — **additivt, aldri erstatning** (map-formen
|
||
parser uendret; alle scriptede svar i suiten og golden-transkriptet bruker den). Sanitiseren er
|
||
**fail-closed** (`StructuredOutputUnsupported`) på `prefixItems`/`oneOf`/`allOf`/fri-form map
|
||
uten deklarert override — validering, ALDRI reparasjon (speiler `write_concept_file`).
|
||
Prompt-linja «Respond with ONLY a JSON object» + parse-retry + funn-1-fangsten står URØRT: en
|
||
leverandør som ignorerer `response_format` må fortsatt få beskjed, og backstoppen er poenget.
|
||
Load-bearing MÅLT (`tests/test_structured_output_loadbearing.py`), seks mutasjoner alle røde +
|
||
grønn kontroll 864/4: detach wiringen (1 rød) · detach sanitiseren (3 røde) · dropp
|
||
`assumptions` fra skjemaet (1 rød) · fail-closed → stille reparasjon (1 rød) · detach
|
||
normaliseringen (3 røde) · erstatning i stedet for tillegg (2 røde — T5 PLUSS
|
||
golden-transkriptet, et uavhengig vitne). **T3 ble skrevet VAKUØS først** (repoets 08-09-klasse,
|
||
sjette gang): den påsto å bli rød når `assumptions` forsvant fra skjemaet, men den scriptede
|
||
klienten ignorerer skjemaet — påstanden ble bevist usann av M3 og testen fikk en DIREKTE
|
||
assert på skjemaet. **ÆRLIGHETS-GRENSE, UTTALT:** ingen betalt kjøring er gjort, så at det
|
||
emitterte skjemaet ER akseptert av det levende endepunktet er IKKE verifisert — testen beviser
|
||
konformitet med det DOKUMENTERTE subsettet, ikke aksept. Ollamas oppførsel på
|
||
`response_format` er likeledes uverifisert.
|
||
- **Overleverings-pakka ER `git archive HEAD`, aldri en kuratert kopi (Fase 5):**
|
||
`scripts/make-handover-package.sh` bygger én zip en ekstern organisasjon deployer uten å klone
|
||
repoet. **Tracked files only er hele eksponerings-kontrollen** — `STATE.md`, `*.local.md` og
|
||
`.env` er gitignorert, så de KAN ikke komme inn; et filter vedlikeholdt i skriptet ville vært den
|
||
andre kopien av den regelen, og den andre kopien er den som drifter (kø-(p)). Mottakeren får altså
|
||
HEAD selv. Versjonen LESES fra `pyproject.toml` — et hardkodet tall her ville råtnet ved neste bump
|
||
nøyaktig som README-ens wheel-filnavn gjorde (Fase 3). `DEPLOY.md` ligger i treet og blir dermed
|
||
med i arkivet av seg selv; den bærer mottakerens tre første spørsmål — hvem gjør hva
|
||
(plattform-operatør / bestiller / fagperson), prosessen ende-til-ende, og **hvorfor det ikke
|
||
finnes et chat-grensesnitt** (flaten er `POST /invocations`, og `as_agent()` er bevisst vraket
|
||
fordi validator, baseline-forankring, checker-gate og ledger ligger UTENFOR grafen — et chat-lag
|
||
ville rutet forespørsler rundt nøyaktig det som gjør svaret etterprøvbart). Den navngir også det
|
||
4e målte deploy-kravet som ingen rad hadde skrevet ned: pakket `model_map.json` bærer
|
||
`REPLACE-WITH-*`, så uten `PORTFOLIO_MODEL_MAP` starter tjenesten, svarer på `/readiness` og
|
||
feiler HVER invocation. Gaten er `tests/test_handover_package_loadbearing.py`, og
|
||
DEPLOY.md-asserten er LINJEFORANKRET: `PORTFOLIO_FOUNDRY_PROJECT_ENDPOINT` INNEHOLDER
|
||
`FOUNDRY_PROJECT_ENDPOINT`, så en delstreng-assert på det injiserte navnet ville vært oppfylt av
|
||
vårt eget (repoets 08-09-klasse, femte gang).
|
||
- **Overleveringen er KUN kjørbar Python, og fraværet er FJERNING — ikke filtrering (14.08,
|
||
operatørdirektiv etter ekstern test):** `Dockerfile` og `azure.yaml` er slettet fra TREET.
|
||
**Sømmen er valgt av den eksisterende invarianten, ikke av smak:** pakka ER `git archive HEAD`, så
|
||
å ekskludere filene fra arkivet ville krevd en kurerings-mekanisme (skript-filter eller
|
||
`export-ignore`) — den andre kopien av «hva mottakeren får», fri til å drifte fra HEAD, altså
|
||
nøyaktig kø-(p)-regelen raden over finnes for. Å beholde dem som «opt-in» ville ikke oppfylt
|
||
direktivet i det hele tatt. Fjerning holder arkivet ukurert OG gjør fraværet til en egenskap ved
|
||
HEAD, som er det eneste en gate kan måle. **De to gatene som pinnet flaten er håndtert BEVISST,
|
||
aldri stille svekket:** 4e-rå-tekst-gaten (`--platform linux/amd64` + ÉN kopi av startkommandoen)
|
||
er SLETTET med et notat der den sto — en gate som pinner en fjernet flate kan bare bli grønn — og
|
||
handover-gatens `_REQUIRED_MEMBERS` er ikke bare fratatt de to navnene, men erstattet av en
|
||
POSITIV fraværs-assert; å kun slutte å KREVE dem ville gitt en gate som ikke kan skille «fjernet»
|
||
fra «shippes fortsatt». Matchingen skjer på arkiv-MEDLEMSNAVN, ikke på prosa (dokumentene må
|
||
kunne forklare at ingen image shippes — repoets 08-09-klasse, sjette gang), og dokument-gaten
|
||
forbyr kommando-FRAGMENTER (`docker build`, `azd deploy`), ikke ordet. **Startkommandoen har nå
|
||
ÉN kopi igjen — DEPLOY.md-ens `python main.py`** — og den navngir inngangen subprosess-testen
|
||
faktisk kjører. **Ærlighets-grense, uttalt:** azd/hosted-agent-stien finnes ikke lenger i pakka;
|
||
hvordan prosessen driftes er mottakerens valg. `git archive HEAD` leser HEAD, ikke arbeidstreet,
|
||
så gaten er ekte men forsinket med én commit (funn 35). Load-bearing MÅLT
|
||
(`tests/test_handover_package_loadbearing.py`).
|
||
- **Sporing er OPT-IN, og «av» betyr at MAF ALDRI kalles (U14, økt 55):** `PORTFOLIO_OTEL` leses på
|
||
**truthiness** (4b-regelen) og er ENESTE bryter; uten den kalles `configure_otel_providers` ikke i
|
||
det hele tatt — spans LAGES fortsatt (`ENABLE_INSTRUMENTATION` defaulter `True`,
|
||
`observability.py:697`) og kastes, så ingenting KAN forlate prosessen. Et kall med tom
|
||
exporter-liste ville derimot installert providere og lest hver `OTEL_EXPORTER_OTLP_*` i det
|
||
omkringliggende miljøet — «av» må være fravær av kall, ikke kall uten innhold. **To regler er
|
||
MÅLT, ikke valgt** (`observability.py:849` bygger exporter-lista i fast rekkefølge: (1) env-avledede
|
||
OTLP-exportere UBETINGET, (2) de innsendte, (3) `ConsoleSpanExporter()` — default-sink **stdout** —
|
||
når `enable_console_exporters` er sann fra argument ELLER `ENABLE_CONSOLE_EXPORTERS`): (a)
|
||
`enable_console_exporters=False` sendes EKSPLISITT i BEGGE moduser, ellers gir en operatør med den
|
||
variabelen eksportert et span-dump på stdout — nøyaktig det S6 målte som ødeleggende for
|
||
golden-transkriptet; (b) `console` NEKTER når en OTLP-endepunkt-variabel finnes, fordi steg (1)
|
||
ville lagt til en nettverks-exporter ordet «console» lover ikke er der. **Validering, ALDRI
|
||
reparasjon** — vi fjerner ikke operatørens miljøvariabel bak ryggen på dem
|
||
(`write_concept_file`-regelen); nekten NAVNGIR variabelen. `otlp` uten deklarert endepunkt nektes
|
||
også: providere med ingenting å eksportere til er en kjøring som SER sporet ut og ikke er det. En
|
||
ukjent verdi nektes ved navn, aldri stille fallback til av. **`tracing_notice` er ENESTE renderer**,
|
||
tar den alt oppløste `TracingSetup` og returnerer `None` når sporing er av — omisjon, aldri tom rad
|
||
(`announce`-regelen), og her bærende utover stil: demoens pinnede stderr er TO linjer (FIRE før F15). **Tre
|
||
kallsteder, ikke ett** (`run.main`, `simulation.main`, `hosting.main`): demoen er et skriptet bevis,
|
||
ikke produktet, og en søm bare demoen når ville latt de to inngangene en virksomhet faktisk kjører
|
||
være usporbare. **OTLP-exporter-PAKKENE er BEVISST ikke deklarert** (egress + grpc/protobuf-vekt i
|
||
et publisert wheel; MAF raiser selv en `ImportError` som navngir pakka) — uttalt ærlighets-grense.
|
||
**`PLAN_CREATED`/`REPLANNED`/`PROGRESS_LEDGER_UPDATED`-eventene planen navngir er IKKE bygget:**
|
||
de hører til utforskningssløyfa (U4) som ikke finnes ennå, og en emitter skrevet før kallstedet er
|
||
en form gjettet i stedet for målt. Load-bearing MÅLT
|
||
(`tests/test_tracing_loadbearing.py`), ni mutasjoner alle røde mot HELE suiten + grønn kontroll
|
||
943/5: exporteren tar sin stdout-default (4 røde) · `enable_console_exporters` overlatt til miljøet
|
||
(3 røde — inkludert den ATFERDSMESSIGE, som kjører demoen med variabelen eksportert; uten den ville
|
||
raden bare vært en keyword-assert) · detach console-nekten (4 røde) · detach otlp-endepunkt-nekten
|
||
(1 rød) · ukjent modus faller stille til av (2 røde) · «av» kaller MAF likevel + renderer returnerer
|
||
alltid en linje (9 røde, hvorav TRE i tester som fantes fra før — `test_golden_transcript` sin
|
||
da fire-linjers (nå to-linjers) stderr og `test_portfolio_cli_offline`s stille-pass — altså er omisjonen gatet av
|
||
uavhengige vitner) · detach demo-wiringen + detach CLI-wiringen (5 røde) · detach hosting-wiringen
|
||
(1 rød, KUN subprosess-testen — P4-presedensen).
|
||
- **Utforskningssløyfa er en MANDAT-FORMER, og de tre garantinivåene er strukturelle (U4+U13
|
||
synkron, økt 56):** `explore.py` legger en Magentic-manager OVER den normative sløyfa — `prompt +
|
||
kunnskapsbaser → Mandate → run_project(mandate=…)` UENDRET, Steg 3s maker-checker urørt (commons-eid
|
||
og normativ). Manageren velger VEI; det som forlater friheten er `mandate.Mandate`, aldri et forslag.
|
||
**Nivå 1** = `quick_validate`-verktøyet (SAMME `validate_proposal`, SAMME baseline, men rådgivende —
|
||
når ALDRI provenance); **nivå 2** = pipelinen som stempler; **nivå 3** = skriverettigheter, som kun
|
||
pipelinen har. `explore()` skriver INGENTING. **Mandatet bygges fra hypotesiserens MERKEDE turer**
|
||
(`HYPOTHESIS: {"label","rationale"}`), aldri fra sluttsvaret — sluttsvaret er RÅTT per design, og en
|
||
parser på det ville gjort det til et forslag. Markøren er dét som gjør fail-closed mulig: en umerket
|
||
tur er ikke en påstand (ingen stillhet å lukke), mens en MERKET-men-uleselig linje raiser
|
||
(`write_concept_file`-regelen). **Frø-approaches bevares ALLTID og FØRST** — også når sløyfa fant
|
||
ingenting og også ved stopp (§ C.6 dør 1 er en bevaringsregel, ikke en belønning for å bli ferdig).
|
||
**Tre kanaler, aldri én:** tokens OG runder raiser `BudgetExceeded` (rundene som
|
||
`kind="exploration_rounds"`, oversatt av VÅRT lag fordi orkestreringen MÅLT ikke raiser ved sitt eget
|
||
rundetak — den returnerer en kanonisk assistent-melding som ved transporten er uskillbar fra suksess),
|
||
mens alt semantisk er en VERDI i `stop` (S3.4-splitten: utmattelse og utfall er ikke samme sak).
|
||
Diskriminatoren mellom «nådde taket» og «ble kappet av taket» er SISTE ledgers
|
||
`is_request_satisfied` — samme felt orkestratoren selv forgrener på (`:1106`) — aldri
|
||
termineringsmeldingen, som er en inline f-string (`:1253`) uten konstant å pinne mot og som en modells
|
||
eget sluttsvar kan inneholde. **`speaker_known` sjekkes FØRST og slår alt annet:** en `next_speaker`
|
||
uten treff gir stille sluttsvar med NULL deltakerarbeid (`:1128-1131`), altså et plausibelt svar
|
||
ingen jobbet for (E2-klassen) — sløyfas egne funn holdes da tilbake, frøene ikke.
|
||
**Kontrakten nekter tre ting ved konstruksjon:** hvert av seks felt er PÅKREVD uten default (MAF
|
||
defaulter `max_round_count`/`max_reset_count` til ubegrenset, så et utelatt felt faller ikke tilbake
|
||
til noe forsiktig, men til dét `method-spec` §8 forbyr); `max_reset_count=0` nektes — **MÅLT**, ikke
|
||
resonnert: `reset_count >= max_reset_count` mot en teller som starter på 0 gjør at kjøringen
|
||
terminerer FØR første runde med kun `facts`+`plan`, null ledger-events og «maximum reset count», altså
|
||
en utforskning som utforsket ingenting, forkledd som en stall som aldri skjedde (`max_stall_count=0`
|
||
er derimot LOVLIG — strengt `>` gjør 0 til «reset ved første stallede runde»); og
|
||
`max_plan_revisions>0` med `enable_plan_review=False` nektes (en cap på en hendelse som ikke kan skje).
|
||
`max_plan_revisions` finnes fordi A3 MÅLTE at en `revise` koster 2 manager-kall, **null** ledger-kall
|
||
og **null** runder og så spør PÅ NYTT — under rundetaket alene er en alltid-reviderende ekspert
|
||
ubundet forbruk under vakter som alle ser tilfredse ut. Ved cap: typet stopp, ALDRI en påtvunget
|
||
approve (repair av et menneskes beslutning er den verste sorten). **U14s tre utsatte events er
|
||
landet** (`plan_created`/`replanned`/`progress_ledger_updated` som span-events på ÉN
|
||
`exploration`-span) — emisjon er UBETINGET og «av» betyr at OTel kaster dem, samme form MAFs egen
|
||
instrumentering alt har; en flagget emitter ville vært en andre oppløsning av regelen `tracing.py`
|
||
eier. Uttalt ærlighets-grense: eventene registreres når event-strømmen foldes, så REKKEFØLGEN er
|
||
tro og tidsstemplene er ikke øyeblikkene manageren handlet.
|
||
**Load-bearing MÅLT** (`tests/test_explore_loadbearing.py`, 32 tester), tolv mutasjoner alle røde mot
|
||
HELE suiten + grønn kontroll 975/5: detach rundetak-oversettelsen (1 rød) · test rundetaket FØR
|
||
tilfredsstillelse (1 rød — den motsatte feilen, som gjør en fullført utforskning til en budsjettfeil) ·
|
||
detach ukjent-taler-sjekken (1) · `BudgetMiddleware` av manageren, deltakerne beholder den (1) ·
|
||
detach revisjons-capen (1) · dropp frø-bevaringen (3) · la en ukjent-taler-kjøring levere funnene
|
||
videre (1) · detach alle tre span-events (1) · tillat `max_reset_count=0` (1) · gjør en merket-men-
|
||
uleselig hypotese tolerant (1) · la `read_bundle` skrive i basen den leser (1) · send spans til OTels
|
||
default-sink (2). **TO av dem FALSIFISERTE testen først, og begge er repoets vakuøs-gate-klasse:**
|
||
(i) skrivefrihets-testen drev kun `explore()`, men en `ScriptedChatClient` returnerer TEKST og
|
||
emitterer aldri et verktøykall — så ingen scriptet kjøring når en verktøykropp, og hele lesesømmen
|
||
(eneste sted en skriving realistisk kan komme fra) lå utenfor gaten; testen kaller nå hvert verktøy
|
||
DIREKTE. (ii) stdout-testen brukte `capsys`, men `ConsoleSpanExporter`s `out`-default bindes når
|
||
`opentelemetry.sdk.trace.export` FØRST importeres — under pytest er det stdout ved COLLECTION, som
|
||
`capsys` aldri ser; spans lå faktisk på stdout mens asserten var grønn. Dét er ikke en test-quirk å
|
||
omgå, det er nøyaktig faktumet U14 finnes for, og arven er P4-presedensen: **subprosessen er
|
||
målingen**. Begge armene kjøres nå i et barn (av: null trace-data noe sted; `PORTFOLIO_OTEL=console`:
|
||
spanet + `progress_ledger_updated` på **stderr** og stdout tomt), med `EXPLORATION-OK` på stderr som
|
||
kontroll — uten den ville «stdout var tomt» vært like sant om et barn som krasjet ved import.
|
||
**Ærlighets-grenser, uttalt:** multi-base-dispatch (`Approach.bundle_id`, § C.7) venter til
|
||
`run_project` tar mer enn én `bundle_dir` — å shippe feltet før konsumenten er en form gjettet i
|
||
stedet for målt; `quick_validate`-dommene hypotesiseren så bor ikke i `ExplorationResult`, de er nivå
|
||
1 og hører hjemme i `{run_id}-exploration.json` som CLI-wiringen skriver; utforskningsrollene løses
|
||
via `resolve_model`s `default`-fallback til en operatør mapper dem eksplisitt; at en LEVENDE modell
|
||
kaller verktøyene er ikke bevist offline (samme klasse som structured-output-grensen).
|
||
- **Utforskningens KALLSTEDER: sporet er kaller-eid, og whitelisten ble en TREDELING (økt 57):**
|
||
`--explore "<prompt>" --explore-config FILE` i `run.py`, `explore_prompt` + `explore_contract` på
|
||
den hostede flaten, og `simulate_exploration` som et TREDJE sim-scenario — alle opt-in, alle over
|
||
den uendrede sløyfa. **`ExplorationTrace` er en KALLER-EID akkumulator (funn-1-sinken, ett lag
|
||
opp), og formen er tvunget av en måling, ikke valgt:** `explore()` raiser `BudgetExceeded` på
|
||
rundetaket og tokentaket fyrer fra middleware midt i løpet — på BEGGE stier konstrueres aldri et
|
||
`ExplorationResult`, mens § C.2 krever at artefaktet er lesbart «uansett hvilken vakt som fyrte».
|
||
Steg-5-regelen («returverdi, ALDRI en out-parameter») styrer en verdi som NÅR kalleren; her gjør
|
||
den ikke det, og å kopiere regelen blindt ville gjenoppbygd defekten den ble skrevet mot.
|
||
`ExplorationResult.ledger_log`/`.plan_reviews` BYGGES FRA akkumulatoren (`tuple(trace.ledger)`),
|
||
aldri ved siden av — to beholdere om ett faktum er kø-(p). `{run_id}-exploration.json` skrives fra
|
||
en **`finally`** (`write_parse_failures`-presedensen) via `explore.trace_payload` → `outbox`s
|
||
plain-mapping-skriver (RAW-laget forblir MAF-fritt); **`completed` er et EGET påkrevd felt**, fordi
|
||
en `stop: null` som betyr BÅDE «avsluttet normalt» og «vi fikk aldri vite» er stillheten
|
||
`cost_baseline_anchored` ble påkrevd for å lukke. **Åtte CLI-nekter, alle ved navn**, hvorav to
|
||
bærer en beslutning: (i) `--explore` + `--mandate` er TO KILDER TIL ETT MANDAT og NEKTES, aldri
|
||
slås sammen — `explore()` tar objective fra prompten og hardkoder `allow_own_proposals=True`, så
|
||
komposisjon ville stille overskrevet tre felt operatøren skrev selv; nekten NAVNGIR
|
||
biblioteksdøra (`seed_approaches`), fordi § C.6 dør 1 er et ekte behov flaten ikke betjener.
|
||
(ii) `enable_plan_review=true` nektes på BEGGE flater FØR `explore()` kalles, og det er en
|
||
TYPE-måling: `ExplorationError` er en `RuntimeError` og ligger utenfor `main()`s
|
||
`(ValueError, FileNotFoundError, ValidationError)`-tuppel og utenfor hostings 400-arm, så å
|
||
overlate den til sløyfa ville gitt traceback på CLI-en og 500 — krasj-kanalen — på HTTP.
|
||
(`TracingConfigError` er derimot en `ValueError`; 400-armen dekket den alt.) Etter nektene er hver
|
||
konfig-formet `ExplorationError` UNÅBAR fra begge inngangene ved konstruksjon; det som fortsatt kan
|
||
slippe ut (uleselig merket hypotese, uttømt budsjett) er RUN-en som feiler, ikke kalleren som tar
|
||
feil. **Hostings whitelist er nå `_REQUIRED` / `_OPTIONAL` / `_CONSUMED`:** utforskningsfeltene er
|
||
IKKE `run_project`-parametre, så Fase 4e-beviset fikk en NEGATIV halvdel — hvert videresendt felt
|
||
MÅ finnes i `inspect.signature(run_project)`, hvert konsumert felt MÅ ikke; uten den ville et felt
|
||
som glir fra konsumert til videresendt vært nøyaktig driften 4e finnes for. **Demo-scenarioet er
|
||
nåbart ved NAVN og bare der** (`main()` kaller det ikke, og at golden-transkriptet er byte-uendret
|
||
etter at det ble lagt til ER målingen av det), med en **vakuitets-vakt**: en label kunnskapsbasen
|
||
ALLEREDE oppgir refuseres, fordi den ville nådd hypotese-prompten som ordinær kontekst enten
|
||
utforskningen kjørte eller ei — `simulate_learning_loop`s to-markør-vakt i demo-form. Manager-
|
||
manuset nøkles på PROMPT-STADIET, ikke prosjekt-ID-en, og det er ikke et unntak fra
|
||
`scripted_proposer`-regelen: manageren får FEM ulike spørsmål og prosjekt-ID-en er konstant over
|
||
alle fem. **`--outbox-dir` uten `--run-id` NEKTES i utforskningsblokka, og det er en HOIST — ikke
|
||
en andre kopi av regelen:** `run_project` eier outbox-kontrakten og nekter på sin FØRSTE setning,
|
||
tidlig nok for enhver sti som fantes før U4, men utforskningen kjører FORAN det kallet — uten
|
||
hoisten brukes hele utforskningsbudsjettet på modellkall før nekten, og artefakt-skrivingen hoppes
|
||
over, så ikke engang regnskapet over hva som ble brukt overlever. Funnet i review FØR commit;
|
||
testen asserterer at INGEN modellkall skjedde, ikke bare at rc er 1 — ved exit-koden ser en nekt
|
||
etter forbruket identisk ut. **Scenarioet har BEVISST intet `label_in_bundle`-felt:** vakten
|
||
raiser før et resultat finnes, så feltet kunne kun vært `False`, og en assert på det ville vært
|
||
grønn mot enhver implementasjon — vakten ER kontrollen, og en alltid-sann gjentakelse av den ville
|
||
bare gjort den ekte lettere å avfeie. Load-bearing MÅLT
|
||
(`tests/test_explore_callsites_loadbearing.py`, 24 tester), sytten mutasjoner alle røde mot HELE
|
||
suiten, hver mot kontrollen som gjaldt da (990/5 for CLI-en + sporet, 996/5 for hosting, 998/5 for
|
||
sim-scenarioet, 999/5 for de to siste): detach sink-appenden (1) · andre liste
|
||
for rundene (4) · detach `--mandate`-nekten (1) · detach `--explore-config`-nekten (1) · skriv
|
||
artefaktet kun ved fullført kjøring (1) · detach CLI-ens `mandate=` (1) · slipp
|
||
`enable_plan_review` gjennom, CLI (1) · detach `--bundle-dir`-kravet, CLI (1) · detach
|
||
`--live-dry-run`-nekten (1) · fjern `--explore` fra portefølje-partisjonen (1) · videresend de
|
||
konsumerte feltene (2) · detach hostings `mandate=` (1) · detach `enable_plan_review`-nekten,
|
||
hosting (1) · detach `bundle_dir`-kravet, hosting (1) · detach sim-scenarioets `mandate=` (1) ·
|
||
detach vakuitets-vakten (1) · detach outbox/run-id-hoisten (1). **ÉN MUTASJON FALSIFISERTE TESTEN FØRST (repoets vakuøs-gate-klasse,
|
||
syvende gang):** portefølje-testen asserterte kun at meldingen nevnte `--explore`, og sto GRØNN
|
||
uten partisjonen — kjøringen falt da gjennom til «`--explore` requires `--bundle-dir`», som nevner
|
||
`--explore` også. To nekter som deler en delstreng er «assert aldri på ordlyd to grener deler»,
|
||
fanget av sin egen mutasjon; testen navngir nå `--portfolio`. **Ærlighets-grenser, uttalt:**
|
||
multi-base (`Approach.bundle_id`, § C.7) er FORTSATT ikke bygget — `run_project` tar én
|
||
`bundle_dir`; utforskningens egne modellkall er UANNONSERTE (annonseringens kontrakt er at en
|
||
KOMMISJON erklæres før arbeidet den bestiller, og før `explore()` returnerer finnes ingen —
|
||
`exploration_notice` dekker gapet i det sløyfa er ferdig); `BudgetExceeded` ut av `--explore`
|
||
tracebacker som den gjør for debatten i dag; og **den HOSTEDE flaten gir ingen innsyn i hva som
|
||
formet mandatet** — det er ingen outbox der og intet utforskningsfelt i `_response_payload`, så
|
||
ledgeren og de rådgivende dommene når kun CLI-ens artefakt. En bevisst scope-grense, men uttalt,
|
||
fordi flatens hele argument er at svaret er etterprøvbart.
|
||
- **Multi-base er en PARTISJON, aldri en videre `run_project`-signatur (U4+U13 del 3, § C.7, økt 58):**
|
||
planens § C.7 og økt 56s egen ærlighets-grense leste som om leveransen var «`run_project` tar mer
|
||
enn én `bundle_dir`». **Den kan ikke det, og nekten er STRUKTURELL:** på bundle-stien avleder
|
||
`run_project` FIRE enkeltverdier fra DEN basen — prosjektet (`_project_from_bundle`, som
|
||
fail-faster når basens egen `validator-input.json` ikke navngir det forespurte prosjektet),
|
||
validatorens stage-0-baseline (S4.0s hele poeng er at gaten er forankret i DETTE prosjektets
|
||
kostlinjer), agentenes lesekontekst og ExpeL-nøkkelen — og returnerer ETT stemplet `RunResult`.
|
||
En andre katalog på den signaturen ville tvunget et stille velg-en for alle fire, som er den
|
||
gjettede-form-klassen repoet nekter. **Planens egen setning sier det samme lest nært:**
|
||
«pipelinen kjøres per bundle som i dag (`run_portfolio`-formen)» = N kall, ikke ETT kall med N.
|
||
Premisset ble felt FØR bygging; ordren ba selv om nettopp den sjekken. **Konsekvensen er at INGEN
|
||
eksisterende kaller endrer signatur** — CLI, hosting og simulation sender fortsatt én base hver,
|
||
og kan fortsatt gjøre det. Tre sømmer: (1) `mandate.Approach.bundle_id`, default `""`, så hvert
|
||
mandat skrevet før i dag er fortsatt gyldig OG dispatchbart uendret; (2) `mandate.route_by_bundle`
|
||
— ren partisjon i `bundle_ids`-rekkefølge (aldri i approach-rekkefølge: spend-ordenen er en
|
||
egenskap ved hvordan kjøringen ble konfigurert, ikke ved hvordan en modell tilfeldigvis sekvenserte
|
||
hypotesene), **fail-fast på et mandat som ikke kan utføres som skrevet** (`load_mandate`-regelen —
|
||
en kjøring skal aldri gå videre på en stille degradert bestilling); (3)
|
||
`run.run_mandate_across_bundles` — dispatchen. **Den tar INGEN `project_id`-parameter, og det er
|
||
designet:** hver bases prosjekt leses fra DEN basens egen IR-projeksjon, altså nøyaktig verdien
|
||
`_project_from_bundle` allerede fail-faster mot, så en kaller-oppgitt konstant kunne uansett bare
|
||
vært riktig for én base av N — den eksisterende fail-fasten blir rutingsnøkkelen, og gjetningen
|
||
forsvinner. Ett `VerdictStore` trådes på tvers (kryss-base-læring, `run_portfolio`-formen), og
|
||
**delt INSTANS er påstanden — ikke lik verdi** (se vakuitets-funnet under). En base ingen approach
|
||
navngir kjøres IKKE (en kjøring koster penger, og bestillingen ba om ingenting der); med NØYAKTIG
|
||
én base absorberer den alt uten navn, som ikke er en gjetning men det eneste mulige svaret — og
|
||
det er dét som holder hvert pre-multi-base-mandat dispatchbart. `explore()` stempler `bundle_id`
|
||
på hver MYNTET approach, men **skriver ALDRI om et frø** (§ C.6 dør 1 er en bevaringsregel — å
|
||
fylle inn feltet på ekspertens vegne ville satt deres navn på en rutingsbeslutning de ikke tok);
|
||
frøene VALIDERES i stedet, **FØR første modellkall** (økt-57-hoisten: ved unntaket alene ser en
|
||
nekt etter forbruket identisk ut med en før). En umerket markør med flere baser NEKTES
|
||
(`HypothesisParseError`), med én base resolveres den. **Budsjett: de to S3.4-tennene som HAR
|
||
mening her** — oppstartsnekt (`BudgetRefused`) og aldri-startet + `budget_stop` +
|
||
`not_evaluated`-rader i `MultiBaseResult.unreached`; bølge-reservasjonen har ingen motpart, for
|
||
dispatchen er SEKVENSIELL. **Ærlighets-grenser, uttalt:** en base som RAISER propagerer
|
||
(collect-and-continue tilhører `run_portfolio`, der kalleren sendte inn en batch uavhengige
|
||
prosjekter); uten `portfolio_meter` er taket antall rutede baser × `max_tokens`, hver kjøring
|
||
bundet for seg; outboxen er IKKE wiret (N kjøringer trenger N `run_id`-er, og å mynte dem her
|
||
ville defaultet en nøkkel repoet krever at en kaller oppgir); og **CLI-en er BEVISST urørt** —
|
||
§ C.8 ber om ETT nytt kallsted i `run.py` (`--explore`, levert i 57), og et repeterbart
|
||
`--bundle-dir` er en NY operatørflate, altså en egen beslutning. Load-bearing MÅLT
|
||
(`tests/test_multibase_loadbearing.py`, 22 tester), tolv mutasjoner alle røde mot HELE suiten +
|
||
grønn kontroll 1020/5 og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): detach myntet `bundle_id` (2 røde) · stille
|
||
gjennomfall ved >1 base (1) · ukjent id resolvert etter rekkefølge (1) · frø-sjekk etter forbruket
|
||
(2 — asserten er på at NULL modellkall skjedde, ikke på unntaket) · ruteren gjetter første base (1)
|
||
· uroutbar approach droppet (1) · dispatchen kollapser til én base (5) · `project_id` fra første
|
||
base (2) · detach aldri-startet-tannen (1) · `unreached` urapportert (1) · fersk store per base (1)
|
||
· detach oppstartsnekten (2). **ÉN MUTASJON FALSIFISERTE TESTEN FØRST (repoets vakuøs-gate-klasse,
|
||
åttende gang):** store-testen sammenlignet med `==`, og `VerdictStore` er en pydantic-modell med
|
||
VERDI-likhet — tre ulike TOMME stores er alle like, så «fersk store per base» lot HELE suiten stå
|
||
grønn. Delt instans er påstanden, så testen asserterer nå på `is`.
|
||
- **«Be om svar, BRUKE svarene» er nåbar fra CLI-en, og gaten er den ANDRE halvdelen (F4, økt 63):**
|
||
før dette nektet BEGGE operatørflatene `enable_plan_review` (`run.py`, `hosting.py`) og eneste dør
|
||
var `explore(..., plan_reviewer=...)` — MÅLT mot kilden, ikke lest ut av reviewens prosa.
|
||
`--plan-review` bygger en `terminal_plan_reviewer()` og gir den til den UENDREDE sløyfa: operatøren
|
||
vises planen og svarer `approve` eller `revise <hva>`; en revisjon går tilbake til manageren, som
|
||
replanlegger og spør IGJEN om den NYE planen. **Diskriminatoren er dét siste** — en dør som printer
|
||
planen, leser linja og kaster den består «operatøren ble spurt» og feiler målbildet (repoets
|
||
vakuøs-gate-klasse); T1 er derfor bygget som `test_explore_loadbearing`s T15 løftet til CLI-nivå og
|
||
er RØD mot en alltid-godkjenn-reviewer. **Vitnet er `{run_id}-exploration.json`, ikke skrapet
|
||
stdout:** `trace_payload` bærer alt tre (rekkefølge, beslutning, feedback verbatim) og skrives fra
|
||
en `finally`, så den ene kjøringen som mest trenger beviset — den et tak eller en ubesvart review
|
||
kappet — etterlater det. **Fail-closed på operatørens EGEN input:** alt utenfor det lukkede
|
||
vokabularet spørres på nytt (aldri lest som en beslutning), og **EOF raiser `PlanReviewInputError`**
|
||
— å lese stillhet som ja ville latt en autonom sløyfe kjøre på en plan ingen signerte, usynlig.
|
||
Strømmene resolveres ved KALL-tid (`shared_root()`-idiomet), ellers svarer reviewer-en fra strømmen
|
||
som fantes da den ble BYGGET. **Fire nekter, alle ved navn**, hvorav to lukker et stille dropp
|
||
ingen test dekket: `report_forbidden` (report-modus returnerer FØR hver utforsknings-nekt) og
|
||
portefølje-partisjonen. De to konfig-avhengige nektene DELER tokenet `enable_plan_review` og har
|
||
derfor bevisst ULIK særtekst («no reviewer was offered» / «no review is ever requested») — den
|
||
eksisterende testen asserterte på det delte tokenet og er rettet (økt-57-mutasjonen, niende gang).
|
||
**Hosting NEKTER fortsatt, og det er en beslutning:** reviewen er synkron, så den ville blokkert
|
||
HTTP-requesten på et menneske OG event-løkka som svarer `/readiness` — meldingen navngir nå
|
||
CLI-døra i stedet for å påstå at biblioteket er den eneste (Fase 3-klassen). **Mid-løp-spørsmål er
|
||
IKKE bygget, og fraværet er MÅLT:** `_magentic.py` har nøyaktig ETT `ctx.request_info` (`:1044`,
|
||
plan review) i hele modulen, så stacken kan ikke levere et spørsmål midt i løpet uten en ny
|
||
emitter. Reviewens «kun plan-review FØR løpet» er derimot upresist: samme forespørsel fyrer også
|
||
ved re-plan etter en stall (`is_stalled=True`), så døra ER nåbar midt i en kjøring på den ene
|
||
måten stacken støtter. Load-bearing MÅLT (`tests/test_plan_review_cli_door_loadbearing.py`, 12
|
||
tester), elleve mutasjoner alle røde mot HELE suiten + grønn kontroll 1040/5 og golden
|
||
`demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): detach
|
||
`plan_reviewer`-wiringen (5 røde) · EOF blir en godkjenning (1) · alltid-godkjenn (3) · alt som
|
||
ikke er en revisjon blir en signatur (1) · dropp `--plan-review` fra portefølje-partisjonen (1) ·
|
||
dropp den fra `report_forbidden` (1) · detach `--plan-review requires --explore` (1) · detach
|
||
review-uten-reviewer-nekten (2, hvorav én i en test som fantes fra før) · detach
|
||
reviewer-ingen-spør-nekten (1) · hostet nekt beholder påstanden fra før F4 (1) · strømmene fanget
|
||
ved bygge-tid (1).
|
||
- **Plan-reviewen kan besvares over DAGER, og det eneste som krysser prosessgrensen er DISK (U12 +
|
||
asynkron U13, planens § D.2 rad 3, økt 64):** F4 gjorde «be om svar, BRUKE svarene» nåbar, men
|
||
bare SYNKRONT — `terminal_plan_reviewer` blokkerer løkka på et menneske ved en terminal, så
|
||
svaret må komme mens prosessen lever. `--checkpoint-dir` PARKERER i stedet reviewen
|
||
(`FileCheckpointStorage` + `{run_id}-plan-review.json`), og `--resume <run_id>` leser svaret fra
|
||
`--review-inbox` i en prosess som ALDRI så kjøringen. **MÅLT FELLE (ansikt 4):**
|
||
`list_checkpoints` (`_checkpoint.py:386-388`) svelger en blokkert deserialisering til en
|
||
`logger.warning` og returnerer TOM liste — uten BEGGE
|
||
`MagenticPlanReviewRequest`/`…Response` i `allowed_checkpoint_types` feiler en resume som et
|
||
FRAVÆR, ikke som en feil, og en test som asserterte «listingen er tom, altså er det ingenting å
|
||
gjenoppta» ville vært GRØNN mot nøyaktig den defekten. `_ALLOWED_CHECKPOINT_TYPES` har derfor ÉN
|
||
kopi og `checkpoint_storage` er ENESTE konstruksjonssted (BEGGE prosesser må deklarere dem; en
|
||
andre kopi er kø-(p)-driften). **Vi er LOUDERE enn rammeverket der det tier:** en tom listing ved
|
||
park raiser `CheckpointUnreadable` i stedet for å skrive et spørsmål ingen kan besvare.
|
||
**Diskriminatoren er den ANDRE halvdelen:** en dør som skriver en spørsmålsfil og en resume som
|
||
leser en svarfil består begge «eksperten ble spurt» — så måltesten krever at et `revise` skrevet
|
||
dag 1 får manageren til å REPLANLEGGE og stille et NYTT spørsmål (indeks 1, nytt `request_id`) i
|
||
en fersk interpreter, med en approve-kontroll som beviser at døra også kan AVSLUTTE (en gate som
|
||
bare kunne parke igjen er en hengning i løkkeklær). **Budsjettet og revisjons-capen spenner over
|
||
suspensjonen:** `meter.charge(parked.tokens_spent)` (gjennom `charge`, ikke ved å sette `tokens`
|
||
— ladingen re-tester taket) og `trace.ledger.extend(parked.ledger)`, ellers får hver park et helt
|
||
budsjett på nytt: S3.4-klassen, ubundet forbruk under vakter som alle ser tilfredse ut. En
|
||
`revise` koster to manager-kall, emitterer null ledger og bruker null runde (§ F, A3), så
|
||
`max_plan_revisions` er det ENESTE båndet på den. **Fail-closed på ekspertens EGEN fil:**
|
||
`request_id`-mismatch, ord utenfor vokabularet og `revise` uten innhold refuseres alle ved navn.
|
||
`hitl.pending_plan_reviews` er registeret over hvem som fortsatt venter — tolerant på LESE-siden,
|
||
fail-closed på BESLUTTE-siden, og joinen er på `request_id` i BEGGE ender (to distinkte sømmer,
|
||
MÅLT: hver har sin egen mutasjon og sin egen røde test). Load-bearing MÅLT
|
||
(`tests/test_async_plan_review_loadbearing.py`, 17 tester), tretten mutasjoner alle røde mot HELE
|
||
suiten + grønn kontroll 1059/5 og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): tom `_ALLOWED_CHECKPOINT_TYPES` (11 røde) · park
|
||
uten checkpoint (1) · resume alltid-approve (2) · tolerant `request_id` (1) · tolerant vokabular
|
||
(1) · `revise` uten feedback (1) · detach `meter.charge` (1) · detach
|
||
`trace.plan_reviews.extend` (1) · detach ledger/hypotese-carry-overen (1) ·
|
||
`pending_plan_reviews` ignorerer `request_id` (1) · detach to-dører-nekten (1) · detach
|
||
outbox/run-id-hoisten (1) · detach `--resume`-armen i `required_scripted_roles` (4 — MAJOR-2s
|
||
`KeyError: 'navigator'` på den andre flaten som bygger en utforskning).
|
||
**ÉN MUTASJON FALSIFISERTE SUITEN (repoets vakuøs-gate-klasse, TIENDE gang):** `trace.plan_reviews
|
||
.extend(parked.plan_reviews)` kunne detaches med HELE suiten grønn (1058/5) — capen leser
|
||
`parked.plan_reviews` DIREKTE, så den binder uansett, og de to første legene er identiske under
|
||
begge implementasjoner. Gaten måtte derfor bli det TREDJE leget, der artefaktet ellers taper dag
|
||
1s revisjon og to ULIKE planer deler indeks 1; den nye testen er rød mot mutasjonen og alene.
|
||
**Ærlighets-grenser, uttalt:** den hostede flaten NEKTER fortsatt (en synkron review ville
|
||
blokkert både requesten og event-løkka som svarer `/readiness`); en park MIDT i løpet (etter en
|
||
stall) har ingen nåbar sti under det skriptede manuset, så carry-overen som betjener den drives
|
||
gjennom en CRAFTED parkert tilstand (`budget_stop`-presedensen); og resume-legets
|
||
`PlanReviewParked` er et NORMALT utfall, ikke en feil.
|
||
- **Katalogkallet koster O(BASER), aldri O(KORPUS) — og det er stigens billigste trinn, ikke dens
|
||
dyreste (ordre `20260825T213645Z`, økt 65):** `list_bundles` returnerte hele rot-indeksens body
|
||
for HVER konfigurert base samtidig, pluss ett JSON-objekt per ufulgt kryss-lenke. Begge vokser med
|
||
korpuset, så prisen på å finne ut *hvilke baser som finnes* ble satt av hvor mye de *inneholder* —
|
||
progressiv disclosure snudd på hodet (målbilde §2/§4). **MÅLT med `o200k_base`, instrumentet først
|
||
validert mot commons' egne fasittall:** 112 116 tokens over tre flate Vegnormal-baser, og
|
||
**124 942 over de 171 grenbasene** som erstattet dem — grenformen (`vegnormal-okf` `8145c23`)
|
||
lukket bundle-siden (−82…92 % på `read_bundle`) og gjorde katalogsiden VERRE, nøyaktig som det
|
||
repoet forutså. Etter: **362** og **21 448** (per base 37 372 → 121 og 731 → 125).
|
||
**Et premiss ble felt FØR noe ble bygget på det:** «indeksbodyen forteller hva basen handler om»
|
||
er USANT for maskin-importerte baser — grenbasenes `index.md` har verken frontmatter eller prosa,
|
||
den er en ren lenkeliste (målt: 959 bytes, første tegn `-`), så feltet var dyrt OG innholdsløst
|
||
der. **Fast vindu, aldri en andel av basen** (`_CATALOGUE_EXCERPT_CHARS = 200`): en andel skalerer
|
||
med korpuset igjen, bare med mindre konstant. **Avkorting ANNONSERES som FELT**
|
||
(`index_truncated` ved siden av utdraget, aldri en markør limt inn i det — `BudgetExceeded`s
|
||
kø-(y)-regel), og en base som PASSER blir ikke merket avkortet og får hele bodyen: omisjon, aldri
|
||
en løgn i noen av retningene. **En ufulgt lenke overlever som ANTALL** — økt 51s «et hopp er
|
||
tolerert, men ikke lenger taust» står, mens per-lenke-detaljen blir liggende der den er
|
||
handlingsbar (`RunResult.skipped_links` / `DryRunReport.skipped_links`) og ikke rir med i et kall
|
||
hvis hele jobb er å være billig. Hele indeksen er fortsatt ETT `read_file(id, "index.md")` unna —
|
||
et disclosure-nivå, ikke datatap. **Taket (500 tegn/base) bor i TESTEN, ikke i `explore.py`:** en
|
||
test som importerte implementasjonens budsjett ville flyttet seg med det, og å heve budsjettet er
|
||
nøyaktig regresjonen gaten finnes for. Load-bearing MÅLT
|
||
(`tests/test_catalogue_cost_loadbearing.py`, 7 armer), **ni mutasjoner alle røde mot HELE suiten**
|
||
+ grønn kontroll 1066/5 og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): ingen binding (4 røde) · bundet men vakuøst (2) ·
|
||
stille kutt (1) · over-annonsert (1) · per-lenke-lista rir med igjen (1) · det ufulgte faktumet
|
||
slettet (1) · suffiks i stedet for ordrett prefiks (2) · en andel i stedet for fast vindu (2) ·
|
||
`documents` gjort konstant (1). **M9 ble kjørt fordi `documents` var et felt uten gate** — et felt
|
||
ingen test kan se, råtner. **MAJOR-1 var IKKE nødvendig:** bindingen sitter i verktøykroppen bak
|
||
en uendret CLI-flate. Ærlighets-grenser, uttalt: `navigate_bundle` kalles fortsatt per base per
|
||
katalogkall (I/O og veggklokke, ikke tokens — ikke målt her); ingen LEVENDE modell har kalt det
|
||
nye verktøyet, så at en manager velger BEDRE med et utdrag enn med hele indeksen er ikke bevist
|
||
(structured-output-grensens klasse); og ordrens nevner for N100:2023 var 34 mens disken viser 40 —
|
||
tallene bruker den målte nevneren. Måling: `docs/2026-08-26-katalogkostnaden.md`.
|
||
- **Et fravær ved en signeringsport sies i ORD; i dataene sies det ved å være borte (PM-tillegg 4,
|
||
økt 77):** `PlanReviewRequest.current_progress` og `ParkedExploration.current_progress` ble begge
|
||
bygget med `str(review.current_progress)`. Verdien er en `MagenticProgressLedger | None` og er
|
||
`None` i hver kjøring målt så langt, så `str()` ga de fire tegnene `None`, rendererens
|
||
truthiness-vakt fant dem ikke-tomme, og eksperten som skulle SIGNERE en plan ble vist en
|
||
«progress so far»-seksjon hvis eneste innhold var ordet `None` — og de samme fire tegnene ble
|
||
skrevet inn i `{run_id}-plan-review.json`, det ENESTE som krysser prosessgrensen i U12s asynkrone
|
||
dør. `_progress_text` er den ENE konverteringen (ved siden av `_plan_text`): fravær blir tom
|
||
streng, aldri `"None"`. **Datalaget sier fravær ved å være tomt** (`Bundle.skipped`s
|
||
tom-tuppel-regel), mens **TERMINALEN sier det i ord** — det er den ene flaten der omisjon er
|
||
feil, fordi stillhet ved en port noen signerer er nøyaktig dét `PlanReviewInputError` alt nekter
|
||
for EOF. **Målingen endret testen:** å reversere BEGGE kallsteder lot KUN en kildeinspeksjons-arm
|
||
bli rød — en lint, ikke en gate, fordi de første armene konstruerer en `PlanReviewRequest` selv og
|
||
aldri går inn i noen av stedene. Hvert sted har nå et ATFERDSMESSIG vitne som driver den EKTE
|
||
døra: terminalen for den synkrone, den parkerte spørsmålsFILA for den asynkrone. Load-bearing
|
||
MÅLT (`tests/test_plan_review_progress_line_loadbearing.py`, 7 armer), fem mutasjoner alle røde
|
||
mot HELE suiten, hver med sin egen signatur + grønn kontroll 1202/5 og golden BYTE-UENDRET:
|
||
begge steder reversert (3 røde) · det synkrone alene (2) · det parkerte alene (2) · terminalen går
|
||
stille igjen (2) · plassholderen fyrer alltid og sluker en ekte ledger (1, kontrollen alene).
|
||
Recorder-wiringen i `resume_exploration` er URØRT (uvitnet, defensiv — S2b).
|
||
- **`evidence_for` avleder en tier KUN for nøkkelen SPEC §5.3 tierer (PM-tillegg 5, økt 77):**
|
||
`evidence_for(path, key="sources")` REISTE `ValueError`. Tieren ble avledet UBETINGET gjennom
|
||
`trust_tier`, som nekter en oppføring uten `by`-aktør — riktig, fordi en tillitsgrad avledet av
|
||
en oppføring som identifiserer ingen mynter den proveniensen den påstår å lese. Men `by` er
|
||
påkrevd av en VERIFIKASJONS-oppføring (SPEC §5.2), ikke av enhver provenienss-nøkkel: den avtalte
|
||
segmenterte formen bærer `segment_id`/`source_offset`, en `sources`-liste bærer `id`/`resource`.
|
||
Vakten tilhørende ÉN nøkkel ble anvendt på ALLE. **`trust_tier` er URØRT** — `_TIERED_KEY` navngir
|
||
den ene nøkkelen §5.3 tierer, og enhver annen nøkkel kommer tilbake med
|
||
`state`/`reason`/`items_seen`/`entries` og `tier=None`. **`admits_falsification` flyttet MED, og
|
||
det er samme faktum, ikke scope-krype:** den leste `tier != "unverified"`, og `None != "unverified"`
|
||
er SANT, så en `sources`-liste som FINNES ville klarert en terskel om verifisering; den navngir nå
|
||
tierene som klarerer. For hver verdi som var nåbar før endringen er de to skrivemåtene identiske —
|
||
derfor står de eksisterende K5-armene grønne, og derfor er dette en innstramming og ikke en ny
|
||
regel. **Målingen korrigerte testen:** en `verified`-verdi UTEN aktør når aldri `trust_tier`
|
||
gjennom `evidence_for` i det hele tatt — dekoderen nekter formen først, som
|
||
`unreadable`/`unsupported-flow`; begge vakter asserteres nå der hver av dem FAKTISK bor.
|
||
**Defekten fantes fordi parameteren aldri var ØVET:** alle 11 kallsteder brukte defaulten (målt
|
||
ved B4s slutt). Load-bearing MÅLT (`tests/test_evidence_key_parameter_loadbearing.py`, 6 armer),
|
||
fire mutasjoner alle røde mot HELE suiten + grønn kontroll 1208/5 og golden BYTE-UENDRET: avled
|
||
tieren ubetinget (3 røde) · reverter K5-terskelen (1, konsekvens-armen alene) · «fiks» det ved
|
||
aldri å tiere (3, inkludert to eksisterende falsifiserings-armer) · løsne `trust_tier` i stedet
|
||
(2, inkludert dens egen eksisterende gate).
|
||
- **`read_bundle` koster O(DOKUMENTER i én base), aldri O(bytes av den — S2c/MAJOR-3, økt 77):**
|
||
verktøyet returnerte `okf.bundle_context`, altså HELE den navigerte basen, og fordi utforskningens
|
||
deltakere deler ÉN samtalehistorikk red det ene `function_result`-et med i **hver senere prompt**
|
||
til full pris uten at noen ba om det igjen. **MÅLT FØRST, med nevner, og committet som docs før én
|
||
linje kode ble rørt** (`docs/2026-09-02-read-bundle-kontekstkostnad.md`): 3 861 / 10 406 / **12 595**
|
||
o200k-tokens for de tre eksempelbasene, **5 kopier** per CLI-`--explore`-kjøring (navigatør ×1,
|
||
manager ×3, hypotesiser ×1) = **54 % / 59 % / 59 %** av ALLE prompt-tokens. Instrumentet ble
|
||
validert mot en KJENT POSITIV før bruk (det reproduserte commons' egne publiserte
|
||
`bundle_context`-fasittall eksakt), og prompten måles som tekst + `function_call` +
|
||
`function_result` — `.text` alene måler en kontekstbærende prompt til noen få tegn.
|
||
**Formen er katalogens, ett trinn ned på stigen** (`list_bundles` = hvilke baser finnes,
|
||
`read_bundle` = hva er i DENNE, `read_file` = hva sier dokumentet): én oppføring per konseptfil med
|
||
`name`, `type`, `title`, `chars`. Etter: **259 tokens** på tunnelbasen, utforskningens
|
||
prompt-tokens −77 / −90 / **−91 %**. **Listen bygges av `Bundle.context_files`, ALDRI `files`** —
|
||
det er dén property som dropper `type: verdict`-laget (og nestede `index.md`) på hvert nivå, og en
|
||
liste bygget av `files` ville rutet tidligere dommer foran navigatøren UTENOM den gatede
|
||
ExpeL-folden mens hver kostnads-arm forble grønn. **Et premiss ble felt før noe ble bygget på det:**
|
||
«indeksbodyen er basens egen navigasjonsprosa, så den hører hjemme her» — tunnelbasens rot-indeks er
|
||
**alene 4 763 tegn ≈ 1 400 tokens**, altså nesten hele taket, for et felt katalogen alt gir et
|
||
bundet utdrag av og `read_file(id, "index.md")` fortsatt gir helt. **Taket bor i TESTEN**
|
||
(`_CEILING_CHARS = 1 500`), katalogtakets regel av katalogtakets grunn. **AVVIK fra ordren, uttalt:**
|
||
ordren ordlegger gaten i o200k-TOKENS; gaten bounder TEGN, fordi `tiktoken` ikke er en
|
||
prosjektavhengighet og en gate som skipper når en valgfri pakke mangler er en gate som kan være
|
||
stille fraværende — konverteringen er MÅLT (748 tegn / 259 tokens = 2,89 tegn/token), og ordrens
|
||
eget kriterium er verifisert direkte én gang av instrumentet. **«Ikke utløs» er bevist som en
|
||
MÅLING, ikke som en forsikring:** debattens tre `okf.bundle_context`-kopier er **byte-identiske før
|
||
og etter** i alle tre baser (12 047 / 32 567 / 39 104 prompt-tokens, hver prompt uendret) — sterkere
|
||
enn å påstå at `run.py` ikke ble rørt. **Verktøybeskrivelsen og navigatørens instruksjon er oppdatert
|
||
i samme trekk:** begge påsto «read its navigated context», og en beskrivelse som lyver om kroppen er
|
||
modellens instruks (Fase 3-klassen, påstander flaten gjør om SEG SELV). **To eksisterende asserts
|
||
ville blitt VAKUØSE i stillhet** (`read_bundle(...) != ""` er sant for enhver liste,
|
||
`test_explore_loadbearing.py` + `test_bundle_id_reconciliation_loadbearing.py`) og er styrket, ikke
|
||
latt stå. Load-bearing MÅLT (`tests/test_read_bundle_cost_loadbearing.py`, 6 armer), **sju mutasjoner
|
||
alle røde mot HELE suiten** + grønn kontroll **1 195/5** (fra 1 189/5, supersett, 0 fjernet) og golden
|
||
`demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): reverter sømmen
|
||
(7 røde) · bygg fra `files` (3) · bundet men VAKUØS tom liste (6) · dropp `chars` (2) · bær
|
||
indeksbodyen likevel (4) · `read_file` trunkerer (2 — inkludert katalog-gaten, et uavhengig vitne) ·
|
||
detach `reconcile_bundle_id` (1). **Ærlighets-grenser, uttalt:** dette er IKKE «−59 % kostnad» — en
|
||
navigatør som åpner *k* dokumenter betaler *k* `read_file`-resultater, og gevinsten er at den betaler
|
||
for det den VALGTE og at hvert resultat rir fra SITT kall og framover; at en LEVENDE modell velger
|
||
BEDRE med en liste enn med hele konteksten er IKKE bevist (structured-output-grensens klasse);
|
||
multiplikatoren 5 gjelder dette manuset (`misjonsreview-v2` § 4 målte 7× med et annet); debattens 3×
|
||
er PM-ens egen beslutning og er urørt; prefiks-caching (≈ 60 % debatt / ≈ 40 % utforskning cachebart
|
||
som koden står) er NOTERT, ikke bygget. **Et fravær som var instrumentfeil, ikke faktum:** første
|
||
ETTER-kjøring rapporterte 0 kopier på to baser — sonden var en midtskive som traff norske tegn
|
||
prompten serialiserer escaped; byttet til et ASCII-konseptfilnavn ga 5, som før.
|
||
- **Ekspertdommen kan ikke oppstå av STILLHET, og fraværet er en FØRSTEKLASSES tilstand (F2,
|
||
non-goal 3, økt 66):** `run_project` KREVDE `verdict_input` og kjørte `capture_verdict`
|
||
ubetinget, CLI-en defaultet det til `{"approved", "reviewed by expert"}`, og hosting listet det
|
||
som PÅKREVD. Netto: hver flaggløs kjøring myntet en ekspertgodkjenning ingen ga, den gikk inn i
|
||
den delte storen, og `run_portfolio` bar den inn i neste prosjekts hypotese-prompt som en
|
||
*prior expert verdict* — på flaten som ble overlevert 14.08. **`RunResult.verdict` er nå
|
||
`Verdict | None`**, og `None` er hva stillhet produserer: ingenting myntes, ingenting lagres,
|
||
ingenting varsles. Prinsippet sto allerede skrevet i repoet — `RunFailure`s docstring: å fylle et
|
||
felt med en dummy legger FABRIKKERT proveniens inn i aggregatet. **Traceability koster ingenting,
|
||
fordi nøkkelen DERIVERES fra kandidaten:** `RunResult.verdict_key` (property, ikke lagret felt —
|
||
en andre kopi av en nøklingsregel er kø-(p)) er `verdicts.verdict_key`s alt dokumenterte formål,
|
||
identisk med `verdict.id` når en dom BLE gitt, og fortsatt meningsfull når ingen ble det; det er
|
||
den outboxen og den hostede responsen stempler, så et artefakt fra en ukommentert kjøring er
|
||
fortsatt dømbart og joiner tilbake via Steg-7-innboksen. **Halv dom NEKTES på begge dører**
|
||
(`FeedbackContract` er ENESTE sted formen valideres, og CLI-en nekter ved navn FØR enhver
|
||
mode-dispatch): den manglende halvdelen er ekspertens å skrive, aldri vår å defaulte — validering,
|
||
ALDRI reparasjon (`write_concept_file`-presedensen). **Hosting er WIDENING, ikke bryting:**
|
||
`verdict_input` flyttet `_REQUIRED_FIELDS` → `_OPTIONAL_FIELDS`, så hvert kall som finnes ute
|
||
virker uendret; en kaller som utelot det fikk før 400 på et felt som ikke KUNNE fylles ærlig.
|
||
**De to mode-partisjonene fikk `--decision`/`--rationale` inn — og det er en KONSEKVENS, ikke
|
||
scope-krype:** kommentarene på begge stedene sa ordrett at en ærlig nekt var *uimplementerbar*
|
||
fordi de non-None argparse-defaultene gjorde en eksplisitt verdi uskillbar fra defaulten. Med
|
||
defaultene borte er den implementerbar, og «refused, never ignored» er partisjonens egen regel.
|
||
`run.verdict_notice` er ENESTE renderer og leser dommen av kjøringens EGET stempel, ikke av argv.
|
||
**Ærlighets-grense, uttalt:** referanse-fixturens SYNTETISKE `verdict_input`-rader står URØRT —
|
||
de er merket SYNTETISK på fire steder og er reviewens F5 (måling av misjonspåstanden), ikke F2;
|
||
`Project.verdict_input` er nå valgfri, så en rad UTEN dom er lovlig. Load-bearing MÅLT
|
||
(`tests/test_ungiven_verdict_loadbearing.py`, 15 armer), **åtte mutasjoner alle røde mot HELE
|
||
suiten** + grønn kontroll 1080/5 og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): detach fangst-gaten (5 røde) · gjeninnfør
|
||
argparse-defaultene (22) · hosting krever fortsatt feltet (1) · CLI-en REPARERER en halv dom (2) ·
|
||
kontrakten reparerer en halv dom (1) · `verdict_key` lest av dommen i stedet for derivert (2) ·
|
||
begge partisjons-radene fjernet (2) · rendereren påstår en dom som aldri ble gitt (2). **ÉN
|
||
MUTASJON FALSIFISERTE TESTEN FØRST (repoets vakuøs-gate-klasse, ELLEVTE gang):** `--report`-armen
|
||
brukte et bart `--report`, som nekter med rc 1 uansett fordi `--ledger` mangler — testen sto
|
||
GRØNN med partisjons-raden fjernet. Den kjører nå mot en argv report-modus ellers ville AKSEPTERT
|
||
(gyldig `--ledger` + en kontroll som beviser rc 0 uten flaggene), så rc 1 er mutantens motsatte
|
||
utfall. **Migreringsnote:** ingen ekstern kaller brekker — hosting utvider, CLI-ens gamle
|
||
flaggform er uendret, og det som ENDRER seg er at en flaggløs kjøring nå SIER at ingen dømte i
|
||
stedet for å påstå `decision=approved`.
|
||
- **Planen et menneske signerer er TEKST, aldri en objekt-repr — og fraværet av repr er en EGEN,
|
||
bredere assert (BLOCKER-1, økt 67):** fire steder gjorde `str(review.plan)` på en MAF `Message`
|
||
som ikke har noen `__str__` (MÅLT: `type(Message).__str__ is object.__str__`), så BEGGE
|
||
HITL-dørene viste og lagret `<agent_framework._types.Message object at 0x…>`: terminalen F4
|
||
spør ved (`explore.py:1395`), de to opptakene i `plan_reviews` (`:1404` approve, `:1418` revise)
|
||
og den PARKERTE spørsmålsfila U12 (`:1478`) — det ENESTE som krysser prosessgrensen. En ekspert
|
||
som svarte `approve` signerte blindt. Fiksen er den eksisterende `_plan_text` (`:966`) på alle
|
||
fire; ingen ny hjelper. **Fire asserts var grønne mot defekten fordi de var TRUTHINESS eller
|
||
SELV-SAMMENLIGNING:** `reviews[1]["plan"] != ""`, `waiting[0].plan`, og
|
||
`reviews[0]["plan"][:40] in out` — den siste sammenlignet den samme repr-en med seg selv, så de
|
||
to flatene var enige mens begge var uleselige. Diskriminatoren er innhold som KUN kan komme av
|
||
`Message.text`: MAF komponerer plan-meldingen rundt managerens svar ORDRETT (målt), så en
|
||
sentinel i det skriptede svaret er til stede når teksten ble tatt og fraværende når repr-en ble
|
||
det. Sentinelen bor i et `reason`-felt fordi ingenting leser dem — å nøkle den til en ANSWER
|
||
ville endret kjøringen den måler. **`str(review.current_progress)` (`:1396`/`:1479`) er BEVISST
|
||
urørt:** den er en `MagenticProgressLedger | None`, ikke en `Message`, og pydantic renderer den
|
||
lesbart (målt) — men i disse kjøringene er den `None`, så terminalen skriver «progress so far:
|
||
None». Annen defekt, annen ordre. Load-bearing MÅLT
|
||
(`tests/test_plan_review_cli_door_loadbearing.py` + `tests/test_async_plan_review_loadbearing.py`),
|
||
fire mutasjoner — **ÉN PER LINJE**, fordi ordrens ene samlede revert undertestet og `:1418` er
|
||
revise-grenens egen kopi som ellers ikke hadde noe rødt vitne: `:1395` → 1 rød (stdout) ·
|
||
`:1404` → 2 · `:1418` → 1 (T1 alene) · `:1478` → 1 (async T9). Golden byte-uendret.
|
||
- **Generalprøven kan ÅPNE en base, og artefaktet sier hvilken (MAJOR-1, økt 67):** `--scripted-replies`
|
||
tok ÉN konstant streng per rolle, så ingen skriptet rolle kunne emittere et `function_call` —
|
||
MÅLT 0 verktøykall / 0 approaches / 1 runde på 4/4 baser, mens hvert annet felt i
|
||
`{run_id}-exploration.json` så ut som en kjøring som hadde virket. Måleprotokollens gratis trinn
|
||
(«bevis så mye som mulig før det dyre») kunne altså ikke bevise at navigatøren åpner noe, og
|
||
etter en BETALT kjøring kunne ingen lese om den gjorde det. To halvdeler, hver gatet så den ANDRE
|
||
ikke kan bære den. **(a) `ExplorationToolRecorder`** — en `FunctionMiddleware` på
|
||
utforskningsagentene som registrerer NAVN + `bundle_id`-argumentet i KALL-REKKEFØLGE på den
|
||
kaller-eide `ExplorationTrace`; `trace_payload` skriver det ved siden av `quick_validations`.
|
||
**SØSKEN av `mcp_tools.ToolCallRecorder`, aldri en gjenbruk:** den filtrerer til KONFIGURERTE
|
||
eksterne verktøy, dedupliserer per `(server, tool)` og returnerer SORTERT, fordi dens rad er en
|
||
egress-påstand; denne beholder rekkefølge uten dedup, fordi et sortert dedupet sett ikke kan
|
||
skille en generalprøve som LESTE en base fra en som bare listet dem. Å generalisere den ene til å
|
||
tjene begge ville brutt den andre. RESULTATET registreres ALDRI — det er basens innhold, altså
|
||
nettopp det MAJOR-3 målte til 73–93 % av alle prompt-tokens. Wiret i BEGGE workflow-byggene
|
||
(`explore()` OG `resume_exploration()`) — men **resume-armen er DEFENSIV og UVITNET, og det er
|
||
målt, ikke antatt** (`budget_stop`-presedensen): å detache KUN den andre forekomsten lot hele
|
||
suiten stå grønn (1087/5), fordi ingen park/resume-scenario under det skriptede manuset når en
|
||
verktøykropp. Den står fordi et gjenopptatt leg ellers ville registrert null verktøykall — samme
|
||
stille gap som `plan_reviews.extend` i økt 64 — ikke fordi en test holder den.
|
||
**(b) et trinn-MANUS** — en utforskningsrolle kan få en LISTE der et trinn er tekst eller ETT
|
||
`{"call": "<tool>", "args": {…}}`. Formen utvider den ENE kanoniske `_inner_get_response`-kroppen
|
||
(S2.5), aldri en andre klient: manuset ligger VED SIDEN AV selektoren (en selektor returnerer
|
||
`str` ved kontrakt, og et verktøykall er ikke tekst), og et utløpt manus faller tilbake på
|
||
selektoren — degradering til konstantformen, ikke til stillhet. Listeformen NEKTES for debattens
|
||
roller ved navn, og hvert malformet trinn nektes ved navn (validering, ALDRI reparasjon).
|
||
**Å skripte navigatøren er IKKE nok, og det er MÅLT:** med en KONSTANT manager konkluderer
|
||
kjøringen etter én runde uten å ha gitt noen deltaker en tur, så `tool_calls` forblir tomt
|
||
uansett hva navigatøren fikk. Manageren må selv få et trinn-manus — én tekst per stadium (fakta,
|
||
plan, ledger, ledger, sluttsvar), samme grunn `simulation._exploration_manager_reply` nøkler på
|
||
PROMPTEN og ikke prosjekt-ID-en: manageren får fem ULIKE spørsmål og én konstant svarer alle fem
|
||
med første rundes ledger. Kontroll-testen med konstant navigatør (og manager i stadier) er dét
|
||
som holder de to formene fra hverandre.
|
||
Load-bearing MÅLT (`tests/test_scripted_explore_door_loadbearing.py`, 12 armer), **ni mutasjoner
|
||
alle røde mot HELE suiten** + grønn kontroll 1087/5 og golden BYTE-UENDRET: detach recorderen
|
||
fra begge byggene (1) · dropp `tool_calls` fra `trace_payload` (3) · sorter+dedupliser sinken (2)
|
||
· registrer navnet uten basen (3) · nekt listeformen igjen (2) · aksepter lista men emitter tekst
|
||
(1) · toler et malformet trinn (1) · la en debattrolle ta listeformen (1) · dropp
|
||
ukjent-nøkkel-whitelisten (1). **ÉN MUTASJON FALSIFISERTE TESTEN FØRST (repoets
|
||
vakuøs-gate-klasse, TOLVTE gang):** nekt-testen brukte `{"invoke": …}` og sto GRØNN med
|
||
forms-sjekken detached — UKJENT-NØKKEL-grenen fanget den i stedet, så nekten under test hadde
|
||
intet vitne. To grener, to armer, to mutasjoner. Ærlighets-grense, uttalt: at en LEVENDE modell
|
||
kaller verktøyene er fortsatt ikke bevist (structured-output-grensens klasse) — dette gjør den
|
||
GRATIS halvdelen av stigen ekte, ikke den betalte.
|
||
- **MAF-pinnen er en TRIPWIRE, ikke en frys — og det som gjorde løftet farlig var IKKE en form som
|
||
forsvant (F15, 02.09, core 1.9.0 → 1.16.0, orchestrations 1.0.1 → 1.1.1):** de to kan ikke løftes
|
||
hver for seg (orchestrations 1.1.1 krever selv `core>=1.15.0`). Gulvet bor i ÉN konstant
|
||
(`_MIN_VERSION` i `tests/test_maf_version_guard.py`) og `pyproject`-asserten DERIVERER sin
|
||
forventede streng fra den — to literaler for ett faktum drifter (kø-(p)), og et driftet gulv er en
|
||
vakt som slutter å vokte uten én lokal diff. **17 private/ugaranterte former, derivert fra repoets
|
||
EGNE siteringer** (hver `_modul.py:linje`-referanse i `src/` + hver form en søm overstyrer eller
|
||
konstruerer); **16 sjekket MEKANISK av en probe mot begge versjoner (1 endret), den 17. funnet av
|
||
TESTSUITEN (endret) — 2 endret totalt.** Splitten er ikke pedanteri: «2 av 16» ville tilskrevet
|
||
proben et funn den ikke gjorde, og skjult at proben sjekker statiske egenskaper ved KILDEN mens den
|
||
farlige endringen var en egenskap ved KJØRINGEN — nevner-disiplin anvendt på mitt eget instrument. Kjent-positiv: `MiddlewareFailure`
|
||
(ny i 1.15.0) flippet NO → YES, altså KAN proben oppdage endring; `_compaction.py`s
|
||
`@experimental`-markører ble FORKASTET som kjent-positiv fordi de teller 0 i BEGGE versjoner og
|
||
derfor ikke diskriminerer noe. **Den farlige endringen var den ordren navnga — formen som fortsatt
|
||
importerer, men har flyttet semantikk i stillhet:** en park skriver nå **TO** checkpoints og bare
|
||
ÉN bærer plan-review-typen, så en feildeklarert `_ALLOWED_CHECKPOINT_TYPES` **tømmer ikke lenger
|
||
listingen** — den taper nøyaktig den checkpointen som betyr noe, `get_latest` returnerer den ANDRE,
|
||
og `_park`s `latest is None`-vakt passerte mens kjøringen svarte `rc=0` og skrev et spørsmål som
|
||
aldri kan bære svaret. Vakten sjekker nå EGENSKAPEN den alltid mente (`str(request.request_id) in
|
||
latest.pending_request_info_events` — et DEKLARERT felt) i stedet for symptomet som pleide å
|
||
innebære den, og fjerner dermed en privat avhengighet i stedet for å legge til en. **`ExperimentalWarning`-paret
|
||
P4 pkt. 2 betalte for å BEHOLDE er borte fordi MAF sluttet å sende det** — `_feature_stage.py`s
|
||
`_add_runtime_warning` emitterer ved FØRSTE BRUK, ikke ved import, og demoen instansierer ingen av
|
||
de to typene; goldenens stderr er derfor TO linjer, regenerert som en BESLUTNING, mens
|
||
`site-packages`-maskeringen er BEHOLDT (spannet er ubebodd, ikke pensjonert) og
|
||
`test_normalisation_does_not_mask_a_new_warning` fortsatt er grønn. Load-bearing MÅLT mot HELE
|
||
suiten, grønn kontroll **1089/5** og `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 revert av vakten → 1 rød. **ÉN MUTASJON BLE IKKE
|
||
RØD, og det står som en ÆRLIGHETS-GRENSE, ikke som en gate:** spikens gjenopptak fra
|
||
`checkpoint_ids[-1]` (siste element i en glob-ordnet listing — nøyaktig anti-mønsteret `_park`s
|
||
docstring advarer mot) feilet i den første fullkjøringen etter bumpen og var GRØNN ved mutasjonen,
|
||
altså rekkefølge-avhengig og flaky. Fiksen står på den observerte feilen, ikke på et rødt vitne.
|
||
Rapport: `docs/2026-09-02-f15-maf-pinnen.md`.
|
||
- **Falsifisering MOT PROVENIENS: en dom hviler på det basen faktisk BÆRER, og det den ikke kunne
|
||
fortelle deg er en del av dommen (B4, Steg 1–13, økt 75+76):** `parse_frontmatter` er
|
||
linjeorientert og leser en flow-verdi som ÉN streng, så `verified: { by: …, at: … }` — SPEC §5.2s
|
||
kanoniske form — nådde konsumenten som ulesbar tekst, og en blokkform nådde den som **tom** streng.
|
||
Begge så ut som «ingen proveniens». **Den defekten er den samme fra begge sider, og produsenten
|
||
MÅLTE den selv:** `llm-ingestion-okf`s egen guard-parser avviser sin EGEN golden
|
||
(`docs/okf-nokkelinventar.md:219`, `OKFFrontmatterError … '['`) — bekreftet på nytt ved Steg 13 mot
|
||
`62b6192`. **Ett skann, to LESERE, aldri to parsere:** `_split_frontmatter` er modulens ENESTE sted
|
||
`---` sammenlignes (gatet av en skanner-tellende arm, M14 → 1 rød), og `decode_flow_value` er den
|
||
ene navngitte sømmen over de rå linjene. Dekoderen er **nøkkel-agnostisk** (aldri hardkodet
|
||
`{id, resource}` — den avtalte segmenterte formen legger til `segment_id`/`source_offset`, så en
|
||
to-nøkkels dekoder ville nektet nøyaktig de basene sømmen finnes for; M3 → 12 røde) og gjør
|
||
**ingen YAML-1.1-koersering** (`yes`/`on`/`1` forblir strenger — en bevisst divergens fra PyYAMLs
|
||
resolver, skrevet ned i stedet for arvet i stillhet; M4 → 1 rød, en ratchet grønn ved
|
||
konstruksjon).
|
||
**Tre tilstander, og den tredje ER poenget:** `evidence_for` svarer `present` / `absent` /
|
||
`unreadable`, og den ulesbare bærer trippelen `(state, reason, items_seen)` — «hvilken FORM» og
|
||
«hvor MANGE» er to ulike operative spørsmål, `BudgetExceeded`-kø-(y)-regelen anvendt på en
|
||
dokumentleser. Å kollapse `unreadable` inn i `absent` gjør en dom om MANGLENDE bevis til bevis for
|
||
FRAVÆR (M7 → 4 røde); å rapportere én fast form for alle (M8 → 9 røde). K5-terskelen bor ÉTT sted
|
||
(`admits_falsification`: `present` OG en tier over `unverified`) og har TO konjunkter som måles
|
||
hver for seg (M19a → 2 røde, M19b → 1 rød). **Nevneren er skrevet ned:** SPEC §5.1 navngir SEKS
|
||
oppføringsnøkler og produsenten skriver TO (`62b6192`), så terskelen krever kun det som faktisk
|
||
emitteres — å kreve `author`/`usage_count`/`last_modified` ville gjort den unåbar i praksis mens
|
||
den så streng ut på papiret. **`adjudication` har en TREDJE token som er VÅR:** vokabularet på
|
||
tråden er lukket (`proposed` | `adjudicated`), og `unknown` er hva FRAVÆR betyr — aldri noe et
|
||
dokument får erklære (M20a → 2 røde), og en bærer som gir fra seg en payload uten tilstanden er
|
||
vokabularet uten sømmen (M20b → 1 rød). **`evidence_for` KUNNE IKKE drive den** (D-e → 5 røde):
|
||
MÅLT er `adjudication` en SKALAR, og begge gyldige verdier kommer tilbake som ETT identisk
|
||
`unreadable`/`unsupported-flow`-record, så den ruten kan ikke skille dem i det hele tatt;
|
||
`parse_frontmatter` er skalarleseren over SAMME skann.
|
||
**Skriveren nekter nøyaktig det leseren ikke kan lese**, og det er strukturelt, ikke en konvensjon:
|
||
`verified_field` og `write_concept_file` reiser den SAMME navngitte `FlowDecodeError` (M5 → 5 røde,
|
||
M16 → 3 røde, M17 → 1 rød). Det usikre tegnsettet er TRANSKRIBERT fra produsentens eget
|
||
`_FLOW_UNSAFE_RE` (`materialize.py:176`, `[,\[\]{}]|:\s`) — ikke oppfunnet — og er BEVISST
|
||
smalere: vår parseparator er kolon-MELLOMROM, så `":\t"` kan ikke restrukturere en av våre par.
|
||
**Ko-drift er stengt av skrivesidens gate, ikke bare oppdagbar via en ekstern referent:** planen
|
||
spådde at M9 (skriver OG dekoder flyttes til blokkform sammen) ville la rundturen stå GRØNN.
|
||
**MÅLT er den spådommen ikke konstruerbar** — skriveren kan ikke flytte alene (M9a → 26 røde + 8
|
||
feil), fordi `render_frontmatter` enlinjer hver verdi OG `write_concept_file` nekter formen; M9
|
||
krevde derfor at BEGGE vaktene ble slått av samtidig, og ga 17 røde inkludert rundturen. Det er et
|
||
sterkere utfall enn planen ba om, og det er skrevet ned som målt, ikke som spådd.
|
||
**Navigasjonen forblir TOLERANT mens dekoderen nekter** (OKF SPEC §4), bevist med BYTES: M10 →
|
||
**1 rød, ett navngitt vitne**, mens begge nav-goldenene og demo-transkriptet står.
|
||
**Identitet er PARET `(bundle_id, concept_id)` (D6/B1), og `origin` har TRE verdier:**
|
||
`okf.reconcile_bundle_id` er den ENE avledningsregelen — konseptets egen frontmatter først, rot-
|
||
`index.md` som fallback, mountets basename til sist — og `ResolvedBundleId.origin` sier hvilken
|
||
(`declared-concept` / `declared-index` / `mount-derived`). **Påkrevd uten default**, av
|
||
`cost_baseline_anchored`s grunn: begge defaults ville løyet om en hendelse. **Ikke en boolean** —
|
||
en kaller som ikke kan skille «konseptet sa det» fra «vi falt tilbake to ganger» har fått et
|
||
stempel den ikke kan revidere (D-i → 3 røde). **MÅLT: null `^bundle_id`-treff** noe sted under
|
||
`shared/`, `src/`, `tests/` mot en kjent-positiv kontroll på 31 filer med `^type:`, så begge
|
||
erklærte grener er DEFENSIVE (`budget_stop`-presedensen) og drives fra CRAFTED baser; alle 27
|
||
`bundle_dirs=`-kallsteder står grønne. **⚠️ TO SETNINGER I DENNE RADEN ER ENDRET 03.09 — se
|
||
slakke-raden nederst (S7a-3 pkt. 1):** mount-avviket NEKTER ikke lenger (erklært vinner), og
|
||
«begge erklærte grener er DEFENSIVE» gjelder kun dette repoet — K2 erklærer nøkkelen i 619 filer. **`explore._bundle_index` forblir REN** — to av dens egne
|
||
armer konfigurerer kataloger som ikke finnes og forventer en id-feil, ikke en I/O-feil — så
|
||
avstemmingen skjer der en base faktisk ÅPNES: `explore.read_bundle` (M11a → 1 rød),
|
||
`run_project`s bundle-arm (M11b → 2 røde) og dispatcheren (M11c → 1 rød, som erstattet en privat
|
||
`Path(raw).name`-kopi). En base uten lesbar `index.md` er **ukjent, ikke uerklært** —
|
||
`navigate_bundle`s fail-fast propagerer. `BundleIdMismatch` subklasser `ValueError` så den lander
|
||
på CLI-ens nekt-tuppel og hostings 400-arm, aldri krasj-kanalen; nekten måles på **null
|
||
modellkall**, ikke på exit-koden (M12 → 2 røde. **Ærlighets-grense, MÅLT:** planens påstand
|
||
«exit-koden forblir 1 uansett» HOLDER IKKE for denne argv — mutanten reiser
|
||
`BudgetExceeded: rounds limit=12 observed=13` før noen nekt, så sink-asserten nås aldri. Asserten
|
||
på KALL er likevel riktig design; den er det som ville fanget en nekt-etter-forbruk som DID
|
||
returnerte rent).
|
||
**En kryss-base-kollisjon rapporteres, aldri droppet i stillhet (D2):** `VerdictStore.add` er
|
||
first-write-wins og `_mint_id` ekskluderer korpuset ved konstruksjon, så to baser som beskriver
|
||
SAMME kandidat kollapser på én dom. `_mint_id` er URØRT (normativ i `shared/method-spec.md`,
|
||
commons-eid) og `add` likeså — en drop DER kan like gjerne være mot en Steg-7-innboksdom eller et
|
||
bundle-frø. Regnskapet bor i dispatcheren, som er det ENE stedet som holder id→base-kartet
|
||
(M13 → 2 røde). **Id-en hentes fra `run_project`s EKSISTERENDE `notify`-søm, aldri fra
|
||
`RunResult.verdict`** (D-l): `notify` fyrer INNE i fangst-blokka, altså nøyaktig når en dom finnes
|
||
(F2), og båsen bygges FERSK hver iterasjon — hoistes den ut, leser en senere base forrige bases dom
|
||
og fabrikkerer en kollisjon som aldri skjedde (D-l → 1 rød). `MultiBaseResult.collisions`
|
||
DEFAULTER til tom tuppel (`skipped_links`-halvdelen: en tom trace er et ærlig POSITIVT utsagn), og
|
||
`collision_notice` returnerer `None` på den — omisjon, aldri tom rad.
|
||
**Metoden er en DELT Agent Skill, forfattet i commons (D4):** `shared/skills/falsification-
|
||
reviewer/` kommer KUN via `git subtree pull` — lokal forfatting ville gitt et wheel søskenet aldri
|
||
arver, og INGEN test i suiten oppdager det avviket. Terminologi-gaten er den som biter
|
||
(`OKF bundle` i kundevendt prosa → M18a, 1 rød), og den er paret med en KJENT-POSITIV kontroll på
|
||
at regexen KAN finne strengen. Rammeverks-nøytraliteten har ÉN kopi
|
||
(`test_method_spec_is_framework_neutral`), utvidet av Amendment 2 fra `expert-reviewer` alene til
|
||
`GUARDED_SKILL_DIRS` — den nye skillen hadde ingen vakt i det hele tatt (M18b → 1 rød, egen
|
||
signatur) — pluss en fail-closed arm som blir rød når et fremtidig subtree-pull bringer en TREDJE
|
||
skill som ikke er listet. Det verkede eksempelet materialiseres fra `frontmatter_verbatim`
|
||
ORDRETT (Amendment 3): den linjeorienterte `frontmatter`-projeksjonen kan ved konstruksjon ikke
|
||
bære blokkform, så å bygge fra den ville gjort det ulesbare tilfellet `absent` og armen ville stått
|
||
GRØNN mens den beviste det motsatte av sin egen docstring. Eksempelets egen dom er `undecided`, ikke
|
||
`survived` — en påstand hvis ene mulige gjendriver var ulesbar ble aldri angrepet.
|
||
**Load-bearing MÅLT: 30 mutasjoner, ALLE røde mot HELE suiten**, grønn kontroll **1189 passed /
|
||
5 skipped**, alle tre byte-fasitene OK og `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`); node-ID-supersettet holder strengt (1094 → 1194,
|
||
**0 fjernet**). Per mutasjon: M1 27 · M2 2 · M3 12 · M4 1 · M5 5 · M6 1 · M7 4 · M8 9 · M9a 26+8E ·
|
||
M9 17 · M10 1 · M11a 1 · M11b 2 · M11c 1 · M12 2 · M13 2 · M14 1 · M15 1 · M16 3 · M17 1 ·
|
||
M18a 1 · M18b 1 · M19a 2 · M19b 1 · M20a 2 · M20b 1 · D-b 1 · D-e 5 · D-i 3 · D-l 1.
|
||
**TRE av planens spådde signaturer ble FALSIFISERT av målingen, og de står som målt:** M9s
|
||
«rundturen forblir grønn» (ikke konstruerbar), M12s «exit-koden forblir 1» (mutanten reiser i
|
||
stedet), og M17s spådde PAR (kun 1 rød — `verified_field("a: b", …)` runder faktisk trippen, fordi
|
||
`_find_pair_separator` tar FØRSTE kolon-mellomrom og verdien beholder sitt eget kolon).
|
||
**Operatørbeslutninger:** D1 én dekoder-søm · D2 dispatcher-side kollisjonsregnskap · D3 én
|
||
linjekilde bak begge lesere · D4 skillen forfattes i commons · D5 ingen ny avhengighet (ingen
|
||
PyYAML) · D6/B1 identitet = `(bundle_id, concept_id)`, konseptet først. **D7-speiling er ÅPEN** for
|
||
dekoder-semantikken, som S3.2 og S4.0. **Ærlighets-grenser, uttalt:** `evidence_for(path, key=…)`
|
||
med en ANNEN nøkkel enn `verified` REISER for enhver verdi som dekoder til oppføringer uten `by`,
|
||
fordi `tier` avledes ubetinget — MÅLT: alle 11 eksisterende kallsteder bruker defaulten, så
|
||
parameteren har aldri vært øvet, og det er RAPPORTERT, ikke fikset (utenfor denne ordren);
|
||
`verified_field` validerer ikke `at`; og at en LEVENDE modell kaller falsifiseringsskillen godt er
|
||
ikke bevist (structured-output-grensens klasse).
|
||
- **Den TREDJE projeksjonen inn i `CostBaseline` DERIVERES fra en tabell som alt er i basen — og
|
||
den nekter heller enn å oppfinne (MAJOR-4, økt 78):** `cost-baseline.json` er håndskrevet per
|
||
prosjekt og `baseline_from_project` tilhører veg-domenet, så et INGESTERT anbudskorpus kunne
|
||
navigeres og aldri forankres. `okf.derive_cost_baseline(bundle, *, project_id)` leser
|
||
prisskjemaet. **`project_id` er PÅKREVD keyword, ikke lest av basen:** `run._project_from_bundle`
|
||
fail-faster alt kjøringens id mot basens `validator-input.json`, så en andre lesing her ville vært
|
||
kø-(p) — og ville dratt en IR-projeksjon inn i en funksjon hvis hele input er en tabell.
|
||
**PREMISSET BLE MÅLT FØR NOE BLE BYGGET PÅ DET, og ordrens to pekere navnga TO ULIKE FORMER:**
|
||
`examples/*/expected-bundle/` bærer PIPE-tabeller, men hver eneste av dem er csv-/sql-kilt og
|
||
rendret av `render.render_table` — **xlsx-stien når ALDRI `render_table`.** Målt (pandoc 3.10.2,
|
||
produsentens egen `_PANDOC_WRITER = "markdown"` + `_PANDOC_ARGS = ("--eol=lf", "--wrap=none")`,
|
||
mot produsentens egen `tests/fixtures/two-line-krav.xlsx` og et håndlagt Prisskjema):
|
||
`extract._extract_office` konverterer, og `inbox.py` gir teksten videre til
|
||
`render_inbox_concept(sanitized_text, …)` URØRT — resultatet er en pandoc **SIMPLE table**, der
|
||
dash-linja definerer kolonne-spennene. En pipe-only leser ville altså vært INERT på nøyaktig det
|
||
korpuset MAJOR-4 finnes for, og en simple-only leser inert på eksemplene ordren pekte på. Begge
|
||
leses, av TO skannere over ÉN rollemapping og ÉN tallgrammatikk (`_split_frontmatter`-formen: ett
|
||
skann, to lesere), aldri to kopier av semantikken. **Span-slicing, ALDRI splitt på whitespace:**
|
||
K2s hele form er tomme priseceller, og en whitespace-splitt kollapser dem og skyver hver senere
|
||
verdi én kolonne til venstre — en feilmapping som leses som DATA (M16 → 3 røde).
|
||
**Ingen skjønn noe sted:** header-vokabularet er lukket og matches EKSAKT (en delstrengregel ville
|
||
latt `Enhetspris eks. mva` og `… inkl. mva` kreve samme rolle, og leseren ville valgt mellom to
|
||
priser), tallgrammatikken er lukket og **dot-desimal** (målt output er `1250.0`/`42.5`, så et
|
||
komma ville kjøpt ingenting og importert `1,250`s tusenskille-vs-desimal-tvetydighet gratis — et
|
||
håndskrevet norsk `1 250,50` er en NEKTET celle, uttalt), og hver tvetydighet er en nekt: ingen
|
||
kandidat-tabell, mer enn én, to kolonner om samme rolle, to rader med samme kostkode.
|
||
**Delvis priset skjema nekter i SIN HELHET** — ikke forsiktighet: en halvderivert base forankrer
|
||
noen koder mens `ProvenanceStamp.cost_baseline_anchored` rapporterer `True`, og den biten er
|
||
påkrevd-uten-default nettopp fordi begge defaults ville løyet. Skannet over `context_files`, aldri
|
||
`files` (MAJOR-3-regelen). **`CostBaselineDerivationError` subklasser `ValueError`**
|
||
(`BundleIdMismatch`-presedensen) — CLI-ens nekt-tuppel og hostings 400-arm, aldri krasj-kanalen.
|
||
Wiret bak `--derive-cost-baseline`, ALDRI stille: ÉN oppløsning i `run.py`s bundle-arm tjener både
|
||
full kjøring og `live_dry_run`, og **nekten PROPAGERER** i stedet for å degradere til fil-lasteren
|
||
(`load_mandate`-regelen — en kaller som ba om derivasjon og fikk en uforankret kjøring er besvart
|
||
av en stille nedgradert ordre). Tre CLI-nekter, alle ved NAVN: krever `--bundle-dir`, refusert i
|
||
`--portfolio` (ved navn, ikke ved gjennomfall til `--bundle-dir`-kravet — `--explore`-presedensen)
|
||
og i `report_forbidden` (report-modus returnerer FØR nekten, så en utelatelse er et stille DROPP,
|
||
ikke en nekt — F4-gapet). **FIXTUREN er MÅLT, ikke håndskrevet:** begge basene under
|
||
`tests/fixtures/` er pandocs output ORDRETT, og den uprisede er K2s faktiske pre-award-form —
|
||
**kolonnene OVERLEVER som blanke** (målt), så tabellen ER en kandidat og nekten blir den skarpe:
|
||
leseren identifiserer kolonnene, leser tomme celler og nekter ved navn. `validator-input.json`
|
||
skrives KUN i testen, aldri inn i den innsjekkede fixturen (`measure`/`claimed_saving_nok` er
|
||
menneskets/mandatets). **`pytest.raises(ValueError)` ville IKKE gatet arm (b), og det er MÅLT, ikke
|
||
resonnert:** M17 (drop positivitetsvakten) får mutanten til å reise
|
||
`pydantic_core.ValidationError` — `isinstance(e, ValueError) is True`,
|
||
`isinstance(e, CostBaselineDerivationError) is False` — så en løsere arm ville stått grønn mot
|
||
nøyaktig den mutasjonen den finnes for. Load-bearing MÅLT
|
||
(`tests/test_cost_baseline_derivation_loadbearing.py`, 22 armer), **18 mutasjoner alle røde mot
|
||
HELE suiten** + grønn kontroll **1230 passed / 5 skipped** (fra 1208/5, supersett, 0 fjernet) og
|
||
golden `demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`):
|
||
M1 detach run-wiringen (2 røde) · M2 fallback ved nekt (1) · M3 hopp over uprisede rader (2) ·
|
||
M4 fabrikkér null (1) · M4b fabrikkér null uten tom-celle-nekten (1) · M17 drop
|
||
positivitetsvakten (1) · M5 transponer mengde/enhetspris (3) · M6 skann `files` (1) · M7 ta første
|
||
tabell ved tvetydighet (1) · M8 ta første kolonne ved duplisert rolle (1) · M9 last-write-wins på
|
||
duplisert kode (1) · M10 utvid tallgrammatikken (1) · M11 drop simple-skanneren (3) · M12 drop
|
||
pipe-skanneren (7) · M13 detach `--bundle-dir`-nekten (1) · M14 drop fra `report_forbidden` (1) ·
|
||
M15 drop fra portefølje-partisjonen (1) · M16 whitespace-splitt (3). **Ærlighets-grenser, uttalt:**
|
||
NS 3451 seksjonsrader (kode + overskrift, ingen mengde, inne i et ellers priset ark) er IKKE
|
||
klassifisert — K2 selv var ikke tilgjengelig å måle her, så et slikt ark NEKTER, og regelen skrives
|
||
når noen kan måle den ekte formen (en rad som er tom over alle tre kolonner er derimot en blank
|
||
spacer og hoppes over); stempelet sier AT en kjøring var forankret, aldri HVILKEN av de tre
|
||
projeksjonene forankret den; den hostede flaten er BEVISST urørt (feltet er ikke i whitelisten, så
|
||
4e-halvdelene står uendret); og ingen LEVENDE K2-fil er lest — fixturen er syntetisk, og at
|
||
produsenten faktisk emitterer denne formen for K2s Prisskjema er MÅLT på pandoc-stien, ikke på K2.
|
||
|
||
- **Den ERKLÆRTE `bundle_id`-en er identiteten; monteringsnavnet er en filsystem-tilfeldighet
|
||
(S7a-3 pkt. 1, økt 81):** til 03.09 NEKTET `reconcile_bundle_id` en base som erklærte en id
|
||
katalogen ikke bar. **Målt mot den første leverte basen som erklærer sin egen id** (K2: 618 av
|
||
630 konseptfiler + rot-`index.md`, alle `k2-trinn1-20260903`, levert som `K2-bundle-20260903`)
|
||
var følgen at basen **ikke kunne åpnes slik den var levert** — botemiddelet var å montere den på
|
||
nytt for hånd, én gang per leveranse, for alltid. Det er en konsument som avviser en produsents
|
||
legitime output over et katalognavn. **PM-beslutning: konsumenten slakker.** Erklært vinner
|
||
(konsept → rot-index → mount, B1s rekkefølge URØRT), avviket REGISTRERES —
|
||
`ResolvedBundleId.mount` bærer den overkjørte katalogen, `ProvenanceStamp.bundle_id_source` og
|
||
`DryRunReport.bundle_id_source` bærer hele oppløsningen inn i artefaktene, og `bundle_id_notice`
|
||
er ENESTE renderer, med TO kallsteder (returnerer `None` ved enighet — omisjon, aldri tom rad; omisjonen er selv
|
||
gatet, M5 → 2 røde inkludert et UAVHENGIG eksisterende vitne i
|
||
`test_navigation_visibility_loadbearing`). **Stempel-feltet er PÅKREVD uten default** av
|
||
`cost_baseline_anchored`s grunn, og her skjerpet: `None` er en VERDI (veg-stien har ingen base),
|
||
så et utelatt felt måtte bety det samme som «ingen base» — nøyaktig stillheten kravet lukker.
|
||
**Det som FORTSATT nekter er den ekte kollisjonen:** to KONSEPTER i ÉN base som erklærer ULIKE
|
||
id-er (`assert_declared_ids_agree`, kalt ved hver dør som ÅPNER en base). **Rot-`index.md` er
|
||
IKKE med i enighets-settet** — B1 anvendt en gang til: konsept-slår-index er en PRESEDENS-regel,
|
||
så en index i utakt med sine konsepter er fallbacken som taper, ikke to konsepter som kolliderer;
|
||
å folde indeksen inn ville nektet nøyaktig de K2-formede basene slakken finnes for (M3 → 1 rød).
|
||
Sjekken er en EGEN funksjon, ikke en gren i `reconcile_bundle_id`: den trenger en navigert
|
||
bundle, resolveren må forbli REN (`_bundle_index` løser id-er for kataloger som kanskje ikke
|
||
finnes), og separat gir den sin egen mutasjon per dør (M1/M2 → 1 rød hver).
|
||
**`explore._bundle_index` løser nå den erklærte id-en, og det er en KONSEKVENS — ikke
|
||
scope-krype:** den brukte `Path(raw).name` mens dispatcheren brukte `reconcile_bundle_id(raw).id`;
|
||
så lenge avviket ble nektet KUNNE de ikke divergere, men med erklært-vinner mynter `explore()`
|
||
approaches som navngir MOUNTET mens dispatcheren ruter på ERKLÆRINGEN — en utforskning hvis eget
|
||
mandat er uruterbart (M9 → 2 røde, M11 → 1 rød). Uleselig base faller tilbake til basenavnet
|
||
i stedet for å reise, fordi to av `_bundle_index`s egne armer konfigurerer kataloger som ikke
|
||
finnes og forventer en ID-feil, ikke en I/O-feil — ingenting utvides: den indeksen svarer på
|
||
hvilke id-er som kan NAVNGIS, og en base ingen kan lese nektes et øyeblikk senere av den døra som
|
||
faktisk åpner den. Load-bearing MÅLT (`tests/test_bundle_id_slack_loadbearing.py`, 13 armer),
|
||
**ti mutasjoner alle røde mot HELE suiten** + grønn kontroll **1243/5** og golden
|
||
`demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` =
|
||
`ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 detach gaten i `run_project` (1) · M2 detach den i
|
||
`read_bundle` (1) · M3 fold indeksen inn i enighets-settet (1) · M4 gjeninnfør mount-nekten (9) ·
|
||
M5 rendereren skriver alltid linja (2) · M6 detach CLI-utskriften (1) · M7 konstant stempel-wiring
|
||
(1) · M8 konstant dry-run-wiring (2) · M9 `_bundle_index` tilbake til mountet (2) · M11
|
||
dispatcheren tilbake til mountet (1). **TRE ARMER I `test_bundle_id_reconciliation_loadbearing`
|
||
ble SKREVET OM, ikke slettet** — (e)/(f)/(j) pinnet nekten beslutningen fjernet; (j) ble SKARPERE
|
||
enn den den erstattet (erklært id ruter, mountet nektes — to implementasjoner som skiller seg i
|
||
BEGGE halvdeler, ikke i en exit-kode). **Ærlighets-grenser, uttalt:** uten `concept_name` svarer
|
||
rot-`index.md`, så en base hvis index erklærer X mens konseptene erklærer Y løser til X (B1s
|
||
rekkefølge, urørt); **portefølje-armen er BEVISST IKKE wiret** — der er `bundle_id_source` `None`
|
||
ved konstruksjon (intet referanse-prosjekt setter `bundle_dir`), så en tredje utskrift ville vært
|
||
død kode; det er en ANNEN avgjørelse enn `cost_baseline_anchored`s, som wiret nettopp den armen
|
||
DEFENSIVT og drev den fra en crafted `PortfolioResult`, og den står her fordi stillhet om
|
||
asymmetrien er det eneste gale svaret. Og dispatcherens «to baser deler id»-nekt er NYLIG NÅBAR — den krevde før to
|
||
monteringer med samme basenavn, nå kolliderer to ULIKT navngitte kataloger som erklærer samme id.
|
||
Kontrakt: `docs/okf-konsum-kontrakter.md § 3.1`.
|
||
- **Stigen har tre trinn: `list_bundles` → `read_bundle` → `read_dir` → `read_file` (S7a-3 pkt. 2,
|
||
økt 81):** MAJOR-3 bygde `read_bundle` om fra HELE basen til én oppføring per konseptfil, og på de
|
||
tre eksempelbasene var det −77…91 %. Så kom det første EKTE korpuset: K2 navigerer til **629
|
||
konsepter bak 478 nestede indekser**, og en listing av 629 koster **42 761 o200k-tokens** som rir
|
||
i 7 av 12 prompter = **89 % av alle prompt-tokens**. Bindingen holdt asymptotisk og priset likevel
|
||
hele korpuset, fordi prisen på å finne ut HVA en base inneholder var satt av hvor mye den
|
||
inneholder. De 478 indeksene ble dessuten BYGGET av navigasjonen, KONSUMERT av den og så flatet
|
||
ut — agenten så 629 søsken og fikk aldri vite at korpuset hadde en form. **MÅLT ETTER:** rotnivået
|
||
er **3 954 tegn / 1 495 tok**, listing-tokens **307 573 → 12 595**, og utforskningens
|
||
prompt-tokens **343 826 → 49 225 (−86 %)**. BEFORE og AFTER er kjørt i SAMME økt med samme kode
|
||
(BEFORE er en mutasjon), og BEFORE reproduserer S7a-2s publiserte tall til 0,03 % — den
|
||
kjent-positive kontrollen på instrumentet. **`okf.directory_listing` er ENESTE renderer** og
|
||
begge verktøy ER den på hvert sitt nivå; to kopier av en listing-regel ville drevet til to svar om
|
||
én base (kø-(p)). **ET PREMISS I ORDREN BLE FELT FØR NOE BLE BYGGET PÅ DET:** `context_files` har
|
||
ALDRI holdt hierarkiet tilbake — hver `BundleFile.name` er allerede den fulle bundle-relative
|
||
stien, så treet var utledbart fra navnene; det var RENDERINGEN som flatet det ut. Dét er grunnen
|
||
til at `bundle_context` og begge nav-goldenene er BYTE-IDENTISKE etter endringen (ordrens eget
|
||
krav), gratis og ikke av forsiktighet. **Kataloger utledes av STIER, aldri av `index.md`** (en
|
||
nestet indeks er navigasjon, ikke innhold), og listingen bygges av `context_files`, ALDRI `files`
|
||
— en katalog-TELLING fra `files` ville reklamert for dokumenter navigatøren ikke får se (N2 → 7
|
||
røde). **Hver sti er BUNDLE-RELATIV, altså brukbar ordrett som neste kalls argument** — en
|
||
nivå-relativ form måtte komponeres av en modell, og en sti som aldri fantes er verre enn ingen
|
||
sti (`_index_excerpt`-regelen, ett trinn opp; N7 → 1 rød). `documents` på en katalog-oppføring er
|
||
antallet i hele SUBTREET — hva subtreet holder, ikke hva ett `read_dir` returnerer — og
|
||
beskrivelsen sier hvilken av de to det er. Ukjent sti NEKTES ved navn (`BundlePathNotFound`,
|
||
`ValueError`-subklasse som `BundleIdMismatch`): en tom listing er umulig å skille fra en katalog
|
||
som finnes og er tom (N5 → 1 rød). **Verktøybeskrivelsene og navigatørens instruksjon flyttet i
|
||
SAMME commit** — en beskrivelse som lyver om kroppen ER modellens instruks (Fase 3-klassen; N9 →
|
||
1 rød). **TO EKSISTERENDE ASSERTS VILLE BLITT VAKUØSE I STILLHET** og er styrket: `len(payload)`
|
||
er nå antallet NØKLER (tre, alltid), så `test_read_bundle_cost_loadbearing`s størrelses-arm talte
|
||
nøkler, og write-frihets-armen i `test_explore_loadbearing` kalte ikke det nye verktøyet i det
|
||
hele tatt. **AVVIK fra ordren, uttalt og målt:** ordren binder «K2 < 1 500 tegn» — K2 kan ikke
|
||
være en testavhengighet (utenfor repoet; MAJOR-3-gaten har samme begrensning), og tallet er ikke
|
||
oppnåelig: rota bærer 39 identifiserbare oppføringer og måler 3 954 tegn. Gaten binder derfor
|
||
1 500 tegn per listing over basene den KAN se, pluss egenskapen som ga fallet (kostnaden følger
|
||
oppføringer på ETT nivå, ikke dokumenter i basen), med en FLAT kontroll over 5× taket — uten den
|
||
ville en grønn binding like gjerne betydd at fixturen var liten. **Ordrens ANDRE binding
|
||
(«`read_dir` over største katalog bundet») er MÅLT med den SHIPPEDE funksjonen over alle 478
|
||
nivåer i K2:** verste nivå noe sted er **6 073 tegn / 2 094 tok** (65 underkataloger) = **4,9 %**
|
||
av den flate formens 42 761 — dyrere enn rota fordi hver sti er bundle-relativ, altså den målte
|
||
prisen på at en sti er brukbar ORDRETT i neste kall. Load-bearing MÅLT
|
||
(`tests/test_hierarchical_navigation_loadbearing.py`, 9 armer), **ni mutasjoner alle røde mot HELE
|
||
suiten** + grønn kontroll **1252/5** og golden BYTE-UENDRET (`shasum -a 1` =
|
||
`ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): N1 reverter sømmen (4) · N2 bygg fra `files` (7) ·
|
||
N3 bundet men VAKUØST tom (12) · N4 dropp `chars` (5) · N5 ukjent sti blir en tom listing (1) ·
|
||
N6 `read_dir` ikke registrert (6) · N7 nivå-relative navn (1) · N8 katalog-tellingen konstant (2)
|
||
· N9 instruksjonen beskriver den gamle stigen (1). **Ærlighets-grenser, uttalt:** dette er ikke
|
||
«−86 % for enhver kjøring» (en navigatør som stiger ned *k* nivåer betaler *k* listinger); at en
|
||
LEVENDE modell navigerer bedre med en struktur enn med 629 flate dokumenter er IKKE bevist
|
||
(structured-output-grensens klasse); multiplikatoren gjelder dette manuset; og `navigate_bundle`
|
||
kalles fortsatt per verktøykall (I/O, ikke tokens — ikke målt). Måling:
|
||
`docs/2026-09-03-hierarkisk-navigasjon-k2.md`.
|
||
- **Sporet sier HVILKE dokumenter navigatøren åpnet, ikke bare hvilken base (S7a-3 pkt. 3, økt
|
||
81):** `ExplorationToolRecorder` registrerte NAVN + `bundle_id` i kall-rekkefølge (MAJOR-1). Over
|
||
de tre eksempelbasene holdt det — 39 konsepter, og en kjøring som åpnet to av dem etterlot et
|
||
spor en operatør kunne resonnere om. Over K2 gjør det ikke: **629 konsepter**, og `tool_calls`
|
||
leser `read_file, k2` to ganger, så **hvilke to av 629 kan ikke leses ut av leveransen i det hele
|
||
tatt** — økt 77 og 81 måtte begge instrumentere kjøringen for hånd for å svare. `ToolCall.path`
|
||
registreres for `read_file` OG `read_dir`; et spor som navnga dokumentene men ikke katalogene
|
||
ville sagt hvor en kjøring ENDTE uten å si hvordan den kom dit. **RESULTATET registreres fortsatt
|
||
ALDRI**, og det er MAJOR-1s beslutning gjentatt nettopp fordi pkt. 3 er øyeblikket den var lettest
|
||
å oppheve: resultatet ER basens innhold, målt til 89 % av hver prompt-token i en K2-kjøring.
|
||
`""` for et verktøy som ikke tar argumentet — `bundle_id`s egen regel anvendt på det andre feltet;
|
||
en verdi oppfunnet for et argument ingen sendte er falsk attribusjon. **ÉN argumentleser for begge
|
||
felt** (`_string_argument`, kø-(p)): to kopier av «les denne nøkkelen ut av begge formene
|
||
`FunctionInvocationContext` tillater» ville stått fritt til å være uenige om hva et fraværende
|
||
argument betyr. Load-bearing MÅLT (`tests/test_tool_call_path_loadbearing.py`, 5 armer), **fire
|
||
mutasjoner alle røde mot HELE suiten** + grønn kontroll **1257/5** og golden BYTE-UENDRET
|
||
(`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): P1 detach registreringen (3) ·
|
||
P2 dropp `path` fra `trace_payload` (3, inkludert et EKSISTERENDE vitne) · P3 koerser en
|
||
ikke-streng til en etikett (2) · P4 les kun Mapping-formen (2).
|
||
- **Forslaget kan OPPSTÅ fra kommisjonen og basens eget prisskjema — og ordrens diagnose var feil
|
||
(S7b-forberedelse, økt 82):** ordren sa at forslaget *leses fra en håndskrevet
|
||
`validator-input.json`. **Symptomet er ekte** — en base uten fila nekter med `FileNotFoundError`
|
||
før første modellkall — **men diagnosen ble felt FØR noe ble bygget på den:** `SavingsProposal`
|
||
har ALLTID blitt konstruert av `generate._parse_ir` fra MODELLENS svar; fila er en fasit VED SIDEN
|
||
AV kjørestien, påkrevd kun som prosjektets IDENTITET. Det skillet avgjorde at S7b er **to sømmer,
|
||
ikke én**, og at bare den ANDRE er bygget her. **Nevneren: tre lesere, ikke én** —
|
||
`run.py:453` (hver bundle-kjøring), `verdicts.py:507` (kun med ikke-tom store) og `run.py:1662`,
|
||
dispatcherens rutingsnøkkel, som bevisst ikke tar `project_id` fordi den leser den derfra. Å gjøre
|
||
IR-projeksjonen valgfri er den ANDRE sømmen: MÅLT, dokumentert, IKKE bygget.
|
||
**Arbeidsdelingen er hele designet:** eksperten sier HVA (`Approach.label` → `measure`, VERBATIM),
|
||
HVILKE linjer (`affected_codes`) og HVOR MYE (`claimed_saving_nok`); dokumentet sier MENGDE og
|
||
PRIS (`derive_cost_baseline`, MAJOR-4). `candidate_from_approach` oppfinner ingenting og nekter
|
||
ved NAVN på alle tre gap. **Anslaget bor på `Approach`, aldri på `Mandate`** — `settle`s egen
|
||
regel: tilnærminger er ALTERNATIVER og summeres aldri, så ett tall på mandatnivå ville vært
|
||
tvetydig over N; og det er IKKE kjøringens MÅL (`contracts.GoalContract` eier nettopp ett sådant),
|
||
hvilket står skrevet der feltet innføres, ellers leses det som den `(p)`-driften modulen forbyr.
|
||
**Null modellkall er STRUKTURELT:** `run.evaluate_mandate_candidates` er **SYNC**, så den kan ikke
|
||
awaite et chat-kall — ingen mutasjon av kroppen kan stille innføre ett; CLI-armen asserterer det
|
||
likevel ATFERDSMESSIG (`_default_factory` patchet til å raise), fordi rc 0 alene også er utfallet
|
||
til en dør som gjorde ingenting. **`allow_own_proposals` får en `not_evaluated`-RAD, ikke en
|
||
nekt:** raden kan ikke fylles uten en modell, men å utelate den gjør den uskillbar fra en
|
||
tilnærming ingen bestilte (`ApproachOutcome`s egen regel), og å nekte hele kjøringen ville vært
|
||
feil andre veien — feltet defaulter til `True`. **Fixturen brukes URØRT**, og dét er armens poeng:
|
||
`test_cost_baseline_derivation_loadbearing` må kalle `_runnable()` og skrive en
|
||
`validator-input.json` inn i en kopi før `run_project` ser på den. Load-bearing MÅLT
|
||
(`tests/test_proposal_from_mandate_loadbearing.py`, 18 armer), **seksten mutasjoner, FEMTEN røde
|
||
mot HELE suiten** + grønn kontroll **1275/5** (fra 1257, supersett, 0 fjernet) og golden
|
||
`demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`,
|
||
INNHOLD — ikke git-blob): M1 detach CLI-dispatchen (1) · M2 fabrikkér et anslag (2) · M3 default
|
||
kodene til hele skjemaet (1) · M4 toler en ukjent kode (1) · M5 bygg lazily (1) · M6 utelat
|
||
own-proposal-raden (1) · M8 detach `--mandate`-nekten (1) · M9 detach
|
||
`--derive-cost-baseline`-nekten (1) · M10 dropp fra portefølje-partisjonen (1) · M11 dropp fra
|
||
`report_forbidden` (1) · M12 `measure` er ikke ekspertens ord (1) · M13 baseline-rekkefølge i
|
||
stedet for ekspertens (1) · M14 rut på mount-navnet (1) · M15 fabrikkér usikkerhetsbånd (1) ·
|
||
M16 detach enighets-gaten ved DENNE døra (1).
|
||
**`evaluate_mandate_candidates` er den TREDJE døra som ÅPNER en base, og den fikk sitt EGET
|
||
vitne** (M16): S7a-3s rad enumererer dørene med vilje («separat gir den sin egen mutasjon per
|
||
dør»), fordi en uvitnet kopi kan regrere ALENE mens de to andre står grønne. **`project_id`
|
||
NARROWES, aldri defaultes:** `args.project_id or ""` ville nådd `derive_cost_baseline` og myntet
|
||
en `CostBaseline(project_id="")` — en fabrikkert identitet, nøyaktig formen
|
||
`cost_baseline_anchored` er påkrevd-uten-default for å forby; unåbar i dag, så det er en assert
|
||
og ikke en default som stille er uenig med guarden over.
|
||
**TRE MUTASJONER FALSIFISERTE TESTEN FØRST (repoets vakuøs-gate-klasse, TRETTENDE til
|
||
FEMTENDE gang):** (i) M5 sto GRØNN — armen asserterte kun `pytest.raises`, og BEGGE implementasjoner
|
||
reiser mens ingen rad når kalleren uansett, så de er uskillbare utenfra; det er økt 57s regel («en
|
||
nekt etter forbruket ser identisk ut ved exit-koden») anvendt på CBC-solves, og testen TELLER nå
|
||
solves med en kontroll som beviser at telleren beveger seg. (ii) M14 sto GRØNN — armen brukte
|
||
`f"not-{declared}"`, som matcher verken mount eller erklæring, og **fixturene erklærer ingen
|
||
`bundle_id`** (S7a-3 målte null `^bundle_id`-treff under `tests/`), så de to SAMMENFALLER der;
|
||
den nye armen bygger en base som erklærer en id ulik katalognavnet og asserterer BEGGE halvdeler.
|
||
(iii) M16s FØRSTE arm erklærte de to id-ene på rot-`index.md` og den ene konseptfila, og sto
|
||
GRØNN — S7a-3 holdt rot-indeksen UTENFOR enighets-settet med vilje, fordi konsept-slår-index er
|
||
en PRESEDENS-regel: en index i utakt med sine konsepter er fallbacken som taper, ikke to
|
||
konsepter som kolliderer. Armen bruker nå TO konseptfiler.
|
||
**ÉN MUTASJON FORBLIR GRØNN, OG DET ER EN ÆRLIGHETS-GRENSE — IKKE EN GATE:** M7 (døm UTEN
|
||
baselinen) er strukturelt uobserverbar, fordi kandidaten er BYGGET fra baselinen og stage 0
|
||
derfor avstemmer med 0 % avvik ved konstruksjon; `baseline=` står som en DEFENSIV, uvitnet søm
|
||
(`budget_stop`-presedensen), ikke som noe en test holder. **Flere ærlighets-grenser, uttalt:**
|
||
`assumptions` er TOM (et bånd kan ikke avledes fra én pris), så Monte Carlo er degenerert
|
||
(P10 == P50 == P90) mens stage 3 fortsatt rapporterer persentiler — det som binder er stage 0,
|
||
stage 2/4b og pydantics `claimed <= total`; `measure` er ikke bare prosa, men stage 5s
|
||
`METHOD_CAPS`-oppslagsnøkkel, så en ekspert-label treffer metode-cap-en kun om den ER et
|
||
registrert metodenavn; den hostede flaten er BEVISST urørt (feltet er ikke i whitelisten, så
|
||
4e-halvdelene står uendret); og ingen LEVENDE K2-fil er lest — fixturen er syntetisk, som i
|
||
MAJOR-4. **MÅLT, RAPPORTERT, IKKE FIKSET (utenfor ordren):** `--mandate` selv står IKKE i
|
||
`report_forbidden`, så `--report --ledger X --mandate Y` DROPPER kommisjonen i stillhet — F4-gapets
|
||
klasse, på et flagg som er eldre enn denne ordren. Måling:
|
||
`docs/2026-09-03-forslag-fra-mandat.md`.
|
||
- **Den håndskrevne IR-projeksjonen er VALGFRI, og fraværet SIES i stedet for å reises (S7b søm 1
|
||
+ syretesten, økt 83):** `okf.load_ir_projection` var fail-fast påkrevd på TRE kallsteder, så et
|
||
ingestert anbudskorpus kunne navigeres (`read_bundle`), katalogiseres (`list_bundles`) og dømmes
|
||
gjennom den deterministiske mandat-døra (`evaluate_mandate_candidates`, som ikke leser fila i det
|
||
hele tatt) — og likevel ikke kjøre åtte-stegs-løkka. `load_optional_ir_projection` er et **PAR**
|
||
ved siden av den fail-faste, ALDRI et `required=`-flagg: PM-tillegg 5 målte hva en uøvet parameter
|
||
koster (alle elleve `evidence_for`-kallsteder brukte defaulten til den andre grenen råtnet), og et
|
||
flagg ville dessuten gjort usanne de docstringene i `hitl`/`ledger`/`verdicts`/`contracts` som
|
||
siterer `load_ir_projection` som DEN fail-faste presedensen. **Toleransen stopper ved fravær**
|
||
(S4.0-radens egen setning): en projeksjon som FINNES men er malformed reiser fortsatt.
|
||
**De TRE kallstedene fikk HVER SIN stilling, og det er derfor dette ikke er ett loader-bytte:**
|
||
`_project_from_bundle` hopper over en fail-fast som ikke har noe å sjekke mot, mens en projeksjon
|
||
som FINNES og navngir et ANNET prosjekt fortsatt nekter (divergens-vakten er kontrakten
|
||
multi-base-dispatchen hviler på); `run_mandate_across_bundles` tar **FILA FØRST**, basens ERKLÆRTE
|
||
`bundle_id` som fallback (S7a-3) — presedensen bærer i BEGGE retninger, for erklæring-først ville
|
||
re-adressert hver eksisterende base der `project_id` ≠ `bundle_id`; og
|
||
`optional_bundle_candidate_features` har **TO konsumenter som svarer ULIKT på samme fravær** —
|
||
Steg-1-folden HOPPER OVER (fraværet av en kandidat er et faktum om basen), mens
|
||
`seed_store_from_bundle` NEKTER ved navn (`VerdictKeyUnavailable`), fordi å mynte en nøkkel for en
|
||
dom som erklærer ingen fester dommen til en kandidat den ikke handler om — nøyaktig defekten S3.2
|
||
lukker. **Synligheten er et ANTALL** (`RunResult.unkeyed_verdicts` + `run.unkeyed_verdicts_notice`
|
||
som ENESTE renderer, `None` ved null — omisjon, aldri tom rad): «folden skjedde ikke» og «to
|
||
dommer nådde aldri modellen» er ulike operative fakta (kø-(y) ett nivå ned), og null er et ærlig
|
||
POSITIVT utsagn, så feltet DEFAULTER (`skipped_links`-halvdelen, motsatt av
|
||
`cost_baseline_anchored`). **Bæreren er MÅLT:** `DryRunReport` kan ikke bære den — dry-run-kuttet
|
||
returnerer OVER folden, så et felt der kunne bare rapportert null, ulikt `cost_baseline_anchored`
|
||
og `skipped_links` som begge oppløses over kuttet; og ikke `ProvenanceStamp`, som beskriver gaten
|
||
som dømte ÉN kandidat. **TO PREMISSER FELT FØR NOE BLE BYGGET PÅ DEM:** (a) den arkiverte
|
||
selv-ordrens «navne-fallbacken er en REELL beslutning» — MÅLT er `SavingsProposal`s fem felt uten
|
||
et navn, så projeksjonen har ALDRI vært en navnekilde og `Project.name` er uendret; (b) ordrens
|
||
DEL B-kjede kan ikke være ÉN kommando — `--explore` NEKTES sammen med `--mandate`,
|
||
`--proposals-from-mandate` er en TERMINAL modus, og det finnes intet `--revise`-flagg (lest som
|
||
plan-review-døra, sagt som tolkning). **DEL C:** `--mandate` var ELDRE enn `report_forbidden` og
|
||
hadde aldri fått en rad, så `--report --ledger X --mandate Y` droppet kommisjonen i STILLHET
|
||
(F4-klassen); armen kjører mot en argv report-modus ellers ville AKSEPTERT, med en kontroll som
|
||
beviser rc 0 uten flagget. **SYRETESTEN (DEL B) er dét som gjør raden mer enn en påstand:** hele
|
||
løkka kjørte på K2 (630 konsepter, ingen `validator-input.json`) med MAJOR-4s SYNTETISK prisede
|
||
skjema montert — 850 000 NOK validert av 3 852 500, 2 av 5 felt på TO ULIKE stages (stage 4 P90,
|
||
stage 5 METHOD_CAPS), og **99,1 % av kjøringens tokens er debattens tre kopier av
|
||
`bundle_context` (648 962 tok hver)** mens utforskningen koster 18 355. Formen var kjent
|
||
(MAJOR-3-raden), nevneren på et ekte korpus er ny. **Et premiss felt:** K2 som levert har NULL
|
||
kandidat-tabeller — prissammenstillingen renderes som en SIMPLE table med ÉN kolonne-overskrift,
|
||
så den er ikke bare upriset, den navngir aldri rollene. Load-bearing MÅLT
|
||
(`tests/test_optional_ir_projection_loadbearing.py`, 15 armer), **TRETTEN mutasjoner ALLE RØDE mot
|
||
HELE suiten** + grønn kontroll **1290/5** (fra 1275/5, supersett, 0 fjernet) og golden
|
||
`demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` av INNHOLDET =
|
||
`ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 fail-fast i `_project_from_bundle` (4 røde) ·
|
||
M2 toleranse utvidet til UENIGHET (3 — hvorav TO i tester eldre enn dette arbeidet) · M3 loaderen
|
||
svelger malformed (1) · M4 presedensen invertert (7 — hvorav fire eksisterende multibase-/
|
||
bundle-id-armer, altså retningen hovedarmen ikke kan se) · M5 fail-fast i dispatcheren (1) ·
|
||
M6 folden hoppes over i stillhet (2) · M7 over-rapportering (1) · M8 antallet forlater aldri
|
||
`run_project` (2) · M9 rendereren skriver alltid linja (1) · M10 rendereren kalles aldri (1) ·
|
||
M11 unøklbar dom hoppes stille over (1) · M12 seedens fallback beholder fail-fasten (3) ·
|
||
M13 `--mandate` faller ut av report-partisjonen (1). **Ærlighets-grenser, uttalt:** feltet når
|
||
IKKE utboksen (`write_proposal` dumper stempelet, og dette er ikke på det — samme grense
|
||
`skipped_links` alt har); portefølje-armen er BEVISST ikke wiret (folden er gatet på `bundle_dir`,
|
||
som intet referanse-prosjekt setter, så en utskrift der ville vært død kode —
|
||
`bundle_id_notice`s avgjørelse, ikke `cost_baseline_notice`s, og asymmetrien står her fordi
|
||
stillhet om den er det eneste gale svaret); `run_mandate_across_bundles` har ingen CLI-flate, så
|
||
dens `unkeyed_verdicts` når kun en bibliotek-kaller; stage 0 kan strukturelt ikke felle en
|
||
mandat-avledet kandidat (bygget FRA baselinen — økt 82s M7-grense); prisene i syretesten er
|
||
SYNTETISKE og ingen levende modell er kalt. Måling: `docs/2026-09-04-syretest-s7b-k2.md`.
|
||
- **Debatten NAVIGERER basen; den får den aldri utlevert — og §4.1a-filteret flyttet MED
|
||
(S2c, økt 85):** MAJOR-3/S7a-3 gjorde utforskningen billig og lot pipelinen stå. MÅLT på K2 (630
|
||
konsepter, S7bs eget instrument, kjent-positiv-kontrollen reprodusert eksakt FØR bruk):
|
||
`okf.bundle_context` er **648 962 o200k-tokens** og rir i TRE kopier = **1 947 342 = 99,1 %** av
|
||
en kjørings prompt-tokens, mot utforskningens 18 355. **Et premiss i måledokumentet ble presisert
|
||
først:** S7b skrev «2 debatt-turer + genererings-prompten», men de tre kopiene er TRE
|
||
DEBATT-TURER (proposer ×2, checker ×1) mens genererings-prompten er **156** tokens — fordi
|
||
`gen_context = debate_output or context` tar debattens output når den finnes. Dét avgjorde formen:
|
||
**generering trengte ingen egen søm**, for å binde `context` binder siste-utvei-fallbacken ved
|
||
KONSTRUKSJON, og en verktøysløyfe inne i `generate_via_llm` ville vært en andre mekanisme for et
|
||
problem den første alt løste. `run_project`s bundle-arm sender nå en **PEKER** (`_bundle_pointer`:
|
||
fast tekst + erklært `bundle_id` + antall konseptdokumenter i scope + stigen, O(1) i korpuset) og
|
||
gir debatten de SAMME fire verktøyene utforskningen bruker — `explore.navigator_tools` GJENBRUKT,
|
||
aldri en andre kopi av policyen. Etter: **753** tokens like-for-like (samme manus, samme fire
|
||
prompter, −99,96 %) og **8 942** med en debatt som faktisk går stigen (11 prompter, −99,5 %),
|
||
mot operatørens terskel 195 000 = **4,6 % av taket**. Prompt-ANTALLET stiger, og det er handelen
|
||
MAJOR-3-raden alt beskriver: man betaler per kall, men hvert resultat rir kun fra SITT kall og
|
||
framover. **§4.1a måtte flytte, ikke forsvinne:** løftet «agentene leser KUN dimensjons-matchet
|
||
kunnskap» ble holdt av `bundle_context`s filter, og holdes nå av VERKTØYENE på **begge trinn** —
|
||
en listing som skjuler et fremmed dokument mens `read_file` serverer det på sti er et filter i
|
||
navnet alene; `okf.in_dimension` er ENESTE predikat (kø-(p)), og `DimensionScopeRefused` er en
|
||
`ValueError` (`BundlePathNotFound`-presedensen: kalleren er en modell som velger en sti, så
|
||
nekten hører på CLI-ens nekt-tuppel, aldri krasj-kanalen). **Sporet er KALLER-EID**
|
||
(`ExplorationToolRecorder` på debattens middleware → `RunResult.debate_tool_calls` →
|
||
`{run_id}-debate.json` fra en `finally`): en returverdi ville vært tapt på nøyaktig den kjøringen
|
||
som trenger beviset, for et budsjettstopp midt i debatten reiser ut av `debate.run` og
|
||
konstruerer aldri et `RunResult`. **Artefaktet skrives også TOMT** — motsatt av
|
||
`write_parse_failures`, hvis TILSTEDEVÆRELSE er signalet: her ER det tomme tilfellet S2c-
|
||
regresjonen (en debatt som navigerer ingenting ser billig ut av feil grunn), så det må kunne
|
||
LESES, ikke utledes av en fil som ikke er der; MÅLT på kontroll-kjøringen med det uendrede
|
||
manuset, som etterlot `{"tool_calls": []}`. `explore.tool_call_payload` er ENESTE renderer for
|
||
begge artefakter. **`--scripted-replies` tar nå steg-lister for debattens roller:** nekten som
|
||
forsvant begrunnet seg med at «proposeren svarer `generate`s eget kall, ikke en agent-løkke som
|
||
kan kalle et verktøy mellom turer» — målbart usant siden proposer og checker ER agenter med de
|
||
fire verktøyene, og å beholde den ville holdt måleprotokollens GRATIS trinn borte fra nøyaktig
|
||
den sømmen S2c bygger (MAJOR-1s vakuitet, ett lag over). **Validert besparelse og validatorens
|
||
dom er UENDRET** — 850 000 NOK av 3 852 500, 2 av 5 felt på stage 4 og stage 5, samme dom-nøkkel
|
||
`be8535e204cdc4c6` — og utforskningens 18 355 er uendret til tokenet (`dimension` defaulter til
|
||
`None`, som er dét som gjør uendretheten til en måling). Load-bearing MÅLT
|
||
(`tests/test_debate_navigation_cost_loadbearing.py`, 11 armer), **åtte mutasjoner røde mot HELE
|
||
suiten** + grønn kontroll **1306/5** (fra 1295/5) og golden `demo-transcript.stdout`
|
||
BYTE-UENDRET (`shasum -a 1` av INNHOLDET = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`):
|
||
M1 reverter sømmen (3) · M2 verktøyene ut av `debate_tools` (7, spredt over fire filer hvorav tre
|
||
eldre gates) · M3 detach recorderen (2) · M4 skriv aldri artefaktet (5) · M5 `directory_listing`
|
||
ignorerer dimensjonen (2) · M6 detach `read_file`-gaten (2) · M7b pekeren navngir ingen base (1) ·
|
||
M8 sporet dropper `path` (3 — hvorav TO i `test_tool_call_path_loadbearing`, altså uavhengige
|
||
vitner på at rendereren er delt). **ÉN MUTASJON FALSIFISERTE SEG SELV, ikke gaten:** M7 (fjern
|
||
basens id fra pekerens overskriftslinje) var GRØNN, fordi pekeren navngir basen FIRE ganger og å
|
||
fjerne én omtale ikke fjerner egenskapen; M7b er mutasjonen som treffer den. Det står som målt.
|
||
**Tre eksisterende armer er SKREVET OM, ikke slettet:** dimensjonens to §4.1a-armer flyttet fra
|
||
prompt-teksten til listingen (den positive ville ellers blitt vakuøs — sentinelen kan aldri nå en
|
||
prompt igjen), MCP-kontrollens `captured_tools[0] == []` ble til «ingen EKSTERN tool + nøyaktig
|
||
navigatør-settet», og `test_a_step_list_is_refused_for_a_debate_role` ble sin egen positive (den
|
||
ENE omdøpte node-ID-en; suiten er ellers et strengt supersett). **Ærlighets-grenser, uttalt:**
|
||
ingen levende modell har navigert (structured-output-grensens klasse); multiplikatoren gjelder
|
||
dette manuset; et proposer-manus konsumeres PÅ NYTT av `generate_via_llm`s ferske klient, så et
|
||
manus som åpner med et verktøykall brenner genererings-forsøk (uttalt i loaderens docstring, ikke
|
||
reparert — å gjette hvilke steg som var «ment for» hvilket kallsted er reparasjon); den hostede
|
||
flaten er urørt; og **`read_file` var sti-adresserbar til `type: verdict`-laget — LUKKET samme dag**
|
||
(raden under). Grensen sto her som MÅLT, RAPPORTERT, IKKE FIKSET, med begrunnelsen at å lukke
|
||
den er én regel ett sted som også endrer utforskningen, altså en egen beslutning; beslutningen
|
||
ble tatt. Måling: `docs/2026-09-04-s2c-debatt-k2.md`.
|
||
- **En dom nås gjennom ÉN dør, og `read_file` er ikke den — nekten leser DOKUMENTET, ikke gangen
|
||
(verdict-gaten, 04.09, ordre `20260904T172353Z`):** ingen listing navngir `type: verdict`-laget
|
||
(`Bundle.context_files` dropper det på hvert nivå, så verken `read_bundle`, `read_dir` eller
|
||
`bundle_context` nevner en dom), men en GJETTET sti nådde en — MÅLT: alle 2 883 tegn av
|
||
fixturens frø-dom, og i en debattkjøring nådde kroppen prompt 1 og 3. Egenskapen var ARVET fra
|
||
S7a-3 og ble nåbar fra debatten da S2c ga den navigatørens fire verktøy. Regelen bor i
|
||
`read_file` inne i `navigator_tools`, altså i ÉN kopi for BEGGE kallere — ikke i renderingen
|
||
(S2c målte selv at et filter som skjuler et dokument mens denne sprossen serverer bytene er «et
|
||
filter i navnet alene») og ikke i prompt-tekst (råd til en utrodd velger er ikke en gate).
|
||
**Predikatet er nøklet på det RESOLVERTE DOKUMENTETS frontmatter** (`okf.declares_verdict_type`),
|
||
aldri på navigasjonen: `Bundle.verdicts` svarer på «hvilke dommer nådde gangen» — riktig spørsmål
|
||
for ExpeL-frøene, feil her, fordi en dom ingen `index.md` lenker er fraværende fra gangen og
|
||
ville seilt rett gjennom (M2 → 1 rød, den armen ALENE). `_VERDICT_TYPE` er nå ÉN kopi av hva et
|
||
verdict ER (kø-(p)); tre flater svarer på det. **Gaten står FØR dimensjonssjekken**, fordi laget
|
||
nektes ubetinget og `dimension=None` er utforskningens EGEN kall — en gate etter den grenen ville
|
||
vært fraværende fra nøyaktig den kalleren den ble skrevet for (M5 → 4 røde).
|
||
`VerdictLayerRefused` er en `ValueError` (`DimensionScopeRefused`-presedensen: kalleren er en
|
||
modell som velger en sti, så nekten hører på CLI-ens nekt-tuppel og hostings 400-arm, aldri
|
||
krasj-kanalen). **Den GATEDE døra er urørt, og det er dét som skiller en gate fra en vegg:** en
|
||
egen arm kjører hele `run_project` og asserterer at `realiseringsgrad=0.82` fortsatt når
|
||
hypotese-prompten gjennom Steg-1-folden. **En nektet lesning er REGISTRERT, aldri stille** —
|
||
recorderen appender FØR `await call_next()`, så kallet står i `RunResult.debate_tool_calls` og i
|
||
`{run_id}-debate.json` med sin sti; det er en EGEN gate og ikke en passasjer på nekten, MÅLT:
|
||
mutasjonen «registrer etter `call_next`» tømmer sporet for nøyaktig et nektet kall (`trace = ()`),
|
||
fordi invokasjonen aldri returnerer (M3 → 1 rød, den armen ALENE). Sideegenskap MÅLT: en nekt fra
|
||
et verktøy fanges av MAF og returneres som feilresultat til modellen — kjøringen fortsetter, og
|
||
`finally`-artefaktet skrives som før. Load-bearing MÅLT
|
||
(`tests/test_verdict_layer_refusal_loadbearing.py`, 8 armer), **fem mutasjoner alle røde mot HELE
|
||
suiten** + grønn kontroll **1314/5** (fra 1306/5; +8, ingen eksisterende testfil rørt, altså et
|
||
strengt supersett ved konstruksjon) og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` av INNHOLDET = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 detach gaten (4) ·
|
||
M2 gate på gangen (1) · M3 registrer etter `call_next` (1) · M4 gate på komplementet av
|
||
`context_files` (3 — hvorav TO eldre, UAVHENGIGE vitner: katalog-gatens «hele indeksen er ett
|
||
kall unna» og utforskningens byte-identitets-arm, altså er stigens toppsprosse gatet av tester
|
||
eldre enn dette arbeidet) · M5 gaten bak dimensjonsgrenen (4). Syretesten er UENDRET i utfall:
|
||
850 000 NOK validert av 3 852 500, 3 av 5, de to falne på stage 4 og stage 5, og hele løkka gir
|
||
fortsatt dom-nøkkel `be8535e204cdc4c6`. **Ærlighets-grenser, uttalt:** ingen LEVENDE modell har
|
||
prøvd den gjettede stien (structured-output-grensens klasse); gaten sitter på `read_file`, ikke
|
||
på filsystemet — en kaller som selv åpner en fil i basen utenom verktøyene er upåvirket; og
|
||
nekten er nøklet på den ENE erklærte typen ExpeL-folden eier, aldri på et bredere
|
||
«ikke i `context_files`»-komplement, som M4 viser ville rammet `index.md` — navigasjon, ikke en
|
||
dom. Måling: `docs/2026-09-04-s2c-debatt-k2.md` § 8.
|
||
- **Eksperten kan svare på forslaget som ligger på BORDET — og svaret BRUKES, det registreres ikke
|
||
bare (MAJOR-2, økt 88–89):** før dette fantes ÉN menneske-søm inne i løkka, `plan_reviewer`, og
|
||
den fyrer FØR noen hypotese finnes. **Nevneren er målt** (`docs/2026-09-02-misjonsreview-v2.md`
|
||
§ 3, re-målt mot HEAD): `grep -n "prior_" generate.py` finner nøyaktig ÉN tilbakemeldings-søm,
|
||
`prior_rejection` — MASKINENS egen falsifisering matet tilbake i samme kjøring. Et menneskes ord
|
||
landet først i NESTE kjøring (Steg-7-innboksen), så «improved proposals given feedback» var, for
|
||
en person, en to-kjørings løkke med dager imellom. `--proposal-review` viser kandidaten
|
||
validatoren nettopp AKSEPTERTE og leser `approve` eller `revise <hva>`; en `revise` **kjøper ETT
|
||
forsøk til under de EKSISTERENDE takene** (ingen ny løkke — `max_attempts` + `meter.tick_round`,
|
||
som Steg 5), og ordene går ORDRETT inn i det forsøkets prompt som en tredje komponerbar blokk
|
||
ved siden av `prior_rejection`.
|
||
**D6: validatorens SISTE dom vinner, aldri revieweren sin.** Alternativet (falle tilbake til det
|
||
sist VALIDERTE forslaget når oppfølgingen blir avvist) ble forkastet fordi det ville latt et
|
||
menneskes ønske om ett forsøk til FORBEDRE utfallet uten at noen falsifiserer sa ja — mennesket
|
||
er en tredje stemme som gater INGENTING utover å be om ett forsøk til. `M27` er dét vitnet.
|
||
**Ekspertens ord er KLEBRIGE, maskinens grunn er PER FORSØK:** `feedback` står til mennesket
|
||
svarer neste gang, `prior_rejection` overskrives hver runde (M4/M5, hver sin ene røde arm).
|
||
**`attempts_remaining` er LEDGER-BEVISST, ikke `max_attempts`-avledet:**
|
||
`min(max_attempts - i - 1, meter.budget.max_rounds - meter.rounds)` — den DELTE rundeboka
|
||
(`max_rounds*4` på run-nivå) spenner over hver tilnærming i en kommisjon og er ofte dét som
|
||
binder, så et tall regnet fra forsøkstaket alene ville vært en påstand terminalen gjør om seg
|
||
selv som måleren straks gjendriver (M38 → 2 røde, BEGGE navngir M38 i sin docstring).
|
||
**`honoured` betyr «forsøket som ble kjøpt HENTET faktisk et svar», ikke «ble kjøpt»:** posten
|
||
føres `False` og forfremmes først når `_fetch_parsed` har RETURNERT, så en revise rundeboka kappet
|
||
før den står `false` ved siden av `rounds limit=2 observed=3` (M40 → 2 røde).
|
||
**Kanalen er valgt av TRE målinger, ikke av smak:** `ProposalReviewInputError` er en
|
||
`RuntimeError` fanget VED NAVN på CLI-ens fullkjørings-dispatch og printet på en egen
|
||
`run stopped:`-linje med rc 1. En `ValueError` ville (a) landet på `run refused:`-tuppelen, som
|
||
MISLABLER en kjøring der argv var riktig og tokens allerede var brukt, og (b) — verre — blitt
|
||
fanget av `_fetch_parsed` ETT frame unna som en PARSE-feil, altså føyd til `parse_failures`
|
||
ordrett og modellen re-kalt til rundeboka fyrte. EOF er ALDRI en signatur (M15/M16).
|
||
**Sinken er KALLER-EID** (funn-1-formen, `parse_failures`-presedensen): `run_project` eier lista,
|
||
nøkler hver post på `(approach_id, attempt)` — `OWN_PROPOSAL_ID` for systemets eget forslag, så
|
||
to tilnærminger aldri kollapser på én rad — og skriver `{run_id}-proposal-reviews.json` fra en
|
||
**`finally`**. En returverdi ville vært tapt på nøyaktig den kjøringen som trenger beviset: et
|
||
budsjett-stopp inne i genereringen konstruerer aldri et `GenerationResult` (M35 → T9 alene).
|
||
**Skrive-regelen er «iff en reviewer ble gitt, OGSÅ når lista er tom»** (D4) — `write_debate_tools`'
|
||
regel, av samme grunn: en reviewer ingen rakk å spørre er dét som må kunne LESES, ikke utledes av
|
||
en fil som ikke er der (M12/M13). Uten reviewer er utboksen BYTE-IDENTISK (M13 → 3 røde, hvorav
|
||
to i tester eldre enn dette arbeidet).
|
||
**`proposal_review_notice` er ENESTE renderer, og den SIER fra på NULL reviews når en reviewer
|
||
ble gitt** («offered, never consulted») — et BEVISST avvik fra announce-regelens
|
||
omisjon-på-ingenting-halvdel, som står urørt i `cost_baseline_notice`, `skipped_links_notice` og
|
||
`unkeyed_verdicts_notice`: stillhet er tvetydig HER og ikke der, fordi en operatør som ga
|
||
`--proposal-review` og ser ingenting ikke kan skille «ingen kandidat ble noensinne validert, så
|
||
ingen ble spurt» fra «døra hang». Uten reviewer returnerer den fortsatt `None` — omisjonen er
|
||
beholdt nøyaktig der den er entydig. Gatet av M33 og M37.
|
||
**Fem nekter, alle VED NAVN**, og plasseringen er MÅLT: blokka ligger på FUNKSJONS-nivå rett etter
|
||
mode-dispatchen, aldri nøstet under `if args.scripted_replies` eller `if args.explore` — under
|
||
hver av dem ville et bart `--live-dry-run --proposal-review` falt rett gjennom til dry-run-
|
||
dispatchen og droppet flagget. `--portfolio` (bølgene deler ÉN terminal), `--report`
|
||
(returnerer OVER hver dispatch, så en utelatelse er et stille DROPP — F4-gapet),
|
||
`--live-dry-run`, `--proposals-from-mandate` og `--checkpoint-dir` («send `--proposal-review` ved
|
||
`--resume` i stedet» — en nekt som bare forbyr etterlater operatøren uten døra som VIRKER).
|
||
**Den siste nekten bærer `and args.resume is None`, og den halvdelen er LOAD-BEARING (økt 91):**
|
||
`--resume` KREVER selv `--checkpoint-dir`, så en bar `checkpoint_dir is not None`-test nektet
|
||
nøyaktig den komposisjonen dens egen melding anbefaler — help-teksten, README-en og denne raden
|
||
beskrev en sti ingen argv kunne ta (Fase-3-klassen, på tvers av tre flater samtidig). Det som
|
||
nektes er en PARK (en etappe som returnerer før noen kandidat finnes), aldri et LØFT. Vitnet er
|
||
`test_the_door_composes_with_resume`, som før økt 91 sendte hverken `--resume`,
|
||
`--checkpoint-dir` eller `--review-inbox` og altså var en vanlig enkeltkjøring T13 alt dekket —
|
||
grønn mot nettopp den defekten den var navngitt for (repoets vakuøs-gate-klasse, ATTENDE gang);
|
||
den driver nå en ekte park → svarfil → resume og er RØD mot den bare vakten.
|
||
Den hostede flaten nekter ved navn som en **pre-whitelist rå-payload-sjekk**, ikke en fjerde
|
||
liste-oppføring: `_CONSUMED_FIELDS` må være disjunkt fra `run_project`s parametre (Fase 4es
|
||
negative halvdel) mens `proposal_reviewer` ER en av dem, og den generiske
|
||
`unknown field(s)`-nekten fyrer FØRST — et navn overlatt til den ville gitt samme 400 med en
|
||
melding som ikke sier hvor døra faktisk er. **F2 står: en `approve` mynter INGEN `Verdict`**
|
||
(M14), og `provenance.validator_decision` speiler fortsatt KUN validatoren.
|
||
**Load-bearing MÅLT** (`tests/test_proposal_review_loop_loadbearing.py`, 49 armer),
|
||
**M1–M40 i ÉN liste, 41 kjøringer (M26 er to lengder), 40 RØDE mot HELE suiten** + grønn kontroll
|
||
**1363/5** (den kontrollen mutasjonene FAKTISK kjørte mot; README-armen i steg 10 gjør den
|
||
1364/5 etterpå) og golden `demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1` av INNHOLDET =
|
||
`ea8c534773acdbe41ae68f2c55724d69aaf8be4f`, ALDRI git-blob-id-en): M1 detach reviewer-kallet (16) ·
|
||
M2 alltid approve (13) · M3 print-and-discard av feedback (6) · M4 ikke-klebrig feedback (1) ·
|
||
M5 akkumuler avvisninger (1) · M6 vis også en AVVIST kandidat (4) · M7 revise tikker ikke
|
||
rundeboka (1) · M8 revisjoner løkker UTENFOR `max_attempts` (36, 18 eldre testfiler) ·
|
||
M9 `honoured` konstant `True` (6) · M10 `approach_id` alltid `None` (3) · M11 skriv etter returen
|
||
i stedet for fra `finally` (2) · M12 skriv kun ved ikke-tom liste (2) · M13 skriv også uten
|
||
reviewer (3) · M14 la `approve` mynte en `Verdict` (1) · M15 EOF er approve (2) · M16 fang ikke
|
||
feilen ved navn (1) · M17 alt som ikke er revise er approve (1) · M18 drop `single_only`-raden (1)
|
||
· M19 drop `report_forbidden`-raden (1) · M20 bibliotekssømmen wiret, argparse-flagget borte (9) ·
|
||
M21 strømmene bundet ved konstruksjon (1) · M22 slett den hostede nekten (1) · M23 videresend det
|
||
hostede feltet (4) · M24 fersk reviewer per base (1) · M25 render kandidaten som repr (2) ·
|
||
M26a trunker feedback til 20 tegn (5) · M26b til 40 tegn, sentinelen OVERLEVER (3) · M27 D6-
|
||
alternativ b (1) · M28 drop `verdict_key` fra posten (2) ·
|
||
**M29 reverter exit-kontrakten (0 — se under)** · M30 drop
|
||
`--live-dry-run`-nekten (1) · M31 drop `--proposals-from-mandate`-nekten (1) · M32 rendereren
|
||
skriver linja uten reviewer (2) · M33 rendereren returnerer `None` på null (3) ·
|
||
M34 feedback løftet ut av per-approach-kallet (5) · M35 returnert
|
||
liste i stedet for kaller-eid sink (1) · M36 dispatcheren slutter å tråde revieweren (1) ·
|
||
M37 detach CLI-utskriften mens rendereren returnerer linja (2) · M38 `attempts_remaining` fra
|
||
`max_attempts` alene (2) · M39 drop `--checkpoint-dir`-nekten (1) · M40 `honoured=True` ved
|
||
revise-tid (2).
|
||
**ÉN MUTASJON FORBLIR GRØNN, OG DET ER ET FUNN — IKKE EN GATE:** M29 reverterer `last_ruling` til
|
||
`assert last is not None`, og HELE suiten står grønn. Planens «Critical risk #1» — at
|
||
«validert → revise» på hvert forsøk ville nå halen med `last is None` — er dermed **FALSIFISERT AV
|
||
MÅLINGEN**: D1(a) RETURNERER inne i løkka når `remaining == 0`, og på siste forsøk er
|
||
`max_attempts - i - 1` alltid 0, så halen er nåbar KUN etter en validator-AVVISNING, som setter
|
||
`last` også. Bæreren er derfor **UVITNET** (`budget_stop`-presedensen) — den står fordi den gjør
|
||
D6 eksplisitt og fjerner en assert som hviler på en ikke-lokal invariant, ikke fordi en test
|
||
holder den. Kommentaren i `generate.py` som PÅSTO at asserten ville fyrt er rettet i samme
|
||
slengen (Fase-3-klassen: en påstand flaten gjør om seg selv); commit-teksten for `bbf4d3b` bærer
|
||
fortsatt den gamle påstanden, og historikken skrives ikke om.
|
||
**TO ARMER VAR GRØNNE AV FEIL GRUNN (repoets vakuøs-gate-klasse, SEKSTENDE og SYTTENDE gang),
|
||
begge funnet i steg 1–8:** (i) `report_forbidden`-armens ledger-fikstur var et JSON-OBJEKT, som
|
||
`SavingsLedger.load` uansett nekter — rc 1 kom fra fiksturen, ikke fra raden; den er nå en JSON-
|
||
ARRAY med en rc-0-kontroll på en argv report-modus ellers ville AKSEPTERT. (ii) «offered, never
|
||
consulted»-armen kjørte et TO-stegs manus mot `max_attempts=3`, så det tredje forsøket falt
|
||
gjennom til selectorens default-svar, som aldri parser — rundeboka fyrte og armen var grønn av en
|
||
helt annen mekanisme; manuset har nå like mange oppføringer som `max_attempts`.
|
||
**README-armen har intet M-nummer** (lista lukket ved M40) og ble drevet RØD TO ganger, fordi
|
||
«blokka mangler» og «blokka er ufullstendig» er ulike feil og bare den andre er dét gaten finnes
|
||
for: først mot README-en slik den STO (uttrekket fant ingenting), så med blokka på plass men
|
||
`--checkpoint-dir`-setningen omskrevet til å beskrive nekten uten å NAVNGI flagget. Kontrollen er
|
||
`--plan-review`-blokka, som har eksistert siden F4.
|
||
**K2-omkjøringen (kriterium 8), samme base og samme syntetiske prisfikstur som S7b/S2c**,
|
||
instrumentet validert mot en KJENT POSITIV FØR bruk (rotnivå-listingen på levert K2: 3 954 tegn /
|
||
1 495 o200k-tokens over 629 konsepter, S7a-3s publiserte tall reprodusert eksakt):
|
||
utforskningen **12 prompter / 18 355 tokens UENDRET til tokenet**, debatt-promptene **UENDRET**
|
||
(proposer 2 → 2 à 314 tokens, checker 1 → 1 à 199), genererings-promptene **2 → 4** (én ekstra per
|
||
tilnærming), totalt **17 → 19 prompter og 19 274 → 19 776 tokens (+2,6 %)**. Ekspertens ord står
|
||
ORDRETT i nøyaktig de to andre-forsøks-promptene (2 av 6), utfallet flytter seg **200 000 →
|
||
150 000 NOK** og dom-nøkkelen `be8535e204cdc4c6` → `f23ecff85f4188b5`, mens
|
||
`{run_id}-proposal-reviews.json` bærer feedbacken ordrett med `honoured: true`.
|
||
**Ærlighets-grenser, uttalt:** Steg 5 UNDER-rapporterer på en revidert kjøring (en revise bruker
|
||
ett av de SAMME `max_attempts`-forsøkene, så `refinements` kan mangle en falsifisering som aldri
|
||
rakk å skje); `coverage`-radene navngir ALDRI en revise som årsak til en `not_evaluated`
|
||
(rundeboka er delt — sann, og `coverage` er et non-goal); feedback-teksten er UBEGRENSET som
|
||
plan-review-feedbacken, belastet det bundne `max_tokens`; checker-gaten og dimensjons-gaten
|
||
overstyrer ETTER at genereringen har returnert, så en `approve` registrert ordrett kan sitte på en
|
||
kjøring hvis utfall er en checker-kildet `Rejection` — posten sier hva mennesket SÅ og SVARTE,
|
||
aldri hva kjøringen konkluderte, og å blande dem er nøyaktig dét to-falsifiserer-raden forbyr;
|
||
F4s traceback-asymmetri er URØRT (`PlanReviewInputError` forlater fortsatt CLI-en som traceback);
|
||
`run_portfolio` tar INGEN reviewer, og fraværet er ASSERTERT; K2-prisene er SYNTETISKE og ingen
|
||
LEVENDE modell har svart på en review (structured-output-grensens klasse). Måling:
|
||
`docs/2026-09-04-major2-proposal-review-k2.md`.
|
||
- **Debatten kan få et DEKLARERT KUTT i stedet for pekeren, og kuttet kan ikke levere bytes basen
|
||
ikke holder (OKF-pre-passet, 07.09, ordre `20260907T080223Z`):** S2c ga debatten en peker og fire
|
||
navigatørverktøy, og den navigerer godt — målt 06.09 nådde en levende modell prisformen i TRE
|
||
steg av 630 konseptdokumenter. Det er samtidig et **UERKLÆRT kutt**: ingenting i kjøringen sa hvor
|
||
mange konsepter som ble vurdert, hvor mange holdt tilbake, eller etter hvilken regel.
|
||
Konsumkontraktens § 2.3 (`llm-ingestion-okf/docs/consumption-contract.md` @ `54a0bc2`, normativ)
|
||
kaller det en nevnersvikt forkledd som et svar — samme regel repoet alt holder under
|
||
`skipped_links`, `unkeyed_verdicts` og `cost_baseline_anchored`. `--prepass-payload FILE` gir
|
||
kjøringen et `okf-consumption/1`-payload: de leverte utdragene PLUSS de tre nevnerne.
|
||
**po produserer intet payload og vendrer ingen produsent** (§ 2.4: transporten er ikke del av
|
||
kontrakten) — en subprosess mot produsentens checkout ville bundet pakka til en sti på én maskin
|
||
og dødd i `git archive HEAD`; en kopi av et 1 038-linjers rangeringsinstrument er kø-(p).
|
||
**VERKTØYENE TREKKES under et payload** (§ 2.2: kontekst pre-passet holdt tilbake ble holdt
|
||
tilbake med vilje) — en debatt som holder BEGGE er fri til å gå rundt kuttet den nettopp
|
||
erklærte. MCP-appenden ligger BEVISST under forgreningen: dette trekker navigatørverktøyene, ikke
|
||
verktøylista (M17 → 4 røde). Målt: `tools=[]` når tråden som `tools: None`, så ingen uprøvd
|
||
tom-array-form innføres. **INJEKSJONSFLATEN ER LUKKET VED KONSTRUKSJON, ikke ved prosa:** `sha256`
|
||
digester HELE den monterte fila mens `text` er et AVLEDET medlem, så et payload kan bære korrekt
|
||
digest ved siden av vilkårlig tekst — og `text` er dét som lander i task-meldingen.
|
||
`verify_against_bundle` RE-UTLEDER teksten lokalt (frontmatter delt på `splitlines()`, NFC,
|
||
per-linje `rstrip` — TRANSKRIBERT fra produsentens kilde og MÅLT mot et ekte payload; en naiv
|
||
`split("\n")` er UENIG, M10 → 20 røde) og krever likhet, så et payload ikke kan levere bytes
|
||
basen ikke holder. Eksponeringen er dermed «basens eget innhold i prompten», som `read_file` alt
|
||
gjør; det som gjenstår er POSISJONEN, og teksten legges i en avgrenset DATA-blokk under
|
||
instruksjonen (§ 9.3) — lindring, uttalt som det. **De to gatene som bodde i det tilbaketrukne
|
||
`read_file` er reist på nytt på det MONTERTE dokumentet** (verdict-laget og § 4.1a), aldri
|
||
delegert til produsentens egne regler — produsenten ekskluderer verdict-laget selv, og dét er
|
||
nøyaktig grunnen til at en av repoets nyest gatede invarianter ikke kan hvile på en fil en ekstern
|
||
kaller leverte. **`delivered == 0` NEKTES ved navn før debatten**, med nevnerne, spørsmålet og
|
||
ref-en sitert: målt er den tilstanden bare nåbar når hvert konsept feilet leksikalsk, altså bevis
|
||
for FRAVÆR (§ 7.3s egen posisjon), og uten den falt kjøringen gjennom til siteringsvakten hvis
|
||
melding navngir `docs_dir` — `None` på denne stien. **Siteringene bygges av de LEVERTE
|
||
konseptene** (629 → 8 på K2): et stempel som siterte hele korpuset for et forslag som så åtte
|
||
dokumenter gjenoppfinner den uerklærte påstanden inne i selve etterprøvbarhets-artefaktet.
|
||
**`ref` bæres, aldri re-beregnet** — `sha256-tree` er produsentens algoritme; vi verifiserer de
|
||
leverte dokumentene, ikke hele treet (uttalt ærlighets-grense). `RunResult.prepass` og
|
||
`DryRunReport.prepass` DEFAULTER (`skipped_links`-halvdelen: `None` er det sanne utsagnet «ingen
|
||
payload ble gitt»); `ProvenanceStamp` er BEVISST urørt (stempelet beskriver gaten som dømte ÉN
|
||
kandidat). `prepass_notice` er ENESTE renderer, `None` uten payload, og omisjonen er gatet av
|
||
golden-transkriptet som uavhengig, eksisterende vitne (M23 → 2 røde).
|
||
`{run_id}-prepass.json` skrives IFF et payload ble gitt, fra `finally`, ved et DIREKTE kall (ikke
|
||
`_write_or_report`, hvis påkrevde `in_flight` bindes først i genererings-blokka og hvor `None`
|
||
ville latt en `OSError` fortrenge en `BudgetExceeded` i luften) — og tilstedeværelsen KVALIFISERER
|
||
`{run_id}-debate.json`s nå-alltid-tomme `tool_calls`, som ellers er uskillbar fra S2c-regresjonen
|
||
den fila skrives ubetinget for å synliggjøre. Seks CLI-nekter, hver ved NAVN med rc-0-kontroll;
|
||
`hosting.py` er BEVISST URØRT (MAJOR-4/S7b) — feltet er i ingen av de tre settene, så den
|
||
generiske 400-en svarer og Fase 4es to halvdeler står, gatet av en testarm i stedet for en
|
||
redigering. **Load-bearing MÅLT: 32 mutasjoner, ALLE RØDE mot HELE suiten** + grønn kontroll
|
||
**1467 passed / 5 skipped** (fra 1387/5; **+80 node-ider, 0 fjernet**, målt med `comm` mot en
|
||
baseline tatt før første commit) og golden `demo-transcript.stdout` BYTE-UENDRET (`shasum -a 1`
|
||
av INNHOLDET = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`). **TRE MUTASJONER VAR GRØNNE FØRST, og
|
||
alle tre var TESTFEIL** (vakuøs-gate-klassen, nittende til tjueførste gang): M9 satte
|
||
`text_sha256` fra den INJISERTE teksten, så `text_sha256`-grenen fyrte og armen matchet på
|
||
`"text"` — en DELSTRENG av `text_sha256`; M18s fixturbase leverer nøyaktig de fire konseptene
|
||
`bundle_citations` returnerer, så «siter de leverte» og «siter alt» ga SAMME sett; M32 falt
|
||
gjennom til «`--explore` requires `--explore-config`», som også navngir `--explore` (økt 57s
|
||
regel ordrett). **Ærlighets-grenser, uttalt:** ingen LEVENDE modell har lest et rendret kutt;
|
||
dette er IKKE en besparelse (like-for-like på K2: 7 031 → 10 641 prompt-tokens, +51 %, ti prompter
|
||
→ tre) men et DEKLARERT kutt og et re-målbart `ref`; en TOM leveranse er bevis for fravær mens en
|
||
FULL **ikke** er bevis for tilstedeværelse — målt returnerer «Hvilken farge har fyrtårnet i
|
||
Alexandria?» åtte arkitekttegninger, og **5,5× dyrere** enn det gode spørsmålet, mens debatten med
|
||
verktøyene trukket ikke har noen vei til å oppdage det selv; `--explore` er NEKTET, ikke løst, så
|
||
utforskningens eget kutt er fortsatt uerklært; `budget.limit` er produsentens valg (vi nekter
|
||
`spent > limit`, vi setter ikke taket, og testen binder OVERHEADET — O(levert tekst) + O(1) — ikke
|
||
totalen); og **pre-passet kan ikke lese en eneste av repoets egne baser** (ingen erklærer
|
||
`bundle_id` på rot-indeksen, S7a-3s måling sett fra produsentsiden, og `shared/` er pull-only), så
|
||
fixturen er bygget på en KOPI med erklært id. Måling:
|
||
`docs/2026-09-07-okf-prepass-i-debatten.md`.
|
||
- **Det samme kuttet kan være et UTGANGSPUNKT i stedet for en erstatning — og hvilket av de to det
|
||
var er et felt, ikke en tone (Q5=B, 08.09, ordre `20260907T234344Z`):** `--prepass-payload` gir
|
||
DEBATTEN kuttet og trekker de fire navigatørverktøyene; `--prepass-seed` gir UTFORSKNINGEN det
|
||
samme kuttet som startpunkt og **beholder** verktøyene. **Nekten M32/F4 står ordrett** — B er et
|
||
NYTT flagg, aldri en løsning av den — og hjemmelen er konsumkontraktens § 2.2, som forbyr å lese
|
||
«outside what the payload delivers **or explicitly names as reachable**»: andre ledd er hele arm
|
||
B. **`admit_payload` er ÉN opptaks-gate** (form → montert base → tom-leveranse-nekt) delt av
|
||
begge dører; to kopier ville latt én dør slippe inn det den andre nekter (kø-(p)).
|
||
**`PrepassDeclaration.rest_reachable` er PÅKREVD uten default** av `cost_baseline_anchored`s
|
||
grunn — `False` ville latt en kjøring som beholdt verktøyene påstå at kuttet var alt den kunne
|
||
lese, `True` ville latt armen som TRAKK dem påstå at basen sto åpen — og `prepass_notice` er
|
||
fortsatt ENESTE renderer, nå med to armer, fordi «8 av 630» sier det motsatte av sannheten i
|
||
nøyaktig ett av de to tilfellene. **Kuttet rir i TASK-MELDINGEN, aldri i `prompt`**
|
||
(`explore(seed_context=…)`): `_finish` bygger `Mandate.objective` av `prompt`, og en kommisjon med
|
||
22 335 tokens utdrag i objektivet er uleselig for den som skrev den; tom streng ⇒ byte-identisk
|
||
med i dag. Deklarasjonen når `{run_id}-exploration.json` via `trace_payload(prepass=…)` skrevet
|
||
fra `finally` — **defaultet** (`skipped_links`-halvdelen), og MÅLT bærende: den seedede kjøringen
|
||
som døde på en Azure-400 etterlot likevel kuttet deklarert. Fem nekter ved navn, og
|
||
`--checkpoint-dir` er den som bærer en beslutning: en gjenopptatt etappe kjører i en prosess som
|
||
aldri så payloaden og ville overskrevet den parkerte etappens deklarasjon med `prepass: null`.
|
||
**`--dimension-config` er BEVISST IKKE nektet** (arm A nekter den): målt bygger utforskningen
|
||
`navigator_tools(bundle_dirs)` UTEN dimensjon, så å skope seedet ville nektet tekst den samme
|
||
løkka kan åpne med `read_file` et øyeblikk senere. **MÅLT PÅ K2 MED LEVENDE MODELL, og
|
||
målingen taler MOT å gjøre B til default:** like-for-like gratis **4 317 → 227 675 o200k
|
||
(× 52,7)**, betalt er manageren **× 21** på samme antall prompter, og — viktigere — den USEEDETE
|
||
kontrollen hentet prisskjemaet i FIRE steg
|
||
(`del-ii-bilag-7-prisskjema/prissammenstilling-sheet-1.md`) mens BEGGE seedede armer lot være:
|
||
den ene med NULL verktøykall fordi manageren rutet til hypotesisereren i alle tre runder, den
|
||
andre ved å gjette stier ut av kuttets egne konsept-navn og mynte en base-id som ikke finnes.
|
||
**Erkjennelsen kom, handlingen ikke** — manageren skrev i hver runde at utdragene ikke rakk.
|
||
Ingen av de 40 svarene brukte ett eneste av kontraktens fem literaler (kontrast S7s arm A, som
|
||
brukte `[sourced-not-sufficient]` ordrett). **NOK 2,78 av taket 5, 0× 429.** Load-bearing MÅLT
|
||
(`tests/test_prepass_seed_door_loadbearing.py`, 26 armer), **16 mutasjoner alle røde mot HELE
|
||
suiten** + grønn kontroll **1493/5** og golden `demo-transcript.stdout` BYTE-UENDRET
|
||
(`shasum -a 1` av INNHOLDET = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 detach CLI-wiringen
|
||
(2) · M2 `explore()` ignorerer seedet (2) · M3 kollaps B inn i A (1) · M4 seedet uten utforskning
|
||
(1) · M5 de to armene tillates sammen (1) · M6 `--checkpoint-dir` tillates (1) · M7/M8 ut av
|
||
portefølje-/report-partisjonen (1+1) · M9 konstant `rest_reachable` (1) · M10 deklarasjonen
|
||
forlater aldri CLI-en (1) · M11 feltet ut av artefaktet (2) · M12 den seedede renderingen sier
|
||
«du har ingen verktøy» (1) · M13 opptaks-gaten svelger alt (7, hvorav TRE i tester eldre enn dette
|
||
arbeidet) · M14 kuttet deklareres til ingen (1) · M15 detach id-enighets-gaten ved denne døra (1)
|
||
· README-armen (1). **TO ARMER VAR GRØNNE AV FEIL GRUNN (repoets vakuøs-gate-klasse, TJUEANDRE og
|
||
TJUETREDJE gang), begge funnet av mutasjonene:** (i) verktøy-armen asserterte på `tool_calls`
|
||
alene, og recorderen appender FØR `call_next`, så en tool som reiste «unknown knowledge base»
|
||
etterlot et byte-identisk spor — «et verktøy ble kalt» og «basen var åpen» er ulike fakta, og
|
||
armen krever nå at basens EGEN indekstekst kommer tilbake; (ii) id-enighets-armen redigerte ÉN
|
||
konseptfil, men `assert_declared_ids_agree` leser konsepter og én erklæring er en base som er
|
||
enig med seg selv — nekten kom fra den STALE DIGESTEN, og armen bruker nå TO konsepter og et
|
||
re-digestet payload. **Sonden var dessuten feil før koden var det:** første diskriminator var
|
||
norsk («rask småskala-testing»), og verktøyresultatet serialiseres med `\uXXXX`-escapes, så armen
|
||
var rød mot en virkende implementasjon — S2c-målingen gjentatt. **Ærlighets-grenser, uttalt:** tre
|
||
betalte kjøringer på ett spørsmål er ikke et utvalg; de to seedede endte ulikt (Azure-400 vs
|
||
rundetak); ingen arm nådde pipelinen, så siteringene i stempelet er IKKE talt — og for en seedet
|
||
arm ville en full kjøring kostet ~NOK 3,2 mot NOK 2,22 igjen av taket, hvilket ER funnet; arm A
|
||
og C er GJENBRUKT fra økt 98 og er dessuten DEBATT-armer mot B-ens utforskning; og
|
||
`ChatClientException` (Azure 400 etter tre `quick_validate`-nekter på rad) er RAPPORTERT, ikke
|
||
fikset — den ligger utenfor `main()`s nekt-tuppel og forlater CLI-en som traceback. Måling:
|
||
`docs/2026-09-07-prepass-mater-q5b-k2.md`.
|
||
- **`read_dir` på et DOKUMENT navngir rungen som leser det — og ordrens premiss ble FELT før noe
|
||
ble bygget på det (F3, 08.09, ordre `20260908T020419Z`):** ordren leste de to nektede live-kallene
|
||
(`read_dir('del-ii-bilag-6-teknisk-oppsett')` + `…-oppsett.md`, § 4 i syretesten) som «stien
|
||
navngir et dokument som FINNES». **MÅLT mot basen som kjørte** holder rotnivået 27 kataloger
|
||
`del-ii-bilag-N-…` og 12 dokumenter `inbox-del-ii-bilag-N-….md`; stien matcher **verken** — den er
|
||
katalog-navnekonvensjonen anvendt på et dokument hvis ekte navn bærer et `inbox-`-prefiks. De to
|
||
rundene var altså UKJENT-sti-klassen, og **denne leveransen gjenoppretter dem IKKE** (gatet av
|
||
`test_the_measured_live_path_is_still_the_unknown_class`); å resolvere dem ville vært å gjette
|
||
hvilket dokument en kaller MENTE — invensjon, ikke validering. **Det som ER ekte er asymmetrien:**
|
||
`read_file` på en katalog har siden økt 95 svart `DirectoryPathRefused` som navngir `read_dir`,
|
||
mens `read_dir` på et dokument svarte den generiske «has no directory» og navnga verken rungen
|
||
eller stien. `okf.DocumentPathRefused` lukker den ene retningen: en `ValueError`
|
||
(`BundlePathNotFound`/`DimensionScopeRefused`-presedensen) og en **SØSKEN av `BundlePathNotFound`,
|
||
aldri en subklasse** — «dette er et dokument» og «dette er ingenting» er ulike fakta, og en kaller
|
||
som switcher på det første skal ikke besvares av det andre. Oppslaget bygges av `context_files`,
|
||
ALDRI `files` (M2 → 1 rød: en suggestion fra vandringen ville navngitt et `type: verdict`-dokument
|
||
ved sti — i en NEKT — altså det ene laget ingen listing nevner og `read_file` avviser blankt), og
|
||
gjennom SAMME `in_dimension`-predikat listingen bruker (M3 → 1 rød: §4.1a invertert, å navngi et
|
||
dokument kjøringen straks ville nektet å åpne er S2cs «filter i navnet alene»). Dokumentets EKTE
|
||
navn siteres, aldri kallerens sti (M5 → 2 røde — `_index_excerpt`-regelen: en sti som aldri fantes
|
||
er verre enn ingen sti; armen mater den navngitte stien tilbake til `read_file`). De to grenene
|
||
deler BEVISST ingen ordlyd (M4 → 4 røde), og arm (g) i
|
||
`test_hierarchical_navigation_loadbearing` er SKREVET OM — ikke svekket — fra `ValueError` til
|
||
`BundlePathNotFound` ved navn, fordi begge nekter siterer kallerens sti og et treff på stien alene
|
||
ikke lenger kan skille dem. Load-bearing MÅLT (`tests/test_read_dir_wrong_rung_loadbearing.py`,
|
||
8 armer), **fem mutasjoner alle røde mot HELE suiten** + grønn kontroll **1511/5** og golden
|
||
BYTE-UENDRET (`shasum -a 1` av INNHOLDET = `ea8c534773acdbe41ae68f2c55724d69aaf8be4f`): M1 detach
|
||
dokument-grenen (4) · M2 bygg fra `files` (1) · M3 ignorer dimensjonen (1) · M4 kollaps de to
|
||
grenenes ordlyd (4) · M5 ekko kallerens sti (2). **Ærlighets-grenser, uttalt:** ingen LEVENDE
|
||
modell har lest den nye nekten, så at den endrer neste trekk er ikke bevist
|
||
(structured-output-grensens klasse); `read_dir`s verktøybeskrivelse er URØRT — den påstår
|
||
ingenting usant, og en utvidelse ville vært prosa uten en gate. Måling:
|
||
`docs/2026-09-08-f3-f4-nekten-og-forankringen.md` § 1.
|
||
- **En kjøring KAN kreve at gaten er forankret, og nekten koster ingenting (F4, 08.09, samme
|
||
ordre):** MÅLT på nytt mot de fire artefaktene den betalte S7-kjøringen etterlot: alle armer
|
||
stemplet `cost_baseline_anchored: False`, stage 0 ble hoppet over, og hver arm fant på kodene sine
|
||
(`ENGRAVE_MARK` · `RITB-HOURS`/`SYSINT-HOURS` · `RITB-consultancy`/`system-integrator` ·
|
||
`Material_Cost_Concrete`/`…_Steel`/`Construction_Heating_Fuel`). **Ordrens opsjon (c) er FELT AV
|
||
MÅLING:** `derive_cost_baseline` mot den leverte basen nekter — K2s prisskjema er en pandoc SIMPLE
|
||
table med ÉN kolonneoverskrift (`Prisskjema`) og hver verdi kollapset i den, så å gjøre
|
||
`--derive-cost-baseline` nåbart der ville krevd en regel for en form ingen har målt, som er
|
||
MAJOR-4s egen ærlighets-grense. **Valgt (b), ikke (a):** synligheten (`cost_baseline_notice`)
|
||
finnes og er ærlig, men den kan ikke stoppe et maskinlesbart artefakt som sier
|
||
`validator_decision: validated` over linjer ingenting forankret. `--require-cost-baseline` /
|
||
`run_project(require_cost_baseline=…)` er **OPT-IN, aldri default** — hver base uten
|
||
`cost-baseline.json`, altså hver commons-eid golden, kjører uendret, som er dét (a) beskyttet
|
||
(M12, gaten fyrer uansett flagg → **171 røde**). `UnanchoredRunRefused` er en `ValueError`
|
||
(`BundleIdMismatch`/`CostBaselineDerivationError`-presedensen): en argv som tar feil om hva denne
|
||
basen kan tilby hører på CLI-ens nekt-tuppel og hostings 400-arm, aldri krasj-kanalen. **Gaten bor
|
||
ÉTT sted — der BEGGE grener har bundet `baseline`, og OVER dry-run-kuttet** (M7 → 1 rød): den
|
||
frie turen er den billigste å lære det på, og på den betalte fyrer den før første modellkall ved
|
||
konstruksjon — armen asserterer NULL kall, aldri bare unntaket, fordi en nekt etter forbruket ser
|
||
identisk ut ved exit-koden (økt 57s regel). Tre CLI-nekter, hver med en rc-0-kontroll på en argv
|
||
som ellers ville blitt AKSEPTERT: krever `--bundle-dir` (veg-stien er forankret ved konstruksjon,
|
||
så der kunne flagget aldri fyre — et flagg som ikke kan fyre er en påstand flaten gjør om seg
|
||
selv, Fase-3-klassen), refusert i `--portfolio` VED NAVN (M9 → 1 rød med egen signatur: uten den
|
||
STARTER mutanten et porteføljepass og når modellen med `ChatClientException`, altså er nekten dét
|
||
som holder argv-en fra å koste noe) og i `report_forbidden` (report-modus returnerer OVER hver
|
||
dispatch, så en utelatelse er et stille DROPP — F4-gapets egen klasse). Load-bearing MÅLT
|
||
(`tests/test_require_cost_baseline_loadbearing.py`, 10 armer), **sju mutasjoner alle røde mot HELE
|
||
suiten** + samme grønne kontroll og golden: M6 detach gaten (3) · M7 gaten under dry-run-kuttet
|
||
(1) · M8 dropp fra `report_forbidden` (1) · M9 dropp fra portefølje-partisjonen (1) · M10 detach
|
||
`--bundle-dir`-kravet (1) · M11 detach fullkjørings-wiringen (1) · M12 gaten fyrer uansett flagg
|
||
(171). **Ærlighets-grenser, uttalt:** den hostede flaten er BEVISST urørt (feltet er i ingen av
|
||
hostings tre sett, så den generiske 400-en svarer og Fase 4es to halvdeler står — MAJOR-4s eget
|
||
valg gjentatt); stempelet sier fortsatt AT en kjøring var forankret, aldri HVILKEN av de tre
|
||
projeksjonene som forankret den; og ingen betalt kjøring er gjort — begge funn er målt offline mot
|
||
basen og artefaktene økt 98 etterlot. Måling:
|
||
`docs/2026-09-08-f3-f4-nekten-og-forankringen.md` § 2.
|
||
- **STATE.md er local-only** (gitignored). Voyage session-state er efemert; STATE.md er kanonisk kontinuitet.
|
||
- Prosess: Voyage-plugin (`/trekbrief → /trekplan → /trekexecute → /trekreview`) per større fase.
|
||
|
||
## Communication patterns
|
||
|
||
When linking to local files in responses, use named markdown links — `[Human-friendly name](file:///absolute/path)`, never bare `file://` URLs or autolinks `<file://...>`, always absolute paths (never `~/` or relative), one bullet per file when there are several. (Bare `file://` URLs render only the first as clickable across multiple lines; named links stay independently clickable.)
|