open/portfolio-optimiser
1
0
Fork 0
Code Issues Releases 4 Activity

feat(prepass): --prepass-seed makes the cut a starting point, and K2 says it costs

Browse source 
Q5 = B, bygget som MAALT OPSJON. --prepass-payload gir DEBATTEN et deklarert
kutt og trekker de fire navigatoerverktoeyene; --prepass-seed gir UTFORSKNINGEN
det samme kuttet som utgangspunkt og BEHOLDER verktoeyene.

Nekten M32/F4 staar ORDRETT. B er et nytt flagg, aldri en loesning av den, og
hjemmelen er konsumkontraktens SS 2.2: en skill maa ikke lese «outside what the
payload delivers or explicitly names as reachable». Andre ledd er hele arm B, og
PrepassDeclaration.rest_reachable er det som gjoer de to lesningene skillbare i
ettertid -- paakrevd uten default av cost_baseline_anchoreds grunn, fordi begge
defaults ville loeyet om hvilken arm som leste kuttet.

Soemmene:
  admit_payload er EN opptaks-gate (form -> montert base -> tom-leveranse-nekt)
    delt av begge doerer; to kopier ville latt en doer slippe inn det den andre
    nekter.
  render_seed deler header, regel->ANTALL-foldingen og DATA-blokkene med
    render_context. Det eneste som skiller dem er avsnittet som sier hva
    leseren kan gjoere videre.
  explore(seed_context=...) legger kuttet i TASK-MELDINGEN, aldri i prompt:
    _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 gir
    en byte-identisk task-melding.
  trace_payload(prepass=...) skriver deklarasjonen fra en finally. MAALT baerende
    -- den seedede kjoeringen som doede paa en Azure-400 etterlot likevel kuttet
    deklarert.
  Fem nekter ved navn. --checkpoint-dir baerer en beslutning: en gjenopptatt
    etappe kjoerer i en prosess som aldri saa payloaden og ville overskrevet den
    parkerte etappens deklarasjon med prepass: null.
  --dimension-config er BEVISST ikke nektet (arm A nekter den): maalt bygger
    utforskningen navigator_tools(bundle_dirs) UTEN dimensjon, saa aa skope
    seedet ville nektet tekst den samme loekka kan aapne et oeyeblikk senere.

MAALT PAA K2 MED LEVENDE MODELL, og maalingen taler MOT aa gjoere B til default:
like-for-like gratis 4 317 -> 227 675 o200k (x 52,7), og betalt er manageren
x 21 paa samme antall prompter. Viktigere enn prisen: den USEEDETE kontrollen
hentet prisskjemaet i fire steg (del-ii-bilag-7-prisskjema/prissammenstilling-
sheet-1.md), mens BEGGE seedede armer lot vaere -- den ene med null verktoeykall
fordi manageren rutet til hypotesisereren i alle tre runder, den andre ved aa
gjette stier ut av kuttets egne konsept-navn og mynte en base-id som ikke finnes.
Erkjennelsen kom (manageren skrev i hver runde at utdragene ikke rakk),
handlingen ikke. Ingen av de 40 svarene brukte ett eneste av kontraktens fem
literaler. NOK 2,78 av taket 5, 0 x 429. Anbefaling skrevet, beslutning ikke
tatt -- den er operatoerens.

Load-bearing maalt: 26 armer, 16 mutasjoner alle roede mot HELE suiten, groenn
kontroll 1493 passed / 5 skipped (fra 1467/5; +26 node-ider, 0 fjernet), golden
demo-transcript.stdout byte-uendret (shasum -a 1 av innholdet =
ea8c534773acdbe41ae68f2c55724d69aaf8be4f).

To armer var GROENNE AV FEIL GRUNN og ble rettet, ikke droppet: tool_calls alene
kan ikke skille «et verktoey ble kalt» fra «basen var aapen», fordi recorderen
appender FOER call_next; og id-enighets-armen maalte den stale digesten i stedet
for id-gaten. Sonden var dessuten feil foer koden var det -- foerste
diskriminator var norsk, og verktoeysvar serialiseres med \uXXXX-escapes.

Avvik, uttalt: implementasjonen ble skrevet FOER testfila. Roedmaalingen er gjort
etterpaa ved aa reversere src/ til HEAD (16 av 24 armer roede), deretter
restaurert med shasum-verifikasjon. Beviset er ekte, rekkefoelgen var ikke.

Rapportert, ikke fikset: ChatClientException (Azure 400, «No tool call found for
function call output») etter tre quick_validate-nekter paa rad -- den ligger
utenfor main()s nekt-tuppel og forlater CLI-en som traceback.

Azure-konfigurasjonen er uendret; endepunktet utledes inline fra az og er aldri
lagret i fil. Ruff + mypy rene.

Maaling: docs/2026-09-07-prepass-mater-q5b-k2.md
Ordre: 20260907T234344Z-9062321009-from-.claude

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-09-08 04:02:09 +02:00
commit 76b939b3b8
9 changed files with 1474 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

35
src/portfolio_optimiser/explore.py
View file

@ -434,7 +434,12 @@ def tool_call_payload(calls: Sequence[ToolCall]) -> list[dict[str, Any]]:
def trace_payload(
trace: ExplorationTrace, *, stop: str | None, completed: bool, mandate: Mandate | None
trace: ExplorationTrace,
*,
stop: str | None,
completed: bool,
mandate: Mandate | None,
prepass: Mapping[str, Any] | None = None,
) -> dict[str, Any]:
"""The ONE rendering of a trace into plain data for ``outbox.write_exploration``.
@ -454,10 +459,18 @@ def trace_payload(
a park), which is exactly what ``completed=False`` already says. Collapsing that into an
empty list would make "the loop formed no approaches" and "the loop never got that far"
unreadable from each other.
``prepass`` is the declared cut this exploration was SEEDED with (``--prepass-seed``), already
rendered by ``prepass.declaration_payload`` so this module and the outbox both stay free of
that dependency. It DEFAULTS to ``None``, unlike ``completed`` and ``mandate`` above: absence
here is an honest positive statement — no cut was given — which is ``Bundle.skipped``'s empty
tuple rather than ``cost_baseline_anchored``'s required boolean, and it is the same decision
``RunResult.prepass`` already made one surface over.
"""
return {
"completed": completed,
"stop": stop,
"prepass": dict(prepass) if prepass is not None else None,
"tokens_spent": trace.tokens_spent,
"approaches": [
{
@ -1516,6 +1529,7 @@ async def explore(
success_criteria: str = "",
trace: ExplorationTrace | None = None,
checkpoint_dir: str | None = None,
seed_context: str = "",
) -> ExplorationResult:
"""Explore the knowledge bases and return the ``Mandate`` the pipeline should evaluate.
@ -1554,6 +1568,20 @@ async def explore(
``trace`` is the caller's accumulator and is the ONLY way to see what a run that RAISED
produced: both budget channels destroy the ``ExplorationResult`` before it exists. When it is
omitted a private one is used, so the returned result is unchanged for every existing caller.
``seed_context`` is material the CALLER has already verified and wants the loop to START from
— today, one contract-conformant OKF pre-pass cut (``--prepass-seed``). It joins the TASK
MESSAGE and deliberately NOT ``objective``: the objective is what a person commissioned and
what ``Mandate.announce`` prints back to them, so folding ten thousand tokens of excerpts into
it would make the commission unreadable and would put the cut's text into every artefact that
quotes the objective. Empty by default, and an empty string leaves the task message
byte-identical to what it has always been — which is what makes "without the flag, nothing
changed" a property rather than a promise.
**This is a starting point, never a boundary.** The navigator tools are built exactly as they
are without it, because an exploration that could not read past its seed would be the OTHER
arm (``--prepass-payload``, where the cut REPLACES the base and the tools are withdrawn), and
building both behaviours behind one name is how a flag stops meaning anything.
"""
if plan_reviewer is not None and checkpoint_dir is not None:
raise ExplorationError(
@ -1614,7 +1642,10 @@ async def explore(
# With no provider installed this is a no-op tracer and every event is discarded, which is
# exactly what "tracing is off" has meant since U14.
with exploration_tracer().start_as_current_span(EXPLORATION_SPAN) as span:
result = await workflow.run(prompt)
# The seed rides in the TASK MESSAGE, never in ``prompt`` itself: ``_finish`` below builds
# the mandate's ``objective`` from ``prompt``, and a commission whose objective carried the
# whole cut would be unreadable to the person who wrote it.
result = await workflow.run(f"{prompt}\n\n{seed_context}" if seed_context else prompt)
stop, _ = await _drive(
workflow,
result,

173
src/portfolio_optimiser/prepass.py
View file

@ -347,6 +347,52 @@ def _in_dimension(path: Path, dimension: str) -> bool:
)
# --- The one admission gate, shared by every door that consumes a payload --------------------
def admit_payload(
payload: PrepassPayload,
*,
bundle_dir: str,
resolved_id: okf.ResolvedBundleId,
dimension: str | None = None,
) -> None:
"""Everything that must hold before a payload may shape a run. Raises, or returns nothing.
ONE copy, because there are now TWO doors onto this file — the debate's ``--prepass-payload``
(the cut REPLACES the pointer and the tools are withdrawn) and the exploration's
``--prepass-seed`` (the cut is the STARTING POINT and the tools stay). The two arms differ in
what they do with an admitted payload and in nothing at all about what makes one admissible,
and two copies of an admission rule is the ko-(p) drift that would let one door accept what
the other refuses.
The three steps, in this order and for this reason: the shape gate reads no disk and so is
free, the bundle check is the expensive one, and the empty-delivery refusal comes last because
a payload that does not hold has not earned an interpretation of its own emptiness.
**``delivered == 0`` is refused on BOTH arms**, and on the seeding arm that is a decision
rather than an inheritance. Measured, it is reachable only when every concept failed to match
lexically (the producer REFUSES the other empty case, where concepts matched and the budget
admitted none), so it is evidence of ABSENCE for this question at this ref. On the seeding arm
a caller might argue the tools are still there and the run could proceed — but it would then
proceed as a PLAIN exploration while the operator had asked for a seeded one, which is the
silently downgraded order ``load_mandate`` fail-fasts against.
"""
check_payload_shape(payload)
verify_against_bundle(
payload, bundle_dir=bundle_dir, resolved_id=resolved_id, dimension=dimension
)
if not payload.excerpts:
# Saying it beats two silent alternatives: an empty prompt, or falling through to
# ``run_project``'s citation guard, whose message names ``docs_dir`` — ``None`` on this
# path. SS 7.3's own posture: the skill stops and says so.
raise PrepassRefused(
f"the pre-pass delivered 0 of {payload.denominators.considered} concepts for the "
f"question {payload.question!r} at ref {payload.bundle.ref}; an empty cut is evidence "
"that this knowledge base does not answer that question, not something to run over"
)
# --- Rendering the cut for the prompt --------------------------------------------------------
@ -382,24 +428,86 @@ def render_context(payload: PrepassPayload) -> str:
GATE is ``verify_against_bundle``, which makes the text re-derivable from the mounted base, so
a payload cannot deliver bytes the base does not hold.
"""
return "\n".join(
_declaration_lines(payload)
+ [
"",
"Each excerpt below matched the question LEXICALLY. That is not the same as answering "
"it: a base that holds no answer still returns its closest matches. If the delivered "
"text does not support a claim, say so with [sourced-not-sufficient] rather than "
"filling the gap. adjudication and trust_tier are the producer's declarations about "
"each document, carried here unchanged.",
]
+ _data_blocks(payload)
)
def render_seed(payload: PrepassPayload) -> str:
"""What the EXPLORATION is handed IN ADDITION to its prompt, keeping its navigation tools.
The other arm of one decision, and the difference is a single fact stated in both directions:
:func:`render_context` says "you have no tools to read further, what is below is all of it",
which is true there and would be a LIE here. Contract SS 2.2 forbids reading "outside what the
payload delivers **or explicitly names as reachable**" — the second clause is what makes this
arm conformant, and a rendering that did not say the rest was reachable would leave a model
obeying the first clause while holding the tools for the second.
**Not a second copy of the rendering rule.** The declaration header, the rule -> COUNT folding
and the delimited DATA blocks are the SAME functions the other arm uses; what differs is the
one paragraph that tells the reader what it may do next. Two full copies would drift, and a
drifted pair would state two different cuts for one run (ko-(p)).
``[unread]`` is used deliberately, and it is one of contract SS 4.1's five required literals:
a withheld concept in this arm is not absent and not unavailable, it is simply not yet read —
and saying so is what turns the withheld list from a boundary into a next step.
"""
return "\n".join(
_declaration_lines(payload, rest_reachable=True)
+ [
"",
"Each excerpt below matched the question LEXICALLY. That is not the same as answering "
"it: a base that holds no answer still returns its closest matches. The withheld "
"concepts are [unread], not absent — if the delivered text does not support a claim, "
"OPEN THE BASE with your navigation tools rather than filling the gap, and reserve "
"[sourced-not-sufficient] for a claim the base itself could not support. Report what "
"you actually read. adjudication and trust_tier are the producer's declarations about "
"each document, carried here unchanged.",
]
+ _data_blocks(payload)
)
def _declaration_lines(payload: PrepassPayload, *, rest_reachable: bool = False) -> list[str]:
"""The header both renderings open with: the base, what the cut may be used for, the counts.
ONE copy, because these lines ARE the declaration (SS 2.3) and two of them would be two
answers to "what was this run's cut". Only the second line differs between the arms, and it
differs on exactly the fact ``PrepassDeclaration.rest_reachable`` carries.
"""
counts = payload.denominators
rules = ", ".join(f"{rule} ({count})" for rule, count in declaration_of(payload).withheld_rules)
lines = [
rules = ", ".join(f"{rule} ({count})" for rule, count in withheld_rule_counts(payload))
stance = (
"You are reading a DECLARED CUT of that base as your STARTING POINT, not as a replacement "
"for it. The rest of the base stays reachable with your navigation tools, and you are "
"expected to use them when the cut does not carry what you need."
if rest_reachable
else "You are reading a DECLARED CUT of that base, not the base itself, and you have no "
"tools to read further. What is below is all of it."
)
return [
f"Knowledge base: {payload.bundle.bundle_id} (ref {payload.bundle.ref}).",
"",
"You are reading a DECLARED CUT of that base, not the base itself, and you have no tools "
"to read further. What is below is all of it.",
stance,
f"The cut was computed for this question: {payload.question}",
f"Concepts considered: {counts.considered}. Withheld: {counts.withheld}. "
f"Delivered below: {counts.delivered}.",
f"Withheld by rule: {rules}." if rules else "Withheld by rule: none.",
"",
"Each excerpt below matched the question LEXICALLY. That is not the same as answering it: "
"a base that holds no answer still returns its closest matches. If the delivered text "
"does not support a claim, say so with [sourced-not-sufficient] rather than filling the "
"gap. adjudication and trust_tier are the producer's declarations about each document, "
"carried here unchanged.",
]
def _data_blocks(payload: PrepassPayload) -> list[str]:
"""The delimited DATA blocks, one per delivered excerpt (SS 9.3), shared by both arms."""
lines: list[str] = []
for excerpt in payload.excerpts:
lines += [
"",
@ -408,7 +516,7 @@ def render_context(payload: PrepassPayload) -> str:
excerpt.text,
f"--- END DATA {excerpt.concept_id} ---",
]
return "\n".join(lines)
return lines
# --- The declaration -------------------------------------------------------------------------
@ -421,6 +529,15 @@ class PrepassDeclaration:
It reports the payload's OWN denominators verbatim, never a recount off the navigated bundle:
the pre-pass may legitimately have considered a different set (it counts the verdict layer,
``Bundle.context_files`` does not), and two numbers for one fact is ko-(p).
``rest_reachable`` says which of the two arms consumed the cut, and it is REQUIRED WITHOUT A
DEFAULT for ``ProvenanceStamp.cost_baseline_anchored``'s reason: **both defaults would lie.**
``False`` would let a run that kept its navigation tools publish a declaration claiming the cut
was all it could read; ``True`` would let the arm that WITHDREW them claim the base stayed
open. It is the contract's own distinction -- SS 2.2 forbids reading "outside what the payload
delivers **or explicitly names as reachable**", so a conformant consumer may keep the base
reachable, and the difference between the two readings is exactly what a reader of this
declaration needs to know.
"""
bundle_id: str
@ -430,19 +547,34 @@ class PrepassDeclaration:
withheld: int
delivered: int
withheld_rules: tuple[tuple[str, int], ...]
rest_reachable: bool
def declaration_of(payload: PrepassPayload) -> PrepassDeclaration:
"""The declaration a verified payload supports.
def withheld_rule_counts(payload: PrepassPayload) -> tuple[tuple[str, int], ...]:
"""rule -> COUNT, sorted. The ONE folding of the withheld list in this repository.
``withheld_rules`` is rule -> COUNT, sorted. The concept ids are deliberately NOT carried:
measured on a 629-concept corpus the withheld list alone is 34 451 o200k tokens, and a rule
name is the fact a reader can act on while a list of ids they cannot open is cost without
information. The full list stays in the payload, one artefact away.
The concept ids are deliberately NOT carried: measured on a 629-concept corpus the withheld
list alone is 34 451 o200k tokens, and a rule name is the fact a reader can act on while a
list of ids they cannot open is cost without information. The full list stays in the payload,
one artefact away.
It is a function of its own rather than a step inside ``declaration_of`` because THREE
surfaces need it -- the declaration and both renderings -- and a second copy of "how the
withheld list folds" would be free to disagree about the run it describes (ko-(p)).
"""
counts: dict[str, int] = {}
for entry in payload.withheld:
counts[entry.rule] = counts.get(entry.rule, 0) + 1
return tuple(sorted(counts.items()))
def declaration_of(payload: PrepassPayload, *, rest_reachable: bool) -> PrepassDeclaration:
"""The declaration a verified payload supports, for the arm that consumed it.
``rest_reachable`` is a REQUIRED keyword: see :class:`PrepassDeclaration`. The payload cannot
supply it -- a cut does not know what its consumer did with the navigation tools -- so it is
the caller's to state, and every caller states it.
"""
return PrepassDeclaration(
bundle_id=payload.bundle.bundle_id,
ref=payload.bundle.ref,
@ -450,7 +582,8 @@ def declaration_of(payload: PrepassPayload) -> PrepassDeclaration:
considered=payload.denominators.considered,
withheld=payload.denominators.withheld,
delivered=payload.denominators.delivered,
withheld_rules=tuple(sorted(counts.items())),
withheld_rules=withheld_rule_counts(payload),
rest_reachable=rest_reachable,
)
@ -466,4 +599,8 @@ def declaration_payload(declaration: PrepassDeclaration) -> Mapping[str, object]
"withheld_rules": [
{"rule": rule, "count": count} for rule, count in declaration.withheld_rules
],
# Which arm read the cut. An artefact that reported the denominators without saying
# whether the consumer could still open the base would leave a reader unable to tell a
# bounded run from a seeded one -- the same undeclared claim, one level up.
"rest_reachable": declaration.rest_reachable,
}

156
src/portfolio_optimiser/run.py
View file

@ -860,8 +860,17 @@ def prepass_notice(declaration: prepass.PrepassDeclaration | None) -> str | None
if declaration is None:
return None
rules = ", ".join(f"{rule} ({count})" for rule, count in declaration.withheld_rules)
# ONE renderer, two arms — because the number of concepts delivered says nothing at all about
# whether the run could still open the rest, and an operator reading a summary that reported
# "8 of 630" without that would draw the wrong conclusion in exactly one of the two cases.
role = (
"a DECLARED CUT SEEDED the exploration (the rest of the base stayed reachable with the "
"navigation tools)"
if declaration.rest_reachable
else "a DECLARED CUT was used"
)
return (
f" Knowledge base: a DECLARED CUT was used — {declaration.delivered} of "
f" Knowledge base: {role} — {declaration.delivered} of "
f"{declaration.considered} concept(s) delivered, {declaration.withheld} withheld"
f"{' by rule: ' + rules if rules else ''}. "
f"Base {declaration.bundle_id} at ref {declaration.ref}; "
@ -1059,27 +1068,19 @@ async def run_project(
prepass_declaration: prepass.PrepassDeclaration | None = None
debate_tools: list[Any]
if prepass_payload is not None:
prepass.check_payload_shape(prepass_payload)
prepass.verify_against_bundle(
# ONE admission gate, shared with the exploration's seeding door: shape, then the
# mounted base, then the empty-delivery refusal. Two copies of what makes a payload
# admissible would let one door accept what the other refuses (kø-(p)).
prepass.admit_payload(
prepass_payload,
bundle_dir=bundle_dir,
resolved_id=resolved,
dimension=dimension_id,
)
if not prepass_payload.excerpts:
# Measured: ``delivered == 0`` is reachable only when every concept failed to
# match (the producer REFUSES the other empty case, where concepts matched and the
# budget admitted none). So this is evidence of ABSENCE for this question at this
# ref, and saying it is better than two silent alternatives: an empty prompt, or
# falling through to the citation guard below, whose message names ``docs_dir`` —
# ``None`` on this path. SS 7.3's own posture: the skill stops and says so.
raise prepass.PrepassRefused(
f"the pre-pass delivered 0 of {prepass_payload.denominators.considered} "
f"concepts for the question {prepass_payload.question!r} at ref "
f"{prepass_payload.bundle.ref}; an empty cut is evidence that this knowledge "
"base does not answer that question, not something to run a debate over"
)
prepass_declaration = prepass.declaration_of(prepass_payload)
# ``rest_reachable=False`` is the FACT this arm establishes four lines below by
# emptying ``debate_tools`` — stated, never defaulted, because the other arm keeps
# them and a declaration that could not tell the two apart would describe neither.
prepass_declaration = prepass.declaration_of(prepass_payload, rest_reachable=False)
context = prepass.render_context(prepass_payload)
# Citations over the DELIVERED concepts alone: a stamp citing the whole corpus for a
# proposal that saw eight documents re-creates the undeclared claim this seam removes.
@ -2395,6 +2396,22 @@ def main(argv: list[str] | None = None) -> int:
"--bundle-dir; refused with --portfolio, --report, --proposals-from-mandate, "
"--dimension-config and --explore.",
)
parser.add_argument(
"--prepass-seed",
default=None,
metavar="FILE",
help="The OTHER arm of the same door (Q5=B): hand the EXPLORATION a declared cut as its "
"STARTING POINT and KEEP the four navigator tools. FILE is one contract-conformant OKF "
"consumption pre-pass payload (okf-consumption/1), admitted by exactly the checks "
"--prepass-payload applies — identity, sha256, the delivered text re-derived from the "
"mounted document, the verdict layer — before a single model call. The difference is what "
"happens next: the cut and its three denominators join the exploration's task message, "
"and the loop may still open anything else in the base (contract SS 2.2 permits what the "
"payload 'explicitly names as reachable'). The cut is printed and recorded in "
"{run_id}-exploration.json, which says rest_reachable so a reader can tell a seeded run "
"from a bounded one. REQUIRES --explore; refused with --prepass-payload (two opposite "
"arms of one decision), --portfolio, --report and --checkpoint-dir.",
)
parser.add_argument(
"--proposal-review",
action="store_true",
@ -2655,6 +2672,9 @@ def main(argv: list[str] | None = None) -> int:
# ABOVE every dispatch, so an omission here is a silent DROP — the operator would be
# told nothing and the declared cut would simply never happen.
"--prepass-payload": args.prepass_payload is not None,
# And the seeding arm, listed for the identical reason: report mode returns above the
# exploration dispatch too, so an omission here is a silent DROP and not a refusal.
"--prepass-seed": args.prepass_seed is not None,
# The three U12 flags, listed for exactly that reason: report mode returns before the
# resume dispatch, so an omission here is a silent drop, not a refusal.
"--checkpoint-dir": args.checkpoint_dir is not None,
@ -2744,6 +2764,10 @@ def main(argv: list[str] | None = None) -> int:
# operator who wrote --portfolio --prepass-payload has to hear which of the two is
# wrong, and an arm asserting on the shared token could not tell the two apart.
"--prepass-payload": args.prepass_payload,
# The seeding arm sits on the same side and by NAME for the same reason: it requires
# --explore, which this mode also refuses, so falling through would tell an operator
# who wrote --portfolio --prepass-seed to add a second flag --portfolio refuses too.
"--prepass-seed": args.prepass_seed,
# And the asynchronous half of the same door, on the same side of the partition and by
# NAME for the same reason.
"--checkpoint-dir": args.checkpoint_dir,
@ -2794,6 +2818,49 @@ def main(argv: list[str] | None = None) -> int:
)
return 1
# The SEEDING arm's three refusals, placed ABOVE the replacing arm's block on purpose: given
# both flags, the block below would answer with "--prepass-payload and --explore cannot be
# combined", which names neither of the two flags the operator actually put in conflict. At
# FUNCTION level, never nested under another flag's branch, for the F4 reason its neighbours
# are: under one, a bare combination falls through to a dispatch that drops the flag silently.
if not args.portfolio and args.prepass_seed is not None:
if args.prepass_payload is not None:
# TWO OPPOSITE ARMS OF ONE DECISION, and merging them is not defined: one WITHDRAWS
# the navigator tools because the cut replaces the base, the other KEEPS them because
# the cut is where to start. A run holding both would have to silently pick, and the
# picked one would be a policy nobody wrote down.
print(
"run refused: --prepass-payload and --prepass-seed are two opposite arms of one "
"decision (the first REPLACES the knowledge base with the cut and withdraws the "
"navigation tools; the second uses the cut as a STARTING POINT and keeps them). "
"Choose which one this run is",
file=sys.stderr,
)
return 1
if args.explore is None:
# The ``--explore-config`` case verbatim: a seed for a loop that never runs would be
# loaded, verified, paid for in I/O and then dropped.
print(
"run refused: --prepass-seed requires --explore (the cut seeds an EXPLORATION's "
"starting point; without one there is no loop to seed, and the debate's own arm "
"is --prepass-payload)",
file=sys.stderr,
)
return 1
if args.checkpoint_dir is not None:
# A parked leg writes {run_id}-exploration.json from its ``finally`` WITH the
# declaration; the resumed leg runs in a process that never saw the payload and
# OVERWRITES the same file with ``prepass: null``. A declaration that evaporates
# halfway is worse than one refused, and it would do so silently — so this is refused
# rather than left to erase itself.
print(
"run refused: --prepass-seed and --checkpoint-dir cannot be combined (the resumed "
"leg runs in a process that never saw the payload, and its own artefact would "
"overwrite the parked leg's declaration of the cut with nothing)",
file=sys.stderr,
)
return 1
# The pre-pass door's four remaining refusals, at FUNCTION level and never nested under
# another flag's branch: under one, a bare combination would fall straight through to a
# dispatch that drops the payload in silence (the F4 class).
@ -3214,6 +3281,16 @@ def main(argv: list[str] | None = None) -> int:
print(f"run refused: {exc}", file=sys.stderr)
return 1
# The seeding arm's payload, loaded here and by the SAME loader: one reader of one file
# format, never a second (kø-(p)). What differs between the two arms starts after admission.
prepass_seed: prepass.PrepassPayload | None = None
if args.prepass_seed is not None:
try:
prepass_seed = load_prepass_payload(args.prepass_seed)
except (FileNotFoundError, ValidationError, ValueError) as exc:
print(f"run refused: {exc}", file=sys.stderr)
return 1
# The egress config, loaded fail-fast alongside the commission. Degrading a broken one to "no
# external services" would make the announcement describe a run nobody configured, and a
# partially-parsed one could contact a subset nobody chose.
@ -3316,6 +3393,41 @@ def main(argv: list[str] | None = None) -> int:
else PlanReviewDecision.revise(answer.feedback),
)
# The seeding arm's admission, HOISTED above the try/finally below for the økt-57 reason the
# resume loads are hoisted: this is a refusal, and a refusal must not first overwrite
# {run_id}-exploration.json with an empty trace. It also has to happen before the first model
# call — at the exit code, a refusal after the spend looks exactly like one before it.
seed_declaration: prepass.PrepassDeclaration | None = None
seed_context = ""
if prepass_seed is not None:
assert args.bundle_dir is not None # guarded: --prepass-seed -> --explore -> --bundle-dir
try:
# This door OPENS a base, so it carries that gate itself rather than trusting the
# tool-side one to fire later (S7a-3: every opening door gets its own, and its own
# mutation). A base whose concepts name two corpora cannot be the one a cut is OF.
okf.assert_declared_ids_agree(okf.navigate_bundle(args.bundle_dir))
prepass.admit_payload(
prepass_seed,
bundle_dir=args.bundle_dir,
resolved_id=okf.reconcile_bundle_id(args.bundle_dir),
# NOT scoped, and that is measured rather than overlooked: the exploration builds
# ``navigator_tools(bundle_dirs)`` with no dimension at all, so scoping the seed
# would refuse text the very same loop can open with ``read_file`` a moment later.
# The DEBATE downstream stays scoped exactly as it is today.
dimension=None,
)
except (FileNotFoundError, ValidationError, ValueError) as exc:
print(f"run refused: {exc}", file=sys.stderr)
return 1
seed_declaration = prepass.declaration_of(prepass_seed, rest_reachable=True)
seed_context = prepass.render_seed(prepass_seed)
# Printed HERE, before the loop it seeds, rather than after: the announcement contract is
# that a commission is declared before the work it commissions, and a run whose budget is
# exhausted mid-exploration must still have said what it started from.
cut_notice = prepass_notice(seed_declaration)
assert cut_notice is not None # a declaration always renders; ``None`` means no cut
print(cut_notice)
if args.explore is not None or resumed is not None:
exploration_trace = ExplorationTrace()
exploration: ExplorationResult | None = None
@ -3356,6 +3468,9 @@ def main(argv: list[str] | None = None) -> int:
plan_reviewer=terminal_plan_reviewer() if args.plan_review else None,
# The U12 door. Mutually exclusive with the one above, refused at the top.
checkpoint_dir=args.checkpoint_dir,
# Q5=B. Empty unless --prepass-seed was given, and an empty string leaves
# the task message byte-identical to what every run built before today.
seed_context=seed_context,
)
)
except PlanReviewParked as parked_exc:
@ -3387,6 +3502,13 @@ def main(argv: list[str] | None = None) -> int:
stop=exploration.stop if exploration is not None else None,
completed=exploration is not None,
mandate=exploration.mandate if exploration is not None else None,
# From the SAME object the notice was rendered from, never a second load:
# stdout and the artefact must describe one cut, not two (kø-(p)).
prepass=(
prepass.declaration_payload(seed_declaration)
if seed_declaration is not None
else None
),
),
)
if budget_now is not None: