The one registry of where a model takes part in the Factory, and the pure selector that chooses, for a declared task, the first entry of its ordered list of owner-approved models and efforts that no recorded fact refuses. Every module in src/, and every planned one (including the nine of the proposed lifecycle design), declares here whether a model is part of its interface (none, optional or required) and why. It dispatches nothing.
Scope: Local model registry and deterministic selector. Build review records accepted snapshots and current verification gates. Priority lists and routes are recorded data; integration and priority-list receipts retain their exact snapshots. No model is qualified, so every task refuses.
- Source:
src/intelligence.ts - Tests:
test/intelligence.test.ts(15),test/intelligence-adversarial.test.ts(7),test/intelligence-lifecycle.test.ts(7),test/intelligence-lifecycle-adversarial.test.ts(8),test/intelligence-priority.test.ts(17) - Rendered views: the README's Intelligence table, generated by
renderIntelligenceTable()for the declarations that use or may use a model, its none line fromrenderNoneModulesLine(), the full declared-modules table fromrenderModuleIntelligenceTable(), and the planned declarations below, the handover steps' generated byrenderPlannedIntelligenceTable()and the lifecycle's byrenderLifecycleIntelligenceTable(); each task's pin, escalation, protocol, bounds and measure are read in the source, not restated here
Intelligence: none — This registry and selector: which model runs must be reproducible from the record, so it is frozen data and a pure function.
What it hides
- Where a model may take part.
MODULE_INTELLIGENCE(modules whose code exists, including the accepted local lifecycle, Service access, Owner policy, Branch health and Owner digest modules; with their exact src-relative file paths;product-gateholdsproduct-gate.tsanddelivery-records.ts, as its reference and build-review row do),PLANNED_INTELLIGENCE(handover steps 1–4;planningalso names the proposed lifecycle'splanning/opportunity-gate.ts) andLIFECYCLE_INTELLIGENCE(the lifecycle's other planned modules whose code has not landed, §2; increment 1 movedlifecycle-scheduleintoMODULE_INTELLIGENCEwithlifecycle-schedule.ts, and increment 2discovery-sources, namingdiscovery-sources.tsanddiscovery-text.ts). No accepted file changes to declare. - Which models and efforts each task may run, and in what order. Each task names an ordered list of owner-approved entries, each a provider, exact model, effort and route, dated: its
pin, then up to threethenentries (a task with one entry, as before, has onlypin, and may declare one escalation). The selector takes the first entry no recorded fact refuses and records each entry it passed over. Callers never choose a model. Routes are declared data naming their provider (TRANSPORTS_V1unless a registry declares its own). Every task of an accepted or step-planned module isfrontier:producer/proposepinsCLAUDE_MODEL, the one model the Claude transport binds, and the five other earlier tasks pin the most capable modelMODEL_TIERSlists. The lifecycle's five tasks pin the spec's defaults as hypotheses:claude-sonnet-5low (efficient) for draft packs and, under the research profile, search;claude-opus-5-5high for retirement cases; and, since the owner's decision of 1 October 2026, triage and the weekly synthesis name an OpenAI model throughcodex-clifirst (gpt-6-lunalow andgpt-6.1-solhigh, each proposed until that route establishes an effort), then their earlier Claude default. Its three Astra tasks areBLOCKED_TASKS:gpt-6-astraxhigh throughcodex-cliis only proposed, since no pin can name an effort that route does not establish. - What is known about each model.
MODEL_TIERS: dated facts per model and route (accepted efforts, whether the route can count provider requests, qualification, a reference note), the routes it declares, and the candidate (model, effort) pairs of each tier. Claude models are listed onclaude-cliand, for Sonnet 5 only, on the research routeclaude-cli-research; OpenAI's (gpt-6-astra,gpt-6-luna,gpt-6.1-sol) oncodex-cli, with no established effort. Every fact on a Claude route isunavailablefor the Factory's model roles by the owner's decision of 1 October 2026, which the Factory records as that fact's qualification.
Public interface
| Name | What |
|---|---|
INTELLIGENCE_PROTOCOL | "sf-intelligence/1", inside every policy digest |
EFFORTS, PHASES, MAX_WHY_LENGTH (160), MAX_TEXT_LENGTH (400), MAX_REASON_LENGTH (500); types Provider, Transport, Allowance | frozen vocabularies, prose bounds and the refusal-reason bound (PRODUCER_LIMITS.textLength). Provider (/^[a-z][a-z0-9-]{0,31}$/, never predetermined) and Transport (a route id, /^[a-z][a-z0-9-]{0,47}$/) are strings: whatever a declared route names. Allowances: slice, product, improvement-window or discovery-window, a Factory admission limit for discovery occurrences, never a reservation of provider capacity (lifecycle §5) |
TransportDeclaration, ModelTiers.transports, TRANSPORTS_V1, INTELLIGENCE_LIMITS | a route is {id, provider, tools, note}; a registry declares 1 to 16, or none and is read with TRANSPORTS_V1 (deep-frozen, never changes): claude-cli (claude), claude-cli-research (claude, tools: "research") and codex-cli (openai). REGISTRY declares those three itself. A fact's provider is its route's; a route with tools: "research" carries a tool, so only a drafter may use it. openai-responses is no route: the accepted Responses adapter (src/openai-producer.ts) stays accepted, with no registry route (lifecycle decision 3). INTELLIGENCE_LIMITS is { entries: 4, transports: 16 }: more is refused at load, never cut. The Producers module's ProviderId and the schedule's Account stay closed, so a caller-declared provider can be selected but not qualified or admitted |
TRANSPORT_CEILINGS | PRODUCER_LIMITS restated: enforced inputBytes 1 310 720, outputBytes 1 048 576, deadlineMs 600 000; requested maxOutputTokens 128 000, maxCostCents 2 000 |
MODULE_INTELLIGENCE, PLANNED_INTELLIGENCE, LIFECYCLE_INTELLIGENCE, BLOCKED_TASKS, MODEL_TIERS, REGISTRY | the deep-frozen registry; REGISTRY holds all three declaration lists and the blocked tasks. A BlockedTask carries a task's descriptive fields and a proposed pin, with no bounds, protocol, basis or policy, and becomes a task by a reviewed edit once its route lists the proposed effort |
taskPolicyDigest(taskId, registry?) | "sha256:" over the canonical form of the named fields the selector enforces (id, role, phase, caller, protocol, tier with an efficient task's basis, pin, escalation, any then entries with their proposed markers, bounds with the estimate's figure, allowance, and its listed models' provider, model, route, efforts, request count and qualification state with its commission reference). then and proposed: true enter only where used, so a one-entry task encodes as it always did. Prose (notes, qualification reasons, route notes, the estimate's basis) and checks are excluded. TypeError for a malformed or unknown task id, a blocked task, or an invalid registry |
chooseModel(request, registry?) | {choice}, {refused, reason} or, when a list has no eligible entry, {refused: "no-eligible-entry", reason, skipped}; TypeError for a malformed request or an invalid registry. A verifier's choice records the producer identity it was checked against, and every choice carries entry (its 1-based place in the list) and skipped (each entry ahead of it a recorded fact refused, with its code and reason). requested has two forms, below |
renderIntelligenceTable(), renderNoneModulesLine(), renderModuleIntelligenceTable(), renderPlannedIntelligenceTable(), renderLifecycleIntelligenceTable(), renderIntelligenceLine(module) | the README table and none line, the full declared-modules table, the two planned tables below and a module page's one line |
A task's bounds keep three things apart: enforced (host-enforced before contact), requested (provider-side ceilings a transport may only estimate) and estimate (a planning figure for the gate's reservation, never a limit; present exactly when the protocol is specified).
ModelRequest.requested has two forms. The choose form (at freeze or admission) carries only policy: the selector walks the task's list and returns the chosen entry with its pass-overs, which the caller records with the frozen work and the admission. The verify form (at dispatch and resume) names one entry in full (provider, model, effort, transport, commission) and policy, as every request did before: it is accepted only if that entry is the first eligible one now. The five naming fields come all together or not at all (a partial group is a TypeError, and a compile error, since the choose form types them never), and escalation needs the verify form (an escalation is requested exactly). The module cannot tell freeze from dispatch, so the rule is the consumer's: record the choose form's result with the frozen work and the admission; dispatch and resume use the verify form naming the recorded entry, so a resumed occurrence runs that entry or refuses and never walks on. A consumer that walks again at dispatch has not substituted, but has not frozen either.
chooseModel checks in this order: request shape (TypeError, names checked by grammar and never by membership: a well-formed provider or route the registry does not declare matches no entry and is refused as a value), the registry when one is given (TypeError), unknown-task (blocked when the id is a blocked task's), producer-unknown (a verifier without the Candidate's producer, or naming a model MODEL_TIERS does not list for that provider; a non-verifier carrying one is a TypeError), not-specified, not-measured, escalation-undeclared, escalation-mismatch, then the list. For a one-entry task in the verify form that is exactly the earlier order: pin-mismatch, not-qualified, policy-mismatch, commission-mismatch, implicit-retries, not-independent. For a list, the choose form checks policy-mismatch first (a list's order and facts are policy); the verify form first requires the named entry to be in the list (pin-mismatch otherwise) and then checks policy-mismatch; then the walk: each entry in order is passed over with the first of proposed, not-qualified (a fact unqualified or unavailable), implicit-retries (an unknown request count is never zero retries) or not-independent (a verifier's entry on the producing model), and the first entry none of them refuses is chosen. The verify form of a list names an entry in it (pin-mismatch otherwise), refuses a named entry that an earlier eligible one outranks with pin-mismatch, and then refuses the named entry with its own code (proposed, not-qualified, commission-mismatch, implicit-retries, not-independent). When nothing is eligible: a one-entry task refuses with its entry's code; a list refuses no-eligible-entry with every entry's pass-over.
Allowance and account state are deliberately not pass-over reasons: every allowance is task-level and provider-neutral, so it cannot tell one entry from another; the usage window, sign-in and overage are recorded at or after contact and checked by the schedule's admission, so walking past an entry because its account is limited would be the provider switch the lifecycle forbids (F3); and those ledgers are durable state the selector must not read. Selection stays pure and the admission follows the choice.
Invariants and guarantees
- Every module file under
src/, at any depth (.ts,.mts,.cts,.tsx,.js,.mjs,.cjs,.jsx,.json,.node,.wasm), belongs to exactly one accepted declaration, so a new source cannot land undeclared; a planned source that exists fails the test until its declaration moves intoMODULE_INTELLIGENCE. The guarded fixture sources staynone. - The registry is checked when the module loads, and a registry given in its place is checked on every call: routes (1 to 16 when declared, ids and providers in their grammars, unique,
predeterminedrefused,toolsnoneorresearch, a one-line note), unique module slugs and task IDs (<module>/<name>), calendar dates, one-line bounded prose, src-relative sources declared once and sorted, tasks exactly whenoptionalorrequired, each model on a declared route of its provider (so nothing onopenai-responses, which no registry declares), every entry of a task's list (pin, thenthen: one to three entries, never empty or callable) on a declared route of its provider with a listed model and no (model, route) pair twice, every established entry and escalation at an accepted effort and a candidate of the task's tier, a proposed entry only on a task withthen, at an effort ofEFFORTS, and only on a listed, unqualified model whose route lists no such effort, at least one established entry per task, no escalation beside a list, only a drafter on a route withtools: "research"(it has a tool), one of the four allowances,checksand its independence rules (invariant 9), each blocked task's id unique among task IDs under a module that declares intelligence and its proposed model listed and unqualified on a route that lists no such effort (otherwise it must be a task), bounds withinTRANSPORT_CEILINGS, and a complete commission reference for any qualified model. A bad edit throws at import. - A task's caller is a declared module that itself declares intelligence, never one declared
none. The rule never asks whether the caller has landed, so a planned declaration that moves intoMODULE_INTELLIGENCEstays valid. The exchange runs through a Producers-module transport the caller is handed, never imports (step-1 spec §7 D1). chooseModelis pure and deterministic. It reads each request field once, from own data properties (an accessor is aTypeError), into a validated copy it alone uses; fields it does not name are never read or returned; its results are fresh and frozen, and it never freezes an object its caller passed in. The module imports onlynode:cryptoand./canonical-json.ts, reads no clock, randomness, environment or file, names no identifiermoduleorrequire(test/delivery-boundaries.test.tsrefuses both insrc/, so themodulekey is written as a string), and no other module file imports it.- It never substitutes. A task's entries (its
pin, then anythenentries) are the owner-approved set, in order, under the task's policy digest. The selector takes the first entry no recorded fact refuses and records each entry it passed over, with its code. It never chooses outside the list, reorders it, lowers or raises an effort (the one declared escalation aside) or retries. A request naming any entry other than the first eligible one is refused, and an admitted dispatch never moves to another entry: dispatch and resume restate the recorded entry. Anefficienttask whose basis is notmeasuredrefusesnot-measuredbefore any walk, whatever its entries' qualification. - A frozen request carries the task's policy digest and the commission digest it pinned; both must equal the registry's now, so a reviewed edit never silently changes what already-frozen work runs, and a wording edit never invalidates it.
- A model is
qualifiedonly with a committeddocs/<provider>-producer-commission.json. The test checks it withparseProducerCommissionandcommissionDigestfromsrc/producer.ts; binds it as the transport would (provider, the transport's one model, its policy digest, and for Claude exactly the managed-policy sources the transport observes on this host, in order); requires a date no later thanMODEL_TIERS.asOf; and requires the commission and its receipt to be regular files inside the repository, reached through no symbolic link and committed at HEAD with the recorded bytes and digests. - A route whose provider request count is unknown (every route today) cannot show "no implicit retry", so its entries are passed over
implicit-retriesuntil a commission establishes one request per invocation. - A verifier needs the Candidate's producer identity from its produce admission (
produce:<48 lowercase hex>, exactly the Product gate'sproductionKeyOfkey), naming a modelMODEL_TIERSlists for that provider, and never runs on the producing model (an entry on it is passed overnot-independent); an authored identity names no provider or model. Independence is also checked at load: the optionalchecksnames the task whose output a task checks, which must be a declared, unblocked task other than the checker; a verifier checks a producer; a producer declares none; and no model appears in both lists (pin,thenand escalation of an ordinary task, or a blocked task's one proposed pin; proposed entries count). Which kind a declaration is follows from the collection it sits in, never from a key it carries, and an ordinary task that carries aproposedkey is refused after the model rule, so a blocked declaration spread into a task cannot hide its real list. It is by model string only, so the same model on another route or provider still collides, and two models of one provider may share errors: since the owner's decision of 1 October 2026 every discovery drafter and checker is an OpenAI model, so the earlier reason of keeping them on different providers no longer holds for the audit and the challenge, and the audit's agreement measure (lifecycle L7) is the only evidence that would show it.checksdrives these load rules only, so it is outside the policy digest. A Factory limit, held by a test rather than a load error: inREGISTRY,checksappears only on a verifier and on blocked tasks. An unblocked drafter that checks another task (the three Astra tasks after L7) gets this static disjointness, but nothing records the checked dispatch's actual model, which a later registry edit could move into the checker's list; L7 must add that record, or accept the gap explicitly, when it unblocks them. - Escalation is the one declared step: the pinned model at a strictly higher effort, requested exactly, from the base pin only, naming the failed dispatch (32 hex); it cannot compound.
- It agrees with the accepted transports (tested):
TRANSPORT_CEILINGSequalsPRODUCER_LIMITSandMAX_REASON_LENGTHitstextLength; eachclaude-clifact's request-count capability is the Claude transport's, andCLAUDE_MODELlists exactly its efforts; the producer pinsCLAUDE_MODEL. No model is listed on the accepted OpenAI Responses transport, which no registry route declares.codex-cliandclaude-cli-researchhave no Producers transport, so their facts have anunknownrequest count and no qualification, and the test's commission check refuses any commission for them; the threecodex-clifacts (gpt-6-astra,gpt-6-luna,gpt-6.1-sol) list no effort, the research fact the Claude CLI's. Every fact on a Claude route isunavailable, and its reason starts with the owner's decision of 1 October 2026 (tested), so a later Claude fact cannot silently read "awaiting a commission". - The walk is deterministic and reproducible. Every pass-over input except the producer identity is inside the policy digest (the order, each entry, the
proposedmarker and each entry's fact: efforts, request count, qualification state), so the same request under the same policy digest reproduces the same chosen entry and the same pass-over codes; only reason prose (qualification reasons,asOf) can differ. A resumed occurrence with the same identity gets the same answer. Entries are proposed (proposed: true) while their route establishes no such effort; a proposed entry is never selectable, and every task keeps an established entry, as a task with none is aBlockedTask. The tests walk every combination of a four-entry drafter list and a verifier list and never see anything but the first eligible entry in declared order orno-eligible-entry. - The README section is at most 25 lines: a heading, one paragraph,
renderIntelligenceTable()(one row peroptionalorrequireddeclaration) andrenderNoneModulesLine();renderModuleIntelligenceTable(),renderPlannedIntelligenceTable()andrenderLifecycleIntelligenceTable()each sit exactly once below, so every declaration renders in exactly one of those three tables. Each accepted module's page here carriesrenderIntelligenceLine()exactly once, and no other line of any page here mentions one.
Failure semantics
- A malformed request or registry throws
TypeError; every other outcome is a value. A refusal's reason is one line of at most 500 characters (longer registry prose is cut with an ellipsis), built only from grammar-checked identifiers and bounded registry text; the caller records it. Nothing runs for a refusal. - Today every task refuses: the ten extensions (five earlier, five from the lifecycle) with
not-specified, andproducer/proposewithnot-qualified(its reason now readsunavailable: owner decision, 1 October 2026: …, since the Claude CLI is unavailable for the Factory's model roles); each blocked task refusesblocked, always. With every protocol specified, the threeefficienttasks would refusenot-measured. Once triage is measured and the weekly synthesis (frontier, so with no measurement gate) has its protocol specified, each, whosepinis a proposed OpenAI entry, refusesproposedin the verify form andno-eligible-entry(codesproposed,not-qualified) in the choose form; every other task refusesnot-qualified, because no model is qualified (tested). A one-entry task is refused with its own entry's code and noskippedlist.
Trust scope
Established, by test: coverage of src/, the registry check, routes as data and their load rules, entry, policy and commission binding, the ordered walk (every combination of four entries, both forms, never beyond the list), reproducibility, verifier placement and independence against the identity supplied and checks at load, the escalation shape, the efficient tier's measurement gate, the blocked tasks' checks and refusal, purity, single reads and freezing, bounded reasons, agreement with the producer transports, the owner's decision recorded on every Claude fact, and README and page sync.
Not established:
- Nothing calls
chooseModelyet, and the transports do not consult the registry; today the Claude transport's ownCLAUDE_MODELcheck is what refuses another model. - Admission of a task with
then. The accepted schedule maps a task to its account statically (proposedCommissionnamesclaudefor triage and the weekly synthesis) and records no model, andadmitCalltakes no model, provider or policy, so a host composing both entry points would admit a chosen Codex entry against the Claude account's records. A task withthenis therefore not admissible through the accepted schedule untiladmitCallrecords the chosen entry (provider, model, effort, route) with the task's policy digest and checks the account of that entry's provider (follow-up FU-1 in the receipt). Nothing runs today, so this does not block this change. - Arbitrary providers end to end. A caller-declared provider can be selected through this contract, but the Producers contract (
ProviderId, closed toclaudeandopenai) cannot qualify it and the schedule (Account, closed toclaudeandchatgpt) cannot admit it; each needs its own reviewed change. - The proposed OpenAI entries. No
codex-cliProducers transport, audit, commission or request count exists (lifecycle L7); thatcodex execruns headless with--output-schemaon this sign-in forgpt-6-luna,gpt-6.1-solorgpt-6-astrais unproven; how the Factory would set an effort oncodex-cliis open (the 0.159.1 source has no dedicated option, only themodel_reasoning_effortconfiguration, which T2's--ignore-user-configdesign drops); whether Codex refuses, truncates or compacts an over-long input is unknown against a 272,000-token catalogue context window and this registry's input bounds; and the quality, cost and efforts of the proposed models are hypotheses (each effort mirrors the former Claude default). A catalogue listing is not entitlement. - That no module outside the Producers module imports a transport is step-1 spec §7 D1, asserted by
test/delivery-boundaries.test.ts, not by this module's tests. - Review checks stay reserved in the accepted code (
judgeRepositoryjudges them inconclusive and the Product gate refuses review dispatches), matchingrepository-assurance/review's extension status. - The producer identity is trusted as supplied; its authenticity comes from the produce admission the caller reads (step 1).
- Single-use escalation admission, reservation and allowances belong to the Product gate and are untested here.
- Model facts are a dated copy of the Claude API reference (cached 2026-06-24), not live; every pin is an unmeasured hypothesis.
- No model is qualified, so the committed-commission check has run only against a temporary repository in its test. What the lifecycle declarations leave unestablished is listed under Lifecycle increment 0.
Composition
- Depends on:
node:cryptoand./canonical-json.tsonly. It must not import a producer: outside the Producers module nosrc/file may reach one. - Consumers: none in
src/.test/intelligence.test.tsreadssrc/producer.ts,src/claude-producer.tsandsrc/openai-producer.tsto check agreement. - Recording a choice. The choose form's result belongs with the frozen work and the admission (
planSlicefor a Slice;admitCallfor a lifecycle call once FU-1 lands), and dispatch and resume use the verify form naming the recorded entry (see the two forms above). - Planned (step 1): before admitting a produce Run, the composition loads the commission, computes its digest and calls
chooseModelwith the frozen Slice's policy digest; a refusal becomes outcomeunavailableand nothing is dispatched.planSlicerecordstaskPolicyDigestbeside the pins it freezes. Repository review derives the producer identity from the produce admission. The lifecycle's plan is under Lifecycle increment 0.
Changing it safely
- Run
node --test test/intelligence*.test.tsandnpm run typecheck;npm run checkruns everything. - A change to a pin, escalation, bounds or estimate figure, allowance, protocol, caller, tier, an
efficienttask's basis, role, phase or a pinned model's enforced facts (including qualification) changestaskPolicyDigest, so frozen requests refuse withpolicy-mismatchby design. Date it (since,asOf). - Adding a provider: declare a route naming it (
ModelTiers.transports) and its facts, then list entries on it. That is policy data only. The Producers module'sProviderId, an audit, a commission, the test's binding table and an admission account (the schedule'sAccount) are each their own reviewed change; nothing here qualifies or admits a provider. - Adding or reordering an entry, or editing any entry or its fact, changes the task's policy digest, so work frozen under the task refuses
policy-mismatcheven when its own entry is unchanged. Keep a list to at most four entries; a proposed entry becomes established only by a reviewed edit once its route's fact lists the effort. - A drafter that checks another task needs a record of the checked dispatch's actual model: when L7 unblocks the Astra tasks it must add that record, or accept the gap explicitly (invariant 9).
- A new
src/file lands with its declaration. A planned module moves intoMODULE_INTELLIGENCEwith the files that actually land; no other rule depends on whether a module has landed. - Qualifying a model is a person's act: commit the commission file and its receipt, then record
{path, sha256 (bare hex of its bytes), digest (commissionDigest)}. Acodex-cliorclaude-cli-researchmodel can qualify only after its Producers transport, audit and commission exist and the test's binding table names that transport. - An
efficienttask, a cascade or an escalation to another model needs a measured comparison with the pinned model at lower effort on the same tasks, judged by cost per completed task, and a reviewed change to the escalation rule (a priority list is not a cascade: its entries are chosen before contact, never after a failed output); until anefficienttask's basis ismeasured,chooseModelrefuses itnot-measured. - When a
why, decision, task or pinned effort changes, regenerate the README table, the lifecycle table below and the page lines, rebuild the docs site, and get a fresh independent review. The README section stays within 25 lines: its prose is one paragraph, and further planned declarations render outside it.
The produce admission key (R13)
PRODUCE_ADMISSION (src/intelligence.ts) accepts exactly the Product gate's key: produce: followed by 48 lowercase hex digits, matching productionKeyOf (src/product-gate.ts). test/intelligence-adversarial.test.ts tests the corrected grammar directly against productionKeyOf, and checks that the selector refuses the old shape, uppercase hex, and 47 or 49 hex digits.
Declared modules
renderModuleIntelligenceTable() renders every MODULE_INTELLIGENCE declaration below, whatever its decision. The README shows only the declarations that use or may use a model (optional or required, from renderIntelligenceTable()) and names the none ones in one line (renderNoneModulesLine()), so its section stays within 25 lines as declarations are added. Every task here is frontier. It saves cost by lowering its effort first, because effort on one model is the simplest lever to tune and keeps one prompt cache.
| Module | Intelligence | Why |
|---|---|---|
| command-journal | none | Atomic commands, receipts and events; correctness is a transaction property, and a model cannot make a write more atomic or a replay more exact. |
| evidence-assurance | none | A Verdict is a pure fold over trusted collector observations; a model's opinion is not evidence, only a producer 'passed' flag by another name. |
| execution | none | Run and Attempt ownership, Budget and cancellation are invariants checked on every read and write; there is no judgement to delegate. |
| local-fixture-worker | none | Fixed fixtures use declared source or compiled pins; model choices must not relax ownership or manufacture Evidence. |
| attempt-fence | none | Ownership proven by kernel locks and a private directory bound to the fence; there is nothing to reason about and nothing a model could prove. |
| guarded-verification | none | Picks the next step from durable facts under fixed rules, so any controller reproduces the same recovery; a model would make it unrepeatable. |
| confined-executor | none | A kernel sandbox boundary that runs one bounded process and reports what the host saw; any decision a model made here would weaken confinement. |
| repository | none | Seals and integrates exact bytes: every identity is recomputed and the target ref moves once per intent; nothing is inferred. |
| operational-signals | none | Authenticated bounded intake, immutable identities and atomic checkpoints are exact rules; model output supplies neither authority nor coverage. |
| portfolio | none | A registry and replay of sourced facts, including model usage receipts, whose whole value is that nothing in it is inferred. |
| dashboard | none | Presents decided facts and counts (apps/dashboard renders them); a generated explanation would be optimistic copy over evidence. |
| project-guidance | optional — project-guidance/summarise via frontier/low | Stores the owner's values with provenance and stays transport-free; a planned caller may draft a document summary the owner reviews and the validator bounds. |
| attention | none | Items exist exactly while sourced facts say so; inferred urgency or drafted advice would be a second, unsourced queue. |
| producer | required — producer/propose via frontier/high | The one place a model's output enters the factory: one bounded, tool-free edit proposal that stays data until the repository seals it. |
| repository-assurance | optional — repository-assurance/review via frontier/medium; repository-assurance/fresh-scenario via frontier/high | A Verdict rests on process checks; a review may withhold Verified with findings, and a fresh scenario may be drafted for a person to pin; neither grants it. |
| product-gate | none | Authority, admission, integration, create-once delivery records and Assessments are pure decisions over durable facts; a model would be a second authority. |
| repository-collector | none | Runs frozen checks under pinned source or compiled resources; drift blocks dispatch and attribution. It observes and never judges. |
| intelligence | none | This registry and selector: which model runs must be reproducible from the record, so it is frozen data and a pure function. |
| lifecycle-schedule | none | Occurrence identity, the capacity ledger and deferral are rules over the clock and counters; a model would make scheduled runs unrepeatable. |
| factory-workflow | none | Stateless composition invokes existing native stages with original requests; no model grants authority or settles unknown effects. |
| delivery | none | Composition moves authored bytes and re-derives stored Evidence under the Product gate; no model makes these decisions. |
| verification-workflow | none | External seals use Delivery’s gate and collector; genuine Evidence re-derives original proof. No model grants authority. |
| implementation-workflow | none | Original worker requests are data; deterministic admission, host Evidence and seal validation decide authority. This module invokes no model transport. |
| knowledge | none | Reviewed lesson pins, source permissions and deterministic advice retain original evidence; no model grants authority or chooses a new owner. |
| checkout-git | none | A bounded fixed Git command reads committed bytes; interpretation and generation are absent. |
| calendar | none | Shared neutral Gregorian arithmetic and fixed schedule identities are pure rules over caller data. |
| discovery-sources | none | Fetching commissioned Sources, hashing, de-duplication and quote checks are exact byte operations; a model could only blur what must match. |
| service-access | none | Discovery, references, readiness and runbooks are exact rules over names and dates; a model would add an injection path near secrets, not accuracy. |
| owner-policy | none | Counts asks, minutes and repeats exactly and records a rule only in the owner's own words; a model would infer rules the owner never made. |
| branch-health | none | Health, episodes and signatures are fixed rules over what GitHub reports; a model would guess at causes where only observed signatures are allowed. |
| owner-digest | none | Every line is rendered from recorded facts and cites them; a model would put unsourced words into what the owner reads and trusts. |
| temporal-planning | none | Dates and constraints are a deterministic evaluation of caller-owned evidence, precision and policy; no model can establish an occurrence or grant authority. |
| capacity-planning | none | Capacity is bounded arithmetic over attributed native observations and explicit assumptions; a model cannot reserve quota or promise completion. |
| material-timing | none | Material timing checks pinned civil rules, attributed readiness and approved constraints; a model cannot establish availability or authorise publication. |
| provider-events | none | Source pins, current permission values and bounded notification fields are exact rules; a model would add authority and leak source data. |
| provider-subscriptions | none | Subscriptions enforce scoped private lifecycle, current caller authority and bounded verification; a model cannot verify keys or grant callback contact. |
| proposal-ownership | none | Immutable proposal generations and first-offer ownership follow an explicit current authority fence; no model supplies permission or settles an unknown effect. |
| guidance-acceptance | none | Original Guidance commands require current permission and exact history; a model cannot grant authority, infer acceptance or release ownership. |
| provider-events-rpc | none | Exact method routing, bounded JSON and fixed host error projection need no model judgement or new authority. |
| provider-guidance-tools | none | Two bounded tools retain original Guidance identity and current receiver authority; no model decides permission, acceptance or replacement. |
| milestone-objectives | none | Milestone intent and reviewed plans follow current caller authority and original Journal history; attributed dates never grant work or promise delivery. |
| provider-event-delivery | none | Current caller authority and retained attempts bound one notification; a model cannot grant contact or infer a domain effect. |
| provider-diagnostics | none | Optional retained-fact attribution is deterministic; a model cannot infer a provider cause, change an outcome or authorise a retry. |
| research-jobs | none | One original public collection remains attributed and untriaged; no model grants source access, renews an allowance or admits implementation. |
| research-semantics | none | Caller ports propose bounded semantics; native quote support and current authority checks decide retention. This module has no model transport. |
| milestone-research | none | Recorded draft parsing preserves native provenance and prepares existing commands; only a separately qualified current independent review can admit a plan. |
| milestone-work-brief | none | Selected-generation brief preparation preserves captured native facts; it cannot admit work, infer current authority or turn capacity counts into dates. |
| prevention-register | none | Guardrail facts are fixed template rules over caller-supplied reads and dated owner exemptions; a model would guess presence where only read evidence counts. |
| marketing-workflow | none | Claims render from typed facts under fixed rules; the job's optional drafter is a caller port whose templates those rules check; no model sets a fact. |
| work-items | none | Claims and lane findings follow fixed rules over declared scope keys and read Git facts; a model would guess at overlap that recorded evidence must decide. |
Lifecycle increment 0
Increment 0 of the proposed lifecycle (§9, row 0), on branch factory/lifecycle from e62abe6. Implemented by Opus 5.5; an independent adversarial pass then found eight defects (its tests are test/intelligence-lifecycle-adversarial.test.ts; report, logs and dispositions under <local evidence archive>), all fixed here. Independent Astra review: <local evidence archive>, where each report applies only to its recorded snapshot; round 1 failed on one finding (the Astra tasks were left out rather than declared blocked), fixed here. Receipt: intelligence-lifecycle-receipt.json.
- Planned declarations. The nine modules of spec §2 with their decision and reason:
planninginPLANNED_INTELLIGENCE, now namingplanning/opportunity-gate.ts, and the other eight inLIFECYCLE_INTELLIGENCE.lifecycle-schedule,discovery-sources,owner-decisionsandoutcome-validationarenone;signal-intake,opportunity-synthesis,growthandcapability-retirementareoptional, with five tasks (triage, search, synthesis, the draft pack and the retirement case) and three blocked tasks (below). Each task is a protocol extension, a plan-phase drafter its own module requests, with no escalation and basishypothesis. - The three Astra tasks are declared blocked. Spec §4 also names
signal-intake/audit,planning/challenge-opportunityandgrowth/review-pack, atgpt-6-astraxhigh (decision 4's default).codex exechas no dedicated effort option: today's hand-run Astra reviews pass a generic configuration override (-c model_reasoning_effort=…), which the designed T2 argv (spec §8, with--ignore-user-config) does not include and no audit covers. So no effort is established oncodex-cli: its fact lists none, asclaude-haiku-4-5's does, and a pin must name an effort its fact lists (invariant 2). The three are thereforeBLOCKED_TASKS, with every descriptive field, their caller and allowance, and Astra at xhigh as aproposedpin;chooseModelrefuses themblocked, and they have no bounds, protocol or policy. They become tasks with that route's audit and transport (increment 7), which must establish how the effort is set; until thengpt-6-astrais no tier candidate. - Efficient tasks wait for their own measurement. Triage, search and the draft pack pin
claude-sonnet-5low (decision 1's default) as hypotheses, andchooseModelrefuses eachnot-measureduntil its own comparison with Opus 5.5 low on its own corpus (spec L3) makes its basismeasured; qualifying the model for one task never makes another selectable. Anefficienttask's basis is part of its policy digest; afrontiertask's gates nothing and is not, so the six earlier tasks' digests are byte-identical before and after (recorded in the receipt). - The research profile. Search is pinned to
claude-cli-research, the Claude CLI under the separate research profile (spec §8 T1; the spec'sClaudeResearchProfile), on which only Sonnet 5 is listed,unavailable, with the CLI's--effortvalues and anunknownrequest count. Only a drafter may pin it, and qualifying the tool-free route never qualifies it. - Per-call input bounds. Spec §5's are enforced, not only stated: a triage call at most 90 000 bytes (20 Captures of at most 4 KiB) and a synthesis call at most 120 000 (its KB read as 1 000 bytes); the other lifecycle tasks stay at the transport ceilings until their protocols are specified.
discovery-window. A fourth allowance, debited by exactly the discovery occurrences' tasks: triage, search and synthesis, and the blocked audit and challenge.codex-cli, declared unqualified. Decision 3's default: OpenAI is re-pointed fromopenai-responsestocodex-cli, andgpt-6-astrais listed only there,unqualified, with no established effort and anunknownrequest count. The accepted OpenAI Responses adapter (src/openai-producer.ts) is unchanged and stays accepted, but no model is listed on its transport, so nothing pins it. This changes which registries load, so it is a behaviour change of this module.- The README stays within its accepted 25 lines. It keeps the accepted and step-planned rows; the lifecycle's other planned declarations render in the table below, and a test holds that every declaration renders in exactly one of the two. (Since the merge with
main, the step-planned rows render here too.) - Choices the spec leaves open, taken here as proposals. Every lifecycle task is phase
plan, since step 1's phases have none after integration and the growth and retirement drafts serve an owner or Planning decision; the audit, challenge and pack review are drafters, since a verifier presumes a Candidate (spec §6 says so of the challenge); the draft pack and its review debit the released Slice's allowance and the retirement case the improvement window, as weekly defrag does; onlyplanningnames a file (planning/opportunity-gate.ts, spec §2). - Not established. Increment 0 built no lifecycle module (increment 1 builds the schedule: below); every pin, allowance and role is the spec's default for an owner decision that is still open (lifecycle §11, decisions 1–4 and 6): a proposal, not a signed commission.
codex-cliis only declared: no Producers transport, pinned audit (spec increment 7) or commission exists, and neither thatcodex exec -m gpt-6-astra --output-schemaruns headless on the ChatGPT sign-in (A4) nor how that route would set an effort is established. Sonnet 5 is not bound by the Claude transport (CLAUDE_MODELonly; spec increment 6), and eachefficientpin is an unmeasured hypothesis. The research profile has no argv, audit or qualification (spec increment 10).discovery-windowis a name the registry accepts; the registry keeps no ledger, ceiling or debit (the schedule's ledger lands in increment 1, below). - Planned. Each lifecycle module lands in its own increment, moving its declaration into
MODULE_INTELLIGENCEwith the files that land;codex-cligets a Producers transport, audit and commission in increment 7, when the three blocked Astra tasks become tasks; Sonnet 5 a reviewed Claude transport extension and qualification in increment 6; the research profile its own audit and qualification in increment 10.
Lifecycle increment 1
Increment 1 of the proposed lifecycle (§9, row 1), on branch factory/lifecycle-schedule, lands lifecycle-schedule. Its declaration moves, unchanged (none, the same reason), from LIFECYCLE_INTELLIGENCE into MODULE_INTELLIGENCE with its one file, lifecycle-schedule.ts, as the planned rule says; it now renders in the README table and no longer below. No task, pin, allowance or selector rule changes, so no task's policy digest changes. The lifecycle test holds that a landed module names exactly the files that landed and that the other seven have not landed. It passed independent review with the module (Astra round 4 PASS, <local evidence archive>).
Planned declarations
Planned declarations render here rather than in the README, so that its section stays within the accepted 25 lines (merge with main). The handover steps' planned modules (PLANNED_INTELLIGENCE), as renderPlannedIntelligenceTable() renders them:
| Module | Intelligence | Why |
|---|---|---|
| brief (planned) | optional — brief/explain-trade-offs via frontier/low | Pins and application rules are copied verbatim from the guidance snapshot; a trade-off explanation may be drafted as a labelled proposal the owner accepts. |
| planning (planned) | optional — planning/propose-improvement via frontier/medium; planning/challenge-opportunity blocked, proposed frontier/xhigh | Health, Assessments and admission are rules over independent facts; a model may draft improvement proposals, and challenge an Opportunity only to lower it. |
The separate E36 Temporal Planning draft proposes deterministic date, capacity and trigger decisions with no model collaborator. It has no runtime declaration or qualified task yet. Research and Marketing may supply or consume its typed facts and proposals through optional adapters; their existing model and authority rules remain.
The separate E37/E38 operational draft keeps ingestion, detector policy, episode transitions and dispatch rules deterministic. A supplied investigator may propose hypotheses under its own qualified contract; model output cannot authenticate telemetry, verify its own repair or grant release/source-writeback authority. No new model task is declared or qualified by this design.
Lifecycle declarations
The proposed lifecycle's planned modules other than planning (above) and those already built (whose rows are in the README table), as renderLifecycleIntelligenceTable() renders them:
| Module | Intelligence | Why |
|---|---|---|
| signal-intake (planned) | optional — signal-intake/triage via openai efficient/low (proposed) then claude efficient/low; signal-intake/search via efficient/low; signal-intake/audit blocked, proposed frontier/xhigh | Triage and the weekly search are bulk classification an efficient model may do; code verifies every quote span, and an Astra audit is to measure the tier. |
| opportunity-synthesis (planned) | optional — opportunity-synthesis/propose via openai frontier/high (proposed) then claude frontier/high | Composing falsifiable needs from crossed Clusters changes a decision: a frontier model drafts at most five a week, only when one crosses, and rules decide. |
| owner-decisions (planned) | none | The weekly bundle, typed answers and single-use Action grants render from verified records; a model would put an unsourced voice between owner and facts. |
| growth (planned) | optional — growth/draft-pack via efficient/low; growth/review-pack blocked, proposed frontier/xhigh | Prose is where a model helps: an efficient model drafts release copy, code renders every claim from typed facts, and Astra is to review the wording. |
| outcome-validation (planned) | none | Measurement contracts, A/B designs and read-outs are statistics over frozen contracts; a model would be a correlated second judge of the Assessment. |
| capability-retirement (planned) | optional — capability-retirement/draft-case via frontier/high | Detection is rules over usage and health; weighing consumers and migration for an E26 retirement case is judgement a frontier model may draft. |
Lifecycle increment 2
Increment 2 of the proposed lifecycle (§9, row 2), on branch factory/lifecycle-sources from 217887b: the Discovery sources collector landed, so its declaration moved from LIFECYCLE_INTELLIGENCE into MODULE_INTELLIGENCE, as the registry requires of any module whose files exist. Implemented by Opus 5.5; passed independent review with that module (Astra round 5 PASS, after rounds 1–4 FAIL, every finding fixed; <local evidence archive>).
- What changed.
discovery-sourcesnames its two files,discovery-sources.tsanddiscovery-text.ts; its decision (none), reason and empty task list are unchanged. Its row therefore renders in the README table, not the lifecycle table above, anddocs/agents/discovery-sources.mdcarries its one intelligence line. - Accepted is claimed only on review.
MODULE_INTELLIGENCEcan hold a module in review, so its doc comment says "every module whose code exists (accepted, or in review with its increment)", and the README paragraph says the table holds the modules whose code exists; while the increment was in review it also saiddiscovery-sourceswas in review, not accepted (an adversarial finding: the row read as accepted), and since round 5's PASS it says the module was accepted with its increment. Comment and prose only: no line moves. - Nothing else moves. Every task's policy digest is byte-identical before and after (logs
policy-digests-before.json,policy-digests-after.jsonandpolicy-digests-compare.txtunder<local evidence archive>), and every task still refuses. - Line numbers kept. lifecycle cites
src/intelligence.tsby line number, and a test holds each anchor. The entry is therefore a hoisted function,discoverySourcesDeclaration(), placed after those lines and called from the end ofMODULE_INTELLIGENCE, so no line above them moves. - The README's 25 lines. The new row would make the section 26 lines; the blank line between its heading and paragraph is dropped instead, as
maindid forrepository-collector, so the section is 25 lines and the cap is unchanged. Merging withmain, which also added a row, will need a reviewed decision on where the rows go.
Merge with main
Lifecycle increments 0–2 (branches factory/lifecycle-schedule and factory/lifecycle-sources, which both contain increment 0) merged with main at 66f66d3 on branch factory/lifecycle-merge, which had meanwhile added repository-collector (step 1, increment 3). Implemented by Opus 5.5; independent review: <local evidence archive>, where each report applies only to its recorded snapshot. Receipt: lifecycle-merge-receipt.json.
- Where the rows go. With
repository-collector,lifecycle-scheduleanddiscovery-sources, 19 declarations have code and 3 are step-planned: 22 rows, which with the heading, paragraph, blank line and table header make 27 lines, over the accepted 25. The README therefore keeps exactly the declarations whose code exists (renderIntelligenceTable(), 24 lines), and the step-planned ones render in the planned declarations above (renderPlannedIntelligenceTable(), new), beside the lifecycle's. The 25-line cap, the exact rendered tables and the rule that every declaration renders exactly once across the tables are unchanged; the README test now names three tables instead of two.discovery-sourceskeeps its README row, which its adversarial test requires. - Registry unchanged. No declaration, task, pin, allowance or selector rule changes:
MODULE_INTELLIGENCEismain's withlifecycle-scheduleanddiscovery-sourcesadded (in that order, afterintelligence), andLIFECYCLE_INTELLIGENCEhas neither. Every task's policy digest is byte-identical to each parent's (logs under<local evidence archive>). - Line numbers.
main'srepository-collectorentry and increment 1'slifecycle-scheduleentry each add seven lines above theimplicit-retriesrefusal, so lifecycle now citessrc/intelligence.ts:709(695 in the spec) and its anchor test follows it; the new renderer sits below that line.
Merge with service access
Historical merge: Service access increment 1 joined main at 21bb146, after lifecycle increments 0–2. Opus 5.5 implemented it; reviews at that point were incomplete. The original receipt retains that evidence. The reviewed scanner and organisation-presence repairs now pass combined integration checks; see the current build review.
- One declaration added.
service-access(none, no tasks, namingservice-access.ts,service-discovery.tsandservice-kinds.ts) joinsMODULE_INTELLIGENCEafterdiscovery-sources, with the branch's decision and reason unchanged. No other declaration, task, pin, allowance or selector rule changes, and every task's policy digest is byte-identical tomain's (logs under the directory above). - Line numbers kept. The branch wrote the entry inline, which would add seven lines above the
implicit-retriesrefusal that lifecycle cites assrc/intelligence.ts:709. LikediscoverySourcesDeclaration(), it is therefore a hoisted function,serviceAccessDeclaration(), called from the end ofMODULE_INTELLIGENCE, so no line above the anchor moves and the anchor test is unchanged. - The README's former 25-line limit. This merge filled the old table. P6 subsequently moved the full registry into Declared modules, leaving model-using rows and a generated summary of deterministic modules in the README.
Standalone adoption
The draft private ESM entry point is software-factory/intelligence, compiled from source the packaging increment left unchanged; the 1 October 2026 change then altered this entry's behaviour and types (see its receipt). Standalone adoption covers deterministic selection, caller registries and the external refusal proof; draft evidence records the exact artefact. Importing or selecting dispatches nothing. Independent Astra review passed; the entry was merged on 1 October 2026 after an Opus 5.5 review and accepted locally the same day by the owner-designated acceptance reviewer after a Fable 5.1 review.
Priority lists and routes (1 October 2026)
Built on branch factory/intelligence-priority from d73b06e, as src/intelligence.ts alone (no new import, file or dependency). Implemented by Sonnet 5.5; an independent Astra review is run by the coordinator, with its report named in the receipt and the build review. It answers the owner's decisions of 1 October 2026: (a) the Claude CLI stays unavailable for the Factory's model roles (no Factory Claude profile; audit trust assumptions O2–O7 not accepted), and (b) discovery's daily and weekly triage and weekly synthesis switch to Codex, with the registry able to give a task models in priority order so arbitrary providers can be added. The coordinator's own Claude sessions are not what (a) rules out.
- Routes are data.
ProviderandTransportwiden from closed unions to grammar-checked strings; a route is declared (ModelTiers.transports) and names its provider, withTRANSPORTS_V1as the frozen default. A fact, entry or blocked pin on an undeclared route is refused at load; a request naming an undeclared route or provider is a refusal value, not aTypeError. - A task lists up to four entries.
pin, thenthen(one to three more), chosen once before contact, in order, from recorded facts only; each pass-over is recorded. A one-entry task behaves, refuses and digests as it did. - Owner decision (a), recorded. The five Claude facts (Fable 5.1, Opus 5.5, Sonnet 5 and Haiku 4.5 on
claude-cli, Sonnet 5 on the research route) becomeunavailable, each reason leading with the decision, andasOfmoves to 2026-10-01.chooseModelalready treatedunavailableas it treatsunqualified, so no refusal code, field or digest key is new; ten policy digests change (the eleven tasks barsignal-intake/search, whose research fact was alreadyunavailable), enumerated in the receipt, and nothing had frozen any of them. - Owner decision (b), as proposals.
signal-intake/triagelistsgpt-6-lunalow viacodex-cli(proposed) then Sonnet 5 low viaclaude-cli(unavailable);opportunity-synthesis/proposelistsgpt-6.1-solhigh viacodex-cli(proposed) then Opus 5.5 high (unavailable). Each OpenAI entry stays proposed until lifecycle increment 7 auditscodex-cli, builds its transport and establishes an effort, so neither task can run, and neither is admissible through the schedule until FU-1. Search keeps its research route, which stays unavailable (a Codex research profile needs its own design: T2 forbids--search). The three Astra tasks stay blocked and gainchecks. If (a) were reversed and the Claude route qualified beforecodex-cliestablishes an effort, triage and synthesis would run on their Claude entries; once both are eligible, the Codex entry runs. - Not a rule 7 substitution. Substitution means running a model, effort or route the reviewed registry did not name for the task, or changing what a call runs after its admission or after a provider answered. Every entry is named, dated and under the task's policy digest; the choice is made before contact from recorded facts and reproduced from them; a dispatch never moves; and an account refusal defers the same occurrence on the same entry. A later entry is therefore a declared, recorded choice. Whether the owner wants
AGENTS.mdto say so is a flagged proposal, not an edit made here. - Not established. Every item under Trust scope: above all that a task with
thenis not admissible through the accepted schedule until FU-1, and that no OpenAI entry has a transport, audit, commission or established effort.
Shared value implementation: common contracts. Owning errors, limits, stored identities and authority remain as specified above.
