The Precise Harness Field Manual

The catalog reports the tree that can answer today.

Capability nodes, commands, and attached floors below are regenerated from the running default tree. A repository package can be real without appearing here; that means it is not connected to this tree, not that it does not exist.

RUNTIME TRUTH generated 2026-08-10T04:31:48.790Z from npm run precise -- describe

Capability nodes: 24
Commands: 149
Attached floors: 36

ESTATE CAPTURED The same run observed 45 curated descriptors: 14 runtime-linked, 19 harness-verified, and 15 with dated deployment observations. These are estate totals, not capability counts.

Capability catalog24 nodes

Runtime path	One-line purpose from describe	Commands	Floors
`precise`	The Precise system: connect customer evidence, explain supported drivers, recommend or apply measurable changes, observe outcomes, and improve the next product decision.	5	0
`precise/decision-learning`	Retain, retrieve, and contextually verify the internal forward-bet checkpoint inside a customer learning history. Existing data, outcome, contribution, eval, floor, ablation, result, qualification, and workload cores remain authoritative.	6	1
`precise/advocate`	A legacy media workflow composed from real cores over one campaign: ingest evidence, analyze contribution, propose and gate a change, retain the forward bet, join the outcome, and sharpen the next recommendation.	2	4
`precise/research`	Freeze and verify domain-neutral, evidence-bound experiment contracts and receipts. Domain adapters run through createResearchProgramHarness; this node cannot execute or activate anything.	23	0
`precise/research/decision-program`	Freeze and contextually verify a DecisionResearchProgram from evidence map and independent audit through no-authority assignment, impact episodes, contextual nomination and confirmation planning, and row-local decision proposals.	43	0
`precise/research/markov-transition-map`	Freeze a point-in-time state-transition map, prove individual rows through its Merkle root, and score a train-only first-order Markov challenger on untouched validation or holdout transitions.	10	3
`precise/attribution`	Explain a complete, already-measured coalition value game with canonical Precise Shapley, interactions, and Owen math; never generate a strategy or promotion claim.	1	3
`precise/contribution`	Shapley contribution of coalition players to a KPI — REAL trace_exact/CC via the Python bridge (TS-controlled).	3	2
`precise/calibration`	ECHO STUB — tags the caller's {lo,hi}. The real calibrator is src/calibrator.ts (Mondrian split-conformal, tested), UNMOUNTED. Do not read this node's numbers as measured.	1	2
`precise/decision`	PROPOSE: the measured next-dollar frontier + priced reallocations (imports surfaces/core; ∇v̂ is the next variant).	6	1
`precise/normalizer`	AGENTIC ontology connector: propose (LLM/heuristic/memory) → HITL ratify → learn per source-type; proposers are ablated.	2	2
`precise/par`	Fit the par referent per cell — attainable-best quantile, advertiser-adjusted; market when identifiable, else honest self-par.	1	3
`precise/application`	Qualify and plan a Precise application through the canonical Boombox lifecycle while keeping product semantics in Precise and provider mutation in the authorized operator path.	3	8
`precise/config`	Infra config + environments + feature flags + surgical ops tools — one source of truth for dev and live.	9	1
`precise/seal`	Tamper-evident sha256 chain over decisions — CONNECTED to packages/gateway/src/ledger.ts (imports its real sealOver/verifyChain).	3	2
`precise/grade`	One internal outcome join in the customer learning history: attach signed, mature evidence to a retained prediction and capture the realized value for authorized model training.	1	3
`precise/backlog`	The single queryable backlog: every open finding tagged by GATE (what unblocks it). `now` = build these; the rest wait on their gate. Update src/backlog.ts, never a scattered TODO.	5	1
`precise/move`	The MoveCard product surface — compose action + value + contribution category + 4-predicate gate + sealRef into one approvable, dispatchable object.	3	2
`precise/seed`	Deterministic synthetic multi-advertiser corpus (seed 20260625): fires market-par in CI AND is the v̂(x) POC set. All records synthetic:true (quarantined).	1	1
`precise/value`	the value estimator (exact \| learned-vx) — model ablation seam	2	1
`precise/replay`	REPLAY a sealed decision: re-run the pure core, re-seal via the gateway's sealOver, assert it hashes to the stored seal_ref (recompute, not just chain integrity). The moat DEMONSTRATED.	2	1
`precise/cassette`	Package a Precise capability into a Boombox cassette (deny-gate + floors + seams); build/publish via the BoomboxDeployer seam.	2	0
`precise/ops`	Operator model over an injected estate reader. The default Precise tree is fixture-backed; a live GCP reader is not wired yet.	5	2
`precise/estate`	Read-only navigation over curated Precise estate metadata, dated observations, and selected repository source boundaries. This is not a live service registry.	10	0

Command catalog149 commands

Capability	Command	Runtime contract
`precise`	`start`	{} -> smallest product model, invariant, and executable first proof
`precise`	`skill`	{} -> {skill: string}
`precise`	`docs`	{} -> ordered developer reading path, generated status commands, references, and historical context
`precise`	`optional-surfaces`	{} -> optional domain harnesses; none are loaded
`precise`	`init`	{surface} -> lazily imported optional harness description
`precise/decision-learning`	`call-open`	precise.call-opening/v2 input -> create-only {status:'created'\|'reused',opening}; a changed opening for the same tenant_path+decision_id refuses
`precise/decision-learning`	`call-inspect`	{tenant_path,decision_id} -> precise.call/v2 at stage:'opened'\|null; happened, contributed, and taught remain null
`precise/decision-learning`	`verify-call-opening`	{opening,context} -> contextual replay verdict; a re-sealed substitution refuses
`precise/decision-learning`	`episode-close`	immutable bindings for one retained Call -> create-only precise.decision-learning-closure/v1 + recomputed episode and closed Call; Product verifiers load exposure and outcome facts
`precise/decision-learning`	`episode-inspect`	{tenant_path,decision_id} -> resolved closure, recomputed episode/Call, and verified\|unavailable semantic status\|null
`precise/decision-learning`	`verify-episode`	{tenant_path,decision_id,episode} -> verified\|unavailable\|invalid after exact primary reload and contextual replay
`precise/advocate`	`run`	{campaign?} -> {moveCard, act, sealRef, grade, trace, fidelity}
`precise/advocate`	`runFromSource`	{file?,from?,to?,dollars?,ratifiedBy?} -> sealed MoveCard + ingest report \| {needsHuman, proposal} (HITL)
`precise/research`	`freeze`	ExperimentSpecInput -> content-addressed precise.experiment-spec/v2
`precise/research`	`freeze-ablation-map`	ResearchAblationMapInput -> declared content-addressed comparison-bundle x cell denominator with no activation authority
`precise/research`	`freeze-physical-plan`	ResearchPhysicalPlanInput -> content-addressed physical stage, resource, denominator, and common-comparison contract
`precise/research`	`freeze-policy-semantics`	ResearchPolicySemanticsInput -> content-addressed opportunity, target-selection, and temporal policy contract
`precise/research`	`freeze-workload`	ResearchWorkloadProgramInput -> content-addressed exact-task workload program with no order authority
`precise/research`	`plan-boombox-workload`	{program,program_ref,descriptor,target} -> public @konstantdotcloud/boombox provider-free desired-state binding; separate signed host admission still required
`precise/research`	`plan-round`	{map,budget?,policy?} -> discovery-only run/audit/hold/refuse ResearchRoundPlan using a bounded caller-declared priority heuristic; confirmation refuses until contextual nomination exists
`precise/research`	`verify-ablation-map`	{map} -> semantic, declared-denominator, authority, and content-hash verification
`precise/research`	`verify-spec`	{spec} -> spec hash and semantic verification
`precise/research`	`verify-receipt`	{receipt} -> content hash, population, evidence, and no-order verification
`precise/research`	`verify-receipt-context`	{receipt,spec,adapterId,implementationHash} -> semantic run-context, floors, courts, winner, and promotion verification
`precise/research`	`verify-stage-receipt`	{receipt} -> stage lineage, missingness, authority, and content-hash verification
`precise/research`	`verify-stage-dag`	{receipts,spec,adapterId,implementationHash} -> complete source-to-contribution predecessor graph verification
`precise/research`	`verify-host-write-path-binding`	{plan,stage_id,read_write_paths} -> exact sealed host-writable resources to systemd ReadWritePaths binding; omitted and undeclared paths refuse
`precise/research`	`verify-physical-plan`	{plan} -> physical stage DAG, immutable-release/mutable-scratch split, population, comparison, resource, and no-order verification
`precise/research`	`verify-policy-semantics`	{semantics} -> opportunity unit, target-selection boundary, score/action target alignment, and content-hash verification
`precise/research`	`verify-round-plan`	{plan,map} -> plan hash, declared-candidate reconciliation, no-activation authority, and required contextual replay
`precise/research`	`verify-physical-policy-binding`	{plan,semantics} -> exact tenant, logical run, implementation, opportunity key, and semantics_hash evidence binding
`precise/research`	`verify-physical-workload-binding`	{plan,workload} -> exact tenant, logical run, implementation, and plan_hash evidence binding
`precise/research`	`verify-workload`	{program} -> workload identity, exact task population, implementation, evidence, and no-order verification
`precise/research`	`verify-boombox-workload-binding`	{binding,program} -> exact Precise workload, public Boombox descriptor/target/plan, package release, and no-authority contextual replay
`precise/research`	`verify-workload-state`	{state,program} -> content-addressed lifecycle, fencing, checkpoint, retry, and terminal verification
`precise/research`	`compare-receipts`	{left,right,requireSameImplementation?} -> compatibility and court/result changes only when frozen identities match
`precise/research/decision-program`	`freeze-map`	DecisionEvidenceMapInput -> precise.decision-evidence-map/v2; declared candidate/predicate denominator only, no action authority
`precise/research/decision-program`	`verify-map`	{map} -> semantic, denominator, authority, and map_hash verification
`precise/research/decision-program`	`freeze-round-plan`	{map,planner,resource_budget,decisions} -> precise.decision-research-round-plan/v2 with an unchanged primary slate and separate hold frame
`precise/research/decision-program`	`verify-round-plan`	{plan,map} -> exact map-bound contextual replay
`precise/research/decision-program`	`plan-decision-coverage`	{map,resource_budget,planner,policy} -> sealed exact reference-planner receipt; OPTIMAL may mark plan rows run, INFEASIBLE/UNKNOWN safely hold all eligible work; planning only
`precise/research/decision-program`	`verify-decision-coverage-receipt`	{receipt,map} -> exact contextual planner replay, proof status, plan_hash, and receipt_hash verification
`precise/research/decision-program`	`freeze-posterior-acquisition`	PosteriorAcquisitionProblemInput -> complete finite posterior-world problem with separate disposition loss, quality, gates, and resource vectors; shadow-only
`precise/research/decision-program`	`plan-posterior-acquisition`	{problem} -> exact conditional EVSI, quality-KG, gate/disposition information gain, Pareto frontier, stop decision, and shadow next-experiment recommendation
`precise/research/decision-program`	`verify-posterior-acquisition`	{receipt,problem} -> exact contextual replay of the finite posterior acquisition receipt
`precise/research/decision-program`	`project-posterior-acquisition-evaluation`	{problem,receipt,scenario} -> exact known-truth comparison of adaptive, cold-coverage, cost-first, and uniform-random selectors
`precise/research/decision-program`	`verify-posterior-acquisition-evaluation`	{evaluation,problem,receipt} -> exact contextual replay of the selector evaluation
`precise/research/decision-program`	`freeze-audit-plan-projection`	AuditPrimaryPlanProjectionInput -> planner-neutral no-authority projection; caller must first verify its source planner
`precise/research/decision-program`	`project-audit-plan`	{plan,map} -> contextually verified primary-slate/hold-frame projection
`precise/research/decision-program`	`freeze-audit-seed-commitment`	{seed_reveal} -> content-addressed seed commitment; external entropy, issuer, and precommit time remain separate authority
`precise/research/decision-program`	`freeze-audit-design`	{primary_plan,audit_budget,method,strata,seed_commitment_hash} -> immutable design over the exact hold frame
`precise/research/decision-program`	`freeze-audit-receipt`	{design,primary_plan,seed_reveal} -> exact inclusion-probability audit receipt; no execution authority
`precise/research/decision-program`	`verify-audit`	{receipt,design,primary_plan} -> contextual audit receipt replay
`precise/research/decision-program`	`freeze-intent`	ResearchExperimentIntentInput -> precise.research-experiment-intent/v1
`precise/research/decision-program`	`verify-intent`	{intent} -> semantic and intent_hash verification
`precise/research/decision-program`	`project-logical-run-id`	{experiment_spec,adapter_id,implementation_hash} -> shared precise.experiment-logical-run/v1 identity
`precise/research/decision-program`	`verify-intent-join`	{intent,map,candidate_id,experiment_spec,policy_semantics} -> exact semantic join across the planned candidate and executable experiment
`precise/research/decision-program`	`freeze-adapter-release`	ResearchAdapterReleaseInput -> immutable adapter/stage release identity; no execution authority
`precise/research/decision-program`	`verify-adapter-release`	{adapter_release} -> semantic and adapter_release_hash verification
`precise/research/decision-program`	`freeze-placement`	ResearchPlacementInput -> desired placement identity only; no host admission
`precise/research/decision-program`	`verify-placement`	{placement} -> semantic and placement_hash verification
`precise/research/decision-program`	`freeze-assignment-basis`	{map,plan,candidate_id,disposition,audit?,intent,experiment_spec,policy_semantics,adapter_release,placement} -> no-authority assignment basis; held work requires a verified audit receipt
`precise/research/decision-program`	`verify-assignment-basis`	{basis,map,plan,audit?,intent,experiment_spec,policy_semantics,adapter_release,placement,confirmation_round?,confirmation_context?} -> exact discovery or explicit confirmation assignment-basis replay
`precise/research/decision-program`	`freeze-confirmation-assignment-basis`	{map,plan,candidate_id,disposition:'run',intent,experiment_spec,policy_semantics,adapter_release,placement,confirmation_round,confirmation_context} -> ResearchAssignmentBasis/v1 with an exact outer confirmation binding; no host or run authority
`precise/research/decision-program`	`verify-confirmation-assignment-basis`	{basis,map,plan,intent,experiment_spec,policy_semantics,adapter_release,placement,confirmation_round,confirmation_context} -> exact outer receipt, fresh-support scope, map, expected-plan, nominated definition, and assignment-basis replay
`precise/research/decision-program`	`project-assignment-evidence-refs`	{basis} -> sorted physical-plan evidence refs bound by the assignment basis
`precise/research/decision-program`	`freeze-assignment`	{basis,physical_plan,workload,task_bindings,map,plan,audit?,intent,experiment_spec,policy_semantics,adapter_release,placement,confirmation_round?,confirmation_context?} -> precise.research-round-assignment/v1; still no host admission or execution authority
`precise/research/decision-program`	`verify-assignment`	{assignment,basis,physical_plan,workload,map,plan,audit?,intent,experiment_spec,policy_semantics,adapter_release,placement,confirmation_round?,confirmation_context?} -> exact discovery or outer-bound confirmation assignment replay
`precise/research/decision-program`	`freeze-impact-episode-opening`	{assignment,assignment_context,planner_prediction_receipt,before_decision_state_hash,private_reference_commitment?} -> precise.decision-impact-episode-opening/v1 bound to the full assignment and plan denominator
`precise/research/decision-program`	`verify-impact-episode-opening`	{opening,assignment,assignment_context} -> exact contextual assignment replay plus episode_id/opening_hash verification
`precise/research/decision-program`	`freeze-impact-episode-closing`	{opening,opening_context,terminal,courts,predicate_effects,actual_resources,elapsed_seconds,after_decision_state_hash,private_reference_reveal?} -> precise.decision-impact-episode-closing/v1 with explicit planner-training eligibility only
`precise/research/decision-program`	`verify-impact-episode-closing`	{closing,opening,assignment,assignment_context} -> exact opening, assignment, denominator, effects, and closing_hash replay
`precise/research/decision-program`	`freeze-contextual-nomination`	{map,primary_plan,audit,requested_candidate_ids,court_policy,outcomes,fresh_support,evidence_scope,recorded_at} -> precise.contextual-nomination-receipt/v1; exact primary+audit outcome denominator, fresh-support scope, nomination-only or sealed refusal
`precise/research/decision-program`	`verify-contextual-nomination`	{receipt,input} -> exact v2 map, primary plan, independent audit, outcomes, fresh support, scope, and receipt_hash replay
`precise/research/decision-program`	`freeze-contextual-confirmation-round`	{nomination_receipt,nomination_context,confirmation} -> precise.contextual-confirmation-round/v1; exact nominated definitions on fresh support, complete discovery denominator, and all-runnable confirmation plan input or sealed refusal; planning only
`precise/research/decision-program`	`verify-contextual-confirmation-round`	{receipt,input} -> exact nomination, fresh-support scope, confirmation map, round input, expected plan hash, denominator, and receipt_hash replay
`precise/research/decision-program`	`verify-decision-qualification`	{verification,context} -> replay an already-issued verifier seal against the exact tenant/predicate/workflow/contract/option/time scope; does not verify source bytes or grant promotion
`precise/research/decision-program`	`project-decision-proposals`	{program_id,tenant_path,decision_policy_hash,evidence_state_hash,as_of,coupling:'independent',targets} -> complete row-local precise.decision-proposal-set/v1; domain recommendations only, no Arranger, approval, or activation authority
`precise/research/decision-program`	`verify-decision-proposals`	{proposal_set,context?} -> complete target denominator, qualification binding, no-authority ceiling, proposal_set_hash, and optional exact tenant/policy/evidence/time/denominator context verification
`precise/research/markov-transition-map`	`freeze-map`	MarkovTransitionMapInput -> exact temporal denominator + canonical Merkle root; no source, promotion, activation, or order authority
`precise/research/markov-transition-map`	`verify-map`	{map} -> temporal split, denominator, authority, transition-leaf, and Merkle-root replay
`precise/research/markov-transition-map`	`prove`	{map,transition_id} -> canonical inclusion proof for one frozen transition
`precise/research/markov-transition-map`	`verify-proof`	{proof} -> transition leaf reaches the claimed map root
`precise/research/markov-transition-map`	`fit`	{map,laplace?} -> train-only first-order categorical Markov model + empirical marginal baseline
`precise/research/markov-transition-map`	`fit-contextual`	{map,context_prefix,prior_strength?} -> train-only cohort-conditioned Markov model with frozen first-order backoff
`precise/research/markov-transition-map`	`verify-model`	{map,model} -> exact map/training rows, recipe, probabilities, and model hash replay
`precise/research/markov-transition-map`	`verify-contextual-model`	{map,model} -> exact context projection, first-order prior, training rows, and model hash replay
`precise/research/markov-transition-map`	`score`	{map,model,split:validation\|holdout} -> proper scores and baseline deltas; diagnostic information value only
`precise/research/markov-transition-map`	`score-contextual`	{map,model,split:validation\|holdout} -> proper scores and row deltas against the first-order Markov baseline
`precise/attribution`	`attribute`	{game:{players,coalition_values+measured evidence\|synthetic weights+interactions,partition?,value_semantics},variant?,include_interactions?,seed?,num_samples?} -> release/game/evidence-bound attribution-only receipt; synthetic games remain research-only
`precise/contribution`	`score`	{segments:[{name,num,den}],denom_policy?} -> Record<name,phi> (real) \| {players,total} -> Record<player,phi> (legacy equal-split)
`precise/contribution`	`blame`	{dimension: string, varied: boolean, value: number} -> number \| Refusal
`precise/contribution`	`ablate`	{segments?} -> AblationReport (real exact-vs-cc, CAPTURED to resultsAt)
`precise/calibration`	`band`	{lo,hi} -> {lo,hi,tag:'projection-error-only'} (ECHO — not a calibrated band)
`precise/decision`	`companies`	{limit?} -> Decision Service company catalog
`precise/decision`	`company`	{companyId,snapshotId?,campaignId?} -> Decision Service company detail
`precise/decision`	`evaluate-v2`	{snapshotId,campaignId,decisionConfig?} -> real Decision Service evaluation
`precise/decision`	`optimize-v2`	{snapshotId,campaignId,decisionConfig?} -> real Decision Service optimization
`precise/decision`	`frontier`	{campaign,segments} -> NextDollarCurve
`precise/decision`	`price`	{segments,from,to,dollars} -> PriceMoveResult
`precise/normalizer`	`infer`	{rows,kind,ratifiedBy?,threshold?} -> {proposer,needsHuman,fromMemory,mapping}
`precise/normalizer`	`ablate`	{} -> AblationReport
`precise/par`	`fit`	{observations:[{cell,advertiser,realized}],q?,parVersion,direction?} -> ParRow[]
`precise/application`	`plan`	{input: HarnessApplicationPlanInput\|JSON} -> BoomboxApplicationDeployPlanV1 (plan only; no mutation)
`precise/application`	`qualify`	{input: PreciseReleaseQualificationInput\|JSON} -> immutable content-addressed PreciseReleaseQualification (gates promotion; renders nothing)
`precise/application`	`release`	{input: {qualification, qualification_ref, planned_at, plan}\|JSON} -> PreciseReleaseHandoff (descriptor-bound qualification + deterministic provider-free plan for the authorized Boombox operator; not admission)
`precise/config`	`env`	{} -> {current,available,envs}
`precise/config`	`config`	{env?} -> {env,infra,flags}
`precise/config`	`flags`	{env?} -> {flags,meta}
`precise/config`	`set`	{flag,value,env?} -> {env,flag,value,file}
`precise/config`	`profile`	{name?,apply?,env?} -> flag-set (POV + unbuilt warning)
`precise/config`	`diff`	{a,b} -> {changed}
`precise/config`	`secret`	{name} -> {command}
`precise/config`	`ledger`	{limit?} -> {command}
`precise/config`	`doctor`	{} -> {environment,ready,bridge_ready,scope,checks,remote_checks}
`precise/seal`	`seal`	{decision_id,event,payload} -> {seq,seal_ref,prev_seal,realized:null}
`precise/seal`	`verify`	{} -> {ok,entries[]} (via gateway verifyChain)
`precise/seal`	`grade`	{realized?,outcomeWindowEnd?,nowIso?} -> {graded,realized,historicalReplay} \| FloorViolation (replay DERIVED from the window closing, not a caller flag)
`precise/grade`	`grade`	{tenantPath,cell,allocation,realizedValue,allSigned,censoring,outcomeWindowEnd?,nowIso?} -> {realized\|null,claim,censoring,captured}
`precise/backlog`	`now`	{} -> build-now items
`precise/backlog`	`list`	{gate?,status?} -> items
`precise/backlog`	`gate`	{name} -> {unblocks}
`precise/backlog`	`stats`	{} -> counts
`precise/backlog`	`evals`	{} -> items needing ablation/continuous-eval
`precise/move`	`emit`	{action:{verb,target},delta,band,phi,parGap,variedWithCommonSupport,consent,reversibility,legible,highValue?,bypass?,sealRef?} -> {card:MoveCard,decision,gate} \| Refusal
`precise/move`	`gate`	{consent,reversibility,value,legibility,highValue?,bypass?} -> GateDecision (auto-dispatch\|hand-off) \| FloorViolation(gate-unbypassable)
`precise/move`	`categorize`	{phi,parGap,band,varied} -> 'Contributing'\|'Partial'\|'Redundant'\|'Waste' \| Refusal(un-varied Waste)
`precise/seed`	`generate`	{seed?,advertisers?,parVersion?} -> {seed,advertisers,cells,observations:[{cell,advertiser,realized,synthetic}],outcomes:OutcomeRecord[]}
`precise/value`	`ablate`	{} -> AblationReport
`precise/value`	`variants`	{} -> variants
`precise/replay`	`replay`	{decision_id?,segments?} -> ReplayReport {verified,storedSeal,recomputedSeal,chainIntact,...}
`precise/replay`	`tamper`	{decision_id?,segments?,bump?} -> {caught,floor,message}
`precise/cassette`	`manifest`	{} -> Cassette
`precise/cassette`	`build`	{} -> {draftId} \| 'provided by @boombox/sdk'
`precise/ops`	`observe`	{} -> WorldModel
`precise/ops`	`verdict`	{} -> {level,reasons[]}
`precise/ops`	`diagnose`	{subject?} -> {level,findings[],narration}
`precise/ops`	`remediate`	{verb,target,observedFailing,reversible?,humanCoSigned?,args?,policy?} -> {action_id,lifecycle,decision,status}
`precise/ops`	`board`	{subject?} -> {subject,ephemeral,renderTarget,slices,verdict} (JIT dashboard, HTML SSR, no fabricated numbers)
`precise/estate`	`list`	{kind?,lifecycle?,harness?,telemetry?,observed?,query?,limit?<=200} -> {authority,matched,returned,truncated,items:AssetSummary[]}
`precise/estate`	`show`	{id} -> {authority,descriptor,repositoryPath,latestObservation}; curated metadata, never a runtime
`precise/estate`	`coverage`	{} -> {authority,summary:EstateCoverageSummary}
`precise/estate`	`deployments`	{id?,kind?,provider?,project?,observed?,limit?<=200} -> declared targets joined to latest dated observations
`precise/estate`	`observations`	{id?,source?,limit?<=200} -> dated EstateDeploymentObservation[]
`precise/estate`	`drift`	{id?,code?} -> pure declared-vs-latest-observation drift summary and selection
`precise/estate`	`gaps`	{id?,code?} -> coverage gaps with descriptor identity
`precise/estate`	`source`	{id,query?,limit?<=200} -> bounded source-file paths inside the selected catalog boundary
`precise/estate`	`docs`	{id,query?,limit?<=200} -> bounded documentation paths inside the selected catalog boundary
`precise/estate`	`symbols`	{id,query?,exported?,kind?,limit?<=200} -> bounded shallow source symbols inside the selected catalog boundary

Floor catalog36 unique attached floors

Membership is generated from floor names attached to connected nodes in describe. Purpose lines are plain-language glosses; code remains the enforcement authority.

Floor	One-line purpose
`action-policy`	Refuses an operator action outside the sealed policy pack.
`advocate-credit-needs-control`	Requires a control before assigning intervention credit to the advocate.
`backlog-item-well-formed`	Requires every backlog entry to carry the registry fields its gate needs.
`band-projection-only`	Labels a band as projection error, never advice efficacy or causal lift.
`cross-tenant-target`	Refuses a command or record that crosses its bound tenant path.
`deploy-placement-must-match-topology`	Requires an application plan to match its canonical topology placement.
`finite-attribution-complete-game`	Requires a complete measured coalition game before finite attribution can run.
`finite-attribution-only`	Keeps an attribution receipt explanatory; it cannot choose or promote a strategy.
`finite-sampled-research-only`	Keeps sampled finite-game output research-only rather than settlement-authoritative.
`gate-blame-unvaried-dimension`	Refuses blame where the dimension did not vary with common support.
`gate-unbypassable`	Keeps the Move Card's required consent and reversibility predicates unbypassable.
`learned-cannot-settle`	Allows a learned estimate to serve, but only exact recomputation to settle.
`live-sharpen-while-null`	Refuses live grading language until a realized outcome is actually joined.
`mapping-not-ratified`	Requires human ratification before a proposed source mapping can apply.
`market-response-out-of-range`	Hands off moves outside the observed own-spend range as extrapolation.
`markov-transition-exact-denominator`	Requires a frozen transition map to retain its complete declared denominator.
`markov-transition-no-lookahead`	Prevents future transitions from leaking into a train-only Markov fit.
`markov-transition-no-order`	Keeps the Markov diagnostic free of order or activation authority.
`no-green-while-null`	Prevents an unread or empty estate from receiving a green verdict.
`no-secret-values-in-config`	Allows secret pointers in configuration, never secret values.
`outcome-censored-not-final`	Keeps pending or censored outcomes from grading as final.
`par-for-market-coverage`	Requires coverage, advertiser multiplicity, and common support before market par.
`par-referent-is-mean`	Requires an attainable-best quantile rather than a mean presented as par.
`par-version-not-pinned`	Pins the par version so benchmark drift cannot masquerade as a new gap.
`qualification-claims-explicit`	Requires every release qualification claim to be explicit and bounded.
`qualification-floors-exercised`	Requires release evidence to show that every declared floor was exercised.
`qualification-gates-promotion`	Prevents promotion without a passing, exact release qualification.
`qualification-immutable-refs`	Requires qualification evidence to use immutable references.
`qualification-no-secret-material`	Prevents credentials or signer material from entering qualification evidence.
`realized-null-until-signed`	Keeps realized value null until every declared outcome source is signed.
`release-artifact-must-match-qualification`	Binds the released artifact to the exact artifact that was qualified.
`release-source-closure-unbound`	Refuses a promotable handoff when the build lacks its source-byte closure.
`replay-mismatch`	Refuses when pure-core recomputation cannot reproduce the stored seal.
`singular-coalition`	Prevents positive-spend, zero-denominator coalitions from scoring as best.
`source-row-unmappable`	Surfaces and refuses source rows missing a ratified ontology mapping.
`synthetic-in-market-prior`	Quarantines synthetic records from the market pooling prior.

The stale-entry check found four doc/runtime conflicts.

4 FOUND Checked against the live describe tree and the named implementation headers. These conflicts are disclosed here; they do not feed the generated counts.

docs/atlas/MODEL.md describes the value component as exact | cc | learned-vx. Runtime precise/value exposes exact | learned-vx; CC is connected elsewhere under contribution/finite attribution, not as that component's third variant.
docs/atlas/MODEL.md describes posterior variance as native to the served model. The connected value node says “additive amortizer,” and gradient.ts widens by projection RMSE. No posterior band is present in the serve-side POC.
docs/atlas/MODEL.md lists synthetic quarantine as still to build. Runtime precise/seed now attaches synthetic-in-market-prior, and the floor exists in code.
docs/atlas/HARNESS.md says the Decision Learning Board “renders” the episode and the Call Sheet “is” its focused view. Runtime exposes Call/episode records but no Board or Call Sheet surface; the master plan still schedules that Svelte product as a future slice.

Discovery narrows from executable truth to exact source.

Start in harness/. The order matters because a semantic match can find code, while only the running tree says what is connected and only the estate says what is mature or observed.

Describe the connected tree.

Read named commands, contracts, evals, state, and floors from the process that can execute them.

cd harness
npm run precise -- describe

Ask the estate what the tree does not prove.

Coverage is curated repository truth; drift joins declared targets to dated observations. Neither is a live service registry.

npm run precise -- estate coverage
npm run precise -- estate drift
npm run precise -- estate gaps --code harness-missing

Search concepts, then code shapes.

CocoIndex accelerates discovery; it does not establish connection, deployment, ownership, or proof.

cd ..
ccc search "where campaign allocation decisions are made"
ccc search --path 'packages/**' --lang typescript "tenant identity binding"
ccc grep 'defineHarness(\X)' harness --lang typescript

Finish with exact symbols and call sites.

Use rg to verify the concrete string, symbol, floor, test, or transport path before changing anything.

rg -n "exactSymbolOrContract" .

Runnable forms reflect .claude/skills/precise-harness/SKILL.md and docs/atlas/HARNESS.md. The app-building guide also offers start as a human quickstart; it does not replace describe as connected-runtime authority.

Three commands show model, comparison, and refusal.

All three outputs below were captured from this checkout on 2026-08-10. Nothing is reconstructed. Each command exited zero; the refusal example returns a typed finding inside an {ok:true} transport envelope.

Start with the smallest product model.

CAPTURED

cd harness
npm run precise -- start

Captured output · complete data envelope

{
  "ok": true,
  "data": {
    "model": {
      "core": "Precise-owned product behavior and differentiated semantics",
      "harness": "the only product contract: commands, describe, evals, and floors over the real core",
      "qualification": "immutable Precise-owned proof of what one release may claim; deployment state is not stored here",
      "boombox": "the canonical shared-production and network operating envelope: tenant identity, deploy/run lifecycle, recovery, receipts, and fleet projection",
      "surfaces": "CLI, HTTP, frontend, and agents; clients of the harness, never a second implementation"
    },
    "invariant": "If work changes a customer-visible result, it lives in the core, behind a harness command, with an eval and an exercised floor before qualification.",
    "first_proof": [
      "npm run doctor",
      "npm run example",
      "npm run eval"
    ],
    "production_rule": "Local proof remains independently runnable. Each customer-facing release selects its operating home independently: Precise-managed, customer-operated, specialized, or another owner-host adapter. Boombox qualification, lifecycle, receipts, recovery, and network travel apply when that shared operating path is selected; specialized compute and data planes remain valid behind the same Product ports.",
    "next": "docs/atlas/START-HERE.md"
  }
}

Ablate the mounted value variants.

CAPTURED

cd harness
npm run precise -- value ablate

Captured output · complete data envelope

{
  "ok": true,
  "data": {
    "component": "value-estimator",
    "contract": "{players, v} -> {name: phi}",
    "ranked": [
      {
        "variant": "exact",
        "pass": 3,
        "fail": 0,
        "metric": 1
      },
      {
        "variant": "learned-vx",
        "pass": 3,
        "fail": 0,
        "metric": 0.9999999991393651
      }
    ],
    "winner": "exact"
  }
}

This is component conformance on its fixtures, not a frozen real-data experiment, promotion receipt, or proof that the learned variant can settle.

Prove a tampered input cannot replay its seal.

CAPTURED

cd harness
npm run precise -- replay tamper

Captured output · complete data envelope

{
  "ok": true,
  "data": {
    "caught": true,
    "floor": "replay-mismatch",
    "message": "FLOOR[replay-mismatch] recompute of 'omg/nissan/q3-olv' re-seals to sha256:f0c1d9ab0e860af… but the ledger stored sha256:246c5bd734c792e… — the sealed payload is NOT what the pure core reproduces from these inputs (tampered input, a drifted/non-deterministic core, or an edited receipt)"
  }
}

The inherited parts are useful at different evidence ceilings.

“Built” is too coarse here. The settlement math, serving math, seal, Call projection, and calibration path each carry a separate authority and a separate gap.

VERIFIED-PARTIAL

Exact-settle Shapley on ratio KPIs.

The production value-function family includes ratio games. For a coalition S, it aggregates numerator and denominator separately, then computes the declared outcome:

v(S) = Σ numerator(S) / Σ denominator(S)

Exact Shapley enumerates the complete coalition game and averages each player's marginal contribution over orderings. On a complete, measured game, that exact result may settle attribution. The generic runtime surface runs exact Shapley, interactions, and Owen through 16 players; sampled complementary contribution covers 17–20 but stays research-only and exposes no invented confidence interval.

Why only verified-partial: the cross-language production route currently covers exact/CC and the CAC family, does not route every estimator, and has no real media scanner or product caller consuming its result. Ratio denominator policy is part of the estimand; zero-conversion singular coalitions must refuse or use a declared floor, never score as “best.”

Sources: packages/trace-score-job/tracescore/compute.py, shapley_methods/README.md, harness/src/outcome.ts, runtime precise/attribution, and docs/atlas/CONNECTIONS.md.

POC

Serve-side surrogate and gradient.

The serving question is different: where should the next unit of allocation go now? vhat.ts fits a seeded, glass-box additive surrogate over sampled coalitions. It recovers exact Shapley only when the game is additive; off-form it is a uniform-measure OLS projection with ridge shrinkage, not an exact Shapley estimator.

gradient.ts adds a quadratic continuous-allocation surface. Its derivative moves with the current allocation and can represent diminishing returns and pairwise terms. The integrated frontier can be checked back against exact Shapley on the coalition restriction.

What the code proves

Deterministic POC fits, on-form fixtures, a measurable exact gap, and an RMSE-widened derivative band.

What it does not prove

No real-data validation, no posterior, no advice-efficacy interval, and no settlement authority.

Honest band label: the current band is projection RMSE only. It is not a posterior interval, it does not cover action efficacy, and it does not rescue out-of-range allocation. The file header says “validated with ZERO real data.”

Sources: harness/src/vhat.ts, harness/src/gradient.ts, docs/atlas/MODEL.md, and runtime precise/value.

VERIFIED-PARTIAL

Seal, Call record, and Call Sheet.

REAL Seal + initial Call slice

The seal imports the gateway's real sealOver and verifyChain. Decision Learning can open, inspect, close, and verify one Call-bound initial episode against separately retained primaries.

SPEC-ONLY Focused Call Sheet UI

The page and product route are designed in Atlas documents, but no Svelte Call Sheet surface exists in the connected tree.

A sealed Call freezes the forward bet before the outcome: what was known, what was chosen, and what was predicted. Later, verified Action Exposure and a mature Outcome Observation can close the initial episode and derive its Forecast Score. The seal proves byte integrity and replay; it does not manufacture causality, execution, contribution, or learning authority.

The Call Sheet is the focused accountability projection of that record when it is eventually rendered. It is not the ledger, not the decision-learning system, and not presently a connected UI. Merkle/AliceNet anchoring also remains absent; the ledger reports anchored:false.

Sources: runtime precise/seal and precise/decision-learning, packages/gateway/src/ledger.ts, docs/atlas/CONNECTIONS.md, and the Decision Learning master plan.

VERIFIED-PARTIAL

Conformal calibration.

The real offline calibration work is media-born: walk-forward campaign panels, Mondrian groups, conservative residual quantiles, and published empirical coverage under drift. The in-repo calibrator.ts is a real split-conformal Mondrian implementation: a sufficiently supported group gets its own residual half-width, a thin group falls back to the global band, and globally insufficient support yields an infinite band rather than a point.

Why only verified-partial: the default precise/calibration band command is still an echo stub. It tags caller-supplied bounds; it does not invoke the real calibrator. The real artifacts and algorithm exist, but the connected act path has not earned the word calibrated.

Evidence ceiling: conformal calibration measures projection error on the population and time split that produced the residuals. It does not prove causal lift, action efficacy, exchangeability across regime change, or gradient direction.

Sources: packages/calibration-breadth/CLAUDE.md, harness/src/calibrator.ts, runtime precise/calibration, and docs/atlas/CONNECTIONS.md.

The primitives compose into one inspectable learning loop.

The lifecycle keeps prospective choice, action, realized outcome, retrospective credit, and future learning separate. A stage cannot borrow authority from the stage beside it.

Follow one decision through its evidence states. 1 / 7 · Frame

Frame a decision.Declare outcome, unit, direction, denominator, evidence ceiling, comparator, and action boundary.
Freeze and preregister.Bind the question, known-at cutoff, alternatives, controls, population, physical plan, and promotion rule.
Compute behind floors.Run the canonical core. Missing support, singular denominators, leakage, or unsafe action becomes a typed refusal.
Seal the Call.Freeze known, chosen, predicted, versions, evidence references, and the recomputable hash before action or outcome.
Observe and join.Record actual exposure and join only signed, mature outcome evidence. Pending stays null.
Settle realized credit.Use exact attribution on the complete measured game; a learned or sampled estimate cannot acquire settlement authority.
Calibrate and compound.Score the frozen forecast, update reliability only under authority, retain the refusal history, and carry the track record forward.

This is a concept composition, not a claim that every transport and product caller is wired. Current reality is the union of runtime describe, generated estate status, and the per-part maturity ledger above.

Why Polymarket: the fast twin of media

Polymarket is an opt-in proof domain, not the harness and not a replacement for media. It compresses the feedback clock around familiar auction, identity, attribution, capacity, and calibration problems.

Media	Polymarket	Shared primitive
Programmatic auction (bid, win rate, clearing price)	CLOB (quote, fill, spread)	auction microstructure, adverse selection
Attribution settles in 6–18 months of negotiated MTA/MMM fog	Resolution settles in DAYS at $0/$1 by adversarial oracle	the settle loop — same math, ~50–100× faster iteration
ROAS = Σ value / Σ spend across channels	Return-on-capital = Σ pnl / Σ capital across cohorts	Shapley credit on RATIO KPIs across segments
Data vendors sell audience segments that decay as they sell	Signal sellers publish wallet lists that decay as they're copied	reflexivity of rented signals; crowd-maps beat crowd-membership
Identity resolution: cookies/devices → households	Entity resolution: wallets → actors (Sybil, rotation)	the unit-of-signal question; fingerprint similarity
Fraud/IVT inflating delivered volume	Wash trading inflating printed volume (~60% weekly peaks measured)	denominator hygiene before any credit math
Pacing into predictable demand (tentpoles, dayparts)	Positioning ahead of predictable flow (alert echoes, copy waves)	anticipate-liquidity-in-advance
Your own spend moves the auction	Your own fills move thin books	FLOOR 17 self-impact
Forecast CPA/reach with bands, graded later	Sealed calls with conformal bands, graded at resolution	calibration as the compounding asset

The symmetry stops where the evidence changes.

Polymarket outcomes are binary and terminal with a real oracle. Media truth is negotiated and slow. Polymarket capacity is small. So Polymarket is the LAB—fast ground truth for the same primitives—and media is the MARKET the proven primitives return to. The harness math was literally born in media data: the calibration harness's panels are media campaigns, and the Shapley job's value functions were media KPIs.

Pattern mapping supplied by the foreman. Polymarket code, data, floors, and schema remain optional and must not shape or load the default media runtime.