Factory docs, home
Page navigation

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 from renderNoneModulesLine(), the full declared-modules table from renderModuleIntelligenceTable(), and the planned declarations below, the handover steps' generated by renderPlannedIntelligenceTable() and the lifecycle's by renderLifecycleIntelligenceTable(); 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-gate holds product-gate.ts and delivery-records.ts, as its reference and build-review row do), PLANNED_INTELLIGENCE (handover steps 1–4; planning also names the proposed lifecycle's planning/opportunity-gate.ts) and LIFECYCLE_INTELLIGENCE (the lifecycle's other planned modules whose code has not landed, §2; increment 1 moved lifecycle-schedule into MODULE_INTELLIGENCE with lifecycle-schedule.ts, and increment 2 discovery-sources, naming discovery-sources.ts and discovery-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 three then entries (a task with one entry, as before, has only pin, 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_V1 unless a registry declares its own). Every task of an accepted or step-planned module is frontier: producer/propose pins CLAUDE_MODEL, the one model the Claude transport binds, and the five other earlier tasks pin the most capable model MODEL_TIERS lists. The lifecycle's five tasks pin the spec's defaults as hypotheses: claude-sonnet-5 low (efficient) for draft packs and, under the research profile, search; claude-opus-5-5 high for retirement cases; and, since the owner's decision of 1 October 2026, triage and the weekly synthesis name an OpenAI model through codex-cli first (gpt-6-luna low and gpt-6.1-sol high, each proposed until that route establishes an effort), then their earlier Claude default. Its three Astra tasks are BLOCKED_TASKS: gpt-6-astra xhigh through codex-cli is 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 on claude-cli and, for Sonnet 5 only, on the research route claude-cli-research; OpenAI's (gpt-6-astra, gpt-6-luna, gpt-6.1-sol) on codex-cli, with no established effort. Every fact on a Claude route is unavailable for 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

NameWhat
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, Allowancefrozen 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_LIMITSa 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_CEILINGSPRODUCER_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, REGISTRYthe 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

  1. 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 into MODULE_INTELLIGENCE. The guarded fixture sources stay none.
  2. 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, predetermined refused, tools none or research, 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 when optional or required, each model on a declared route of its provider (so nothing on openai-responses, which no registry declares), every entry of a task's list (pin, then then: 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 with then, at an effort of EFFORTS, 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 with tools: "research" (it has a tool), one of the four allowances, checks and 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 within TRANSPORT_CEILINGS, and a complete commission reference for any qualified model. A bad edit throws at import.
  3. 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 into MODULE_INTELLIGENCE stays valid. The exchange runs through a Producers-module transport the caller is handed, never imports (step-1 spec §7 D1).
  4. chooseModel is pure and deterministic. It reads each request field once, from own data properties (an accessor is a TypeError), 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 only node:crypto and ./canonical-json.ts, reads no clock, randomness, environment or file, names no identifier module or require (test/delivery-boundaries.test.ts refuses both in src/, so the module key is written as a string), and no other module file imports it.
  5. It never substitutes. A task's entries (its pin, then any then entries) 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. An efficient task whose basis is not measured refuses not-measured before any walk, whatever its entries' qualification.
  6. 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.
  7. A model is qualified only with a committed docs/<provider>-producer-commission.json. The test checks it with parseProducerCommission and commissionDigest from src/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 than MODEL_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.
  8. A route whose provider request count is unknown (every route today) cannot show "no implicit retry", so its entries are passed over implicit-retries until a commission establishes one request per invocation.
  9. A verifier needs the Candidate's producer identity from its produce admission (produce:<48 lowercase hex>, exactly the Product gate's productionKeyOf key), naming a model MODEL_TIERS lists for that provider, and never runs on the producing model (an entry on it is passed over not-independent); an authored identity names no provider or model. Independence is also checked at load: the optional checks names 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, then and 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 a proposed key 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. checks drives these load rules only, so it is outside the policy digest. A Factory limit, held by a test rather than a load error: in REGISTRY, checks appears 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.
  10. 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.
  11. It agrees with the accepted transports (tested): TRANSPORT_CEILINGS equals PRODUCER_LIMITS and MAX_REASON_LENGTH its textLength; each claude-cli fact's request-count capability is the Claude transport's, and CLAUDE_MODEL lists exactly its efforts; the producer pins CLAUDE_MODEL. No model is listed on the accepted OpenAI Responses transport, which no registry route declares. codex-cli and claude-cli-research have no Producers transport, so their facts have an unknown request count and no qualification, and the test's commission check refuses any commission for them; the three codex-cli facts (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 is unavailable, 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".
  12. The walk is deterministic and reproducible. Every pass-over input except the producer identity is inside the policy digest (the order, each entry, the proposed marker 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 a BlockedTask. 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 or no-eligible-entry.
  13. The README section is at most 25 lines: a heading, one paragraph, renderIntelligenceTable() (one row per optional or required declaration) and renderNoneModulesLine(); renderModuleIntelligenceTable(), renderPlannedIntelligenceTable() and renderLifecycleIntelligenceTable() each sit exactly once below, so every declaration renders in exactly one of those three tables. Each accepted module's page here carries renderIntelligenceLine() 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, and producer/propose with not-qualified (its reason now reads unavailable: owner decision, 1 October 2026: …, since the Claude CLI is unavailable for the Factory's model roles); each blocked task refuses blocked, always. With every protocol specified, the three efficient tasks would refuse not-measured. Once triage is measured and the weekly synthesis (frontier, so with no measurement gate) has its protocol specified, each, whose pin is a proposed OpenAI entry, refuses proposed in the verify form and no-eligible-entry (codes proposed, not-qualified) in the choose form; every other task refuses not-qualified, because no model is qualified (tested). A one-entry task is refused with its own entry's code and no skipped list.

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 chooseModel yet, and the transports do not consult the registry; today the Claude transport's own CLAUDE_MODEL check is what refuses another model.
  • Admission of a task with then. The accepted schedule maps a task to its account statically (proposedCommission names claude for triage and the weekly synthesis) and records no model, and admitCall takes 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 with then is therefore not admissible through the accepted schedule until admitCall records 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 to claude and openai) cannot qualify it and the schedule (Account, closed to claude and chatgpt) cannot admit it; each needs its own reviewed change.
  • The proposed OpenAI entries. No codex-cli Producers transport, audit, commission or request count exists (lifecycle L7); that codex exec runs headless with --output-schema on this sign-in for gpt-6-luna, gpt-6.1-sol or gpt-6-astra is unproven; how the Factory would set an effort on codex-cli is open (the 0.159.1 source has no dedicated option, only the model_reasoning_effort configuration, which T2's --ignore-user-config design 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 (judgeRepository judges them inconclusive and the Product gate refuses review dispatches), matching repository-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:crypto and ./canonical-json.ts only. It must not import a producer: outside the Producers module no src/ file may reach one.
  • Consumers: none in src/. test/intelligence.test.ts reads src/producer.ts, src/claude-producer.ts and src/openai-producer.ts to check agreement.
  • Recording a choice. The choose form's result belongs with the frozen work and the admission (planSlice for a Slice; admitCall for 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 chooseModel with the frozen Slice's policy digest; a refusal becomes outcome unavailable and nothing is dispatched. planSlice records taskPolicyDigest beside 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.ts and npm run typecheck; npm run check runs everything.
  • A change to a pin, escalation, bounds or estimate figure, allowance, protocol, caller, tier, an efficient task's basis, role, phase or a pinned model's enforced facts (including qualification) changes taskPolicyDigest, so frozen requests refuse with policy-mismatch by 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's ProviderId, an audit, a commission, the test's binding table and an admission account (the schedule's Account) 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-mismatch even 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 into MODULE_INTELLIGENCE with 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)}. A codex-cli or claude-cli-research model can qualify only after its Producers transport, audit and commission exist and the test's binding table names that transport.
  • An efficient task, 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 an efficient task's basis is measured, chooseModel refuses it not-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.

ModuleIntelligenceWhy
command-journalnoneAtomic commands, receipts and events; correctness is a transaction property, and a model cannot make a write more atomic or a replay more exact.
evidence-assurancenoneA Verdict is a pure fold over trusted collector observations; a model's opinion is not evidence, only a producer 'passed' flag by another name.
executionnoneRun and Attempt ownership, Budget and cancellation are invariants checked on every read and write; there is no judgement to delegate.
local-fixture-workernoneFixed fixtures use declared source or compiled pins; model choices must not relax ownership or manufacture Evidence.
attempt-fencenoneOwnership 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-verificationnonePicks the next step from durable facts under fixed rules, so any controller reproduces the same recovery; a model would make it unrepeatable.
confined-executornoneA kernel sandbox boundary that runs one bounded process and reports what the host saw; any decision a model made here would weaken confinement.
repositorynoneSeals and integrates exact bytes: every identity is recomputed and the target ref moves once per intent; nothing is inferred.
operational-signalsnoneAuthenticated bounded intake, immutable identities and atomic checkpoints are exact rules; model output supplies neither authority nor coverage.
portfoliononeA registry and replay of sourced facts, including model usage receipts, whose whole value is that nothing in it is inferred.
dashboardnonePresents decided facts and counts (apps/dashboard renders them); a generated explanation would be optimistic copy over evidence.
project-guidanceoptional — project-guidance/summarise via frontier/lowStores 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.
attentionnoneItems exist exactly while sourced facts say so; inferred urgency or drafted advice would be a second, unsourced queue.
producerrequired — producer/propose via frontier/highThe one place a model's output enters the factory: one bounded, tool-free edit proposal that stays data until the repository seals it.
repository-assuranceoptional — repository-assurance/review via frontier/medium; repository-assurance/fresh-scenario via frontier/highA 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-gatenoneAuthority, admission, integration, create-once delivery records and Assessments are pure decisions over durable facts; a model would be a second authority.
repository-collectornoneRuns frozen checks under pinned source or compiled resources; drift blocks dispatch and attribution. It observes and never judges.
intelligencenoneThis registry and selector: which model runs must be reproducible from the record, so it is frozen data and a pure function.
lifecycle-schedulenoneOccurrence identity, the capacity ledger and deferral are rules over the clock and counters; a model would make scheduled runs unrepeatable.
factory-workflownoneStateless composition invokes existing native stages with original requests; no model grants authority or settles unknown effects.
deliverynoneComposition moves authored bytes and re-derives stored Evidence under the Product gate; no model makes these decisions.
verification-workflownoneExternal seals use Delivery’s gate and collector; genuine Evidence re-derives original proof. No model grants authority.
implementation-workflownoneOriginal worker requests are data; deterministic admission, host Evidence and seal validation decide authority. This module invokes no model transport.
knowledgenoneReviewed lesson pins, source permissions and deterministic advice retain original evidence; no model grants authority or chooses a new owner.
checkout-gitnoneA bounded fixed Git command reads committed bytes; interpretation and generation are absent.
calendarnoneShared neutral Gregorian arithmetic and fixed schedule identities are pure rules over caller data.
discovery-sourcesnoneFetching commissioned Sources, hashing, de-duplication and quote checks are exact byte operations; a model could only blur what must match.
service-accessnoneDiscovery, references, readiness and runbooks are exact rules over names and dates; a model would add an injection path near secrets, not accuracy.
owner-policynoneCounts 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-healthnoneHealth, episodes and signatures are fixed rules over what GitHub reports; a model would guess at causes where only observed signatures are allowed.
owner-digestnoneEvery line is rendered from recorded facts and cites them; a model would put unsourced words into what the owner reads and trusts.
temporal-planningnoneDates and constraints are a deterministic evaluation of caller-owned evidence, precision and policy; no model can establish an occurrence or grant authority.
capacity-planningnoneCapacity is bounded arithmetic over attributed native observations and explicit assumptions; a model cannot reserve quota or promise completion.
material-timingnoneMaterial timing checks pinned civil rules, attributed readiness and approved constraints; a model cannot establish availability or authorise publication.
provider-eventsnoneSource pins, current permission values and bounded notification fields are exact rules; a model would add authority and leak source data.
provider-subscriptionsnoneSubscriptions enforce scoped private lifecycle, current caller authority and bounded verification; a model cannot verify keys or grant callback contact.
proposal-ownershipnoneImmutable proposal generations and first-offer ownership follow an explicit current authority fence; no model supplies permission or settles an unknown effect.
guidance-acceptancenoneOriginal Guidance commands require current permission and exact history; a model cannot grant authority, infer acceptance or release ownership.
provider-events-rpcnoneExact method routing, bounded JSON and fixed host error projection need no model judgement or new authority.
provider-guidance-toolsnoneTwo bounded tools retain original Guidance identity and current receiver authority; no model decides permission, acceptance or replacement.
milestone-objectivesnoneMilestone intent and reviewed plans follow current caller authority and original Journal history; attributed dates never grant work or promise delivery.
provider-event-deliverynoneCurrent caller authority and retained attempts bound one notification; a model cannot grant contact or infer a domain effect.
provider-diagnosticsnoneOptional retained-fact attribution is deterministic; a model cannot infer a provider cause, change an outcome or authorise a retry.
research-jobsnoneOne original public collection remains attributed and untriaged; no model grants source access, renews an allowance or admits implementation.
research-semanticsnoneCaller ports propose bounded semantics; native quote support and current authority checks decide retention. This module has no model transport.
milestone-researchnoneRecorded draft parsing preserves native provenance and prepares existing commands; only a separately qualified current independent review can admit a plan.
milestone-work-briefnoneSelected-generation brief preparation preserves captured native facts; it cannot admit work, infer current authority or turn capacity counts into dates.
prevention-registernoneGuardrail facts are fixed template rules over caller-supplied reads and dated owner exemptions; a model would guess presence where only read evidence counts.
marketing-workflownoneClaims 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-itemsnoneClaims 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: planning in PLANNED_INTELLIGENCE, now naming planning/opportunity-gate.ts, and the other eight in LIFECYCLE_INTELLIGENCE. lifecycle-schedule, discovery-sources, owner-decisions and outcome-validation are none; signal-intake, opportunity-synthesis, growth and capability-retirement are optional, 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 basis hypothesis.
  • The three Astra tasks are declared blocked. Spec §4 also names signal-intake/audit, planning/challenge-opportunity and growth/review-pack, at gpt-6-astra xhigh (decision 4's default). codex exec has 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 on codex-cli: its fact lists none, as claude-haiku-4-5's does, and a pin must name an effort its fact lists (invariant 2). The three are therefore BLOCKED_TASKS, with every descriptive field, their caller and allowance, and Astra at xhigh as a proposed pin; chooseModel refuses them blocked, 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 then gpt-6-astra is no tier candidate.
  • Efficient tasks wait for their own measurement. Triage, search and the draft pack pin claude-sonnet-5 low (decision 1's default) as hypotheses, and chooseModel refuses each not-measured until its own comparison with Opus 5.5 low on its own corpus (spec L3) makes its basis measured; qualifying the model for one task never makes another selectable. An efficient task's basis is part of its policy digest; a frontier task'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's ClaudeResearchProfile), on which only Sonnet 5 is listed, unavailable, with the CLI's --effort values and an unknown request 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 from openai-responses to codex-cli, and gpt-6-astra is listed only there, unqualified, with no established effort and an unknown request 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; only planning names 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-cli is only declared: no Producers transport, pinned audit (spec increment 7) or commission exists, and neither that codex exec -m gpt-6-astra --output-schema runs 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_MODEL only; spec increment 6), and each efficient pin is an unmeasured hypothesis. The research profile has no argv, audit or qualification (spec increment 10). discovery-window is 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_INTELLIGENCE with the files that land; codex-cli gets 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:

ModuleIntelligenceWhy
brief (planned)optional — brief/explain-trade-offs via frontier/lowPins 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/xhighHealth, 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:

ModuleIntelligenceWhy
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/xhighTriage 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/highComposing 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)noneThe 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/xhighProse 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)noneMeasurement 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/highDetection 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-sources names its two files, discovery-sources.ts and discovery-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, and docs/agents/discovery-sources.md carries its one intelligence line.
  • Accepted is claimed only on review. MODULE_INTELLIGENCE can 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 said discovery-sources was 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.json and policy-digests-compare.txt under <local evidence archive>), and every task still refuses.
  • Line numbers kept. lifecycle cites src/intelligence.ts by 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 of MODULE_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 main did for repository-collector, so the section is 25 lines and the cap is unchanged. Merging with main, 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-schedule and discovery-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-sources keeps its README row, which its adversarial test requires.
  • Registry unchanged. No declaration, task, pin, allowance or selector rule changes: MODULE_INTELLIGENCE is main's with lifecycle-schedule and discovery-sources added (in that order, after intelligence), and LIFECYCLE_INTELLIGENCE has neither. Every task's policy digest is byte-identical to each parent's (logs under <local evidence archive>).
  • Line numbers. main's repository-collector entry and increment 1's lifecycle-schedule entry each add seven lines above the implicit-retries refusal, so lifecycle now cites src/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, naming service-access.ts, service-discovery.ts and service-kinds.ts) joins MODULE_INTELLIGENCE after discovery-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 to main's (logs under the directory above).
  • Line numbers kept. The branch wrote the entry inline, which would add seven lines above the implicit-retries refusal that lifecycle cites as src/intelligence.ts:709. Like discoverySourcesDeclaration(), it is therefore a hoisted function, serviceAccessDeclaration(), called from the end of MODULE_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. Provider and Transport widen from closed unions to grammar-checked strings; a route is declared (ModelTiers.transports) and names its provider, with TRANSPORTS_V1 as 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 a TypeError.
  • A task lists up to four entries. pin, then then (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) become unavailable, each reason leading with the decision, and asOf moves to 2026-10-01. chooseModel already treated unavailable as it treats unqualified, so no refusal code, field or digest key is new; ten policy digests change (the eleven tasks bar signal-intake/search, whose research fact was already unavailable), enumerated in the receipt, and nothing had frozen any of them.
  • Owner decision (b), as proposals. signal-intake/triage lists gpt-6-luna low via codex-cli (proposed) then Sonnet 5 low via claude-cli (unavailable); opportunity-synthesis/propose lists gpt-6.1-sol high via codex-cli (proposed) then Opus 5.5 high (unavailable). Each OpenAI entry stays proposed until lifecycle increment 7 audits codex-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 gain checks. If (a) were reversed and the Claude route qualified before codex-cli establishes 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.md to say so is a flagged proposal, not an edit made here.
  • Not established. Every item under Trust scope: above all that a task with then is 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.

Source: docs/agents/intelligence.md