Skip to main content

Appendix D — Protocol Schemas

These are draft executable protocol schemas for the living book. They are intentionally small and should not be treated as final API contracts or as evidence that a full implementation exists. A schema records the current operational shape of a record the book can validate, test, or later formalize.

Executable schema drafts are tracked in schemas/:

Example fixtures for implemented schema checks are tracked in tests/fixtures/protocol_records/ and validated by python3 scripts/validate_protocol_examples.py.

D.1 Command Contract

command_contract:
  contract_id: string
  intent_id: string
  validation_state: validated_for_planning
  role: string
  objective: string
  context_refs: []
  field_provenance: []
  field_confidence: []
  constraints: []
  procedure: []
  allowed_means: []
  forbidden_means: []
  bounded_defaults: []
  output_contract: string
  verification: []
  failure_behavior: []
  authority_ceiling: string
  authority_basis: string
  required_approvals: []
  expected_artifacts: []
  feedback_route: string
  recontract_points: []
  dispatch_blockers: []
  non_claims: []

This record turns a request into an operational command with explicit objective, context, constraints, allowed means, output, verification, failure behavior, authority, approvals, artifacts, field provenance, bounded defaults, dispatch blockers, re-contract points, non-claims, and feedback route.

D.2 Intent Contract

intent_contract:
  intent_id: string
  intake_state: validated_for_command
  request_summary: string
  desired_outcome: string
  allowed_means: []
  forbidden_means: []
  authority_ceiling: string
  source_boundaries: []
  acceptance_criteria: []
  evidence_requirements: []
  escalation_conditions: []
  stop_conditions: []
  open_ambiguities: []
  bounded_defaults: []
  recontract_triggers: []
  non_claims: []

This record translates natural-language purpose into a bounded contract before planning or execution, including intake state, bounded defaults, re-contract triggers, and explicit non-claims.

D.3 Intent-to-Execution Trace

intent_execution_trace:
  trace_id: string
  intent_contract: string
  command_contract: string
  plan_graph: string
  typed_jobs: []
  authority_transitions: []
  handoff_receipts: []
  dispatch_receipts: []
  artifacts: []
  verification_records: []
  delivery_or_deployment: string
  feedback_refs: []
  recontract_events: []
  stop_or_fault_state: string
  residuals: []
  non_claims: []

This record preserves the chain from intent to command, plan, job, authority transition, handoff receipt, dispatch receipt, artifact, verification, delivery, feedback, re-contract event, stop/fault state, residual, and explicit non-claim.

D.4 Layer Boundary Record

layer_boundary_record:
  layer_id: string
  lifecycle_state: fixture_validated
  owner: string
  responsibility: string
  chapter_refs: []
  traceability_state: claim_mapped
  input_artifacts: []
  output_artifacts: []
  authority_ceiling: string
  handoff_protocol: string
  contract_refs: []
  change_policy: string
  integration_decision: owns_layer
  owned_invariants: []
  failure_modes: []
  evidence_gates: []
  downstream_interfaces: []
  promotion_blockers: []
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record gives each stack layer a bounded lifecycle state, owner, chapter refs, traceability state, responsibility, input/output surface, authority ceiling, handoff protocol, contract refs, change policy, integration decision, invariant set, failure model, evidence gate, downstream interface, promotion blockers, source refs, support-state effect, and explicit non-claims.

D.5 Plan Graph

plan_graph:
  plan_id: string
  command_contract: string
  assumptions: []
  nodes: []
  dependencies: []
  context_requests: []
  tool_requirements: []
  authority_requirements: []
  authority_budget: string
  risk_budget: string
  compute_budget: string
  verification_plan: []
  replanning_policy: string
  replanning_history: []
  stop_conditions: []
  node_lifecycle_states: []
  blocked_nodes: []
  dispatch_receipts: []
  residual_register: []
  dispatch_state: dispatchable
  non_claims: []

This record keeps planning separate from memory, reasoning, and execution while making assumptions, dependencies, context, tools, authority budget, risk budget, compute budget, verification, replanning history, lifecycle states, blocked nodes, dispatch receipts, residual register, non-claims, and dispatch state explicit.

D.6 PlanForge DAG

planforge_dag:
  dag_id: string
  parent_plan: string
  nodes: []
  edges: []
  scheduling_states: []
  capability_tiers: []
  context_requests: []
  adequacy_contracts: []
  quality_predicates: []
  verification_requirements: []
  budget_limits: []
  route_assignments: []
  merge_conditions: []
  assumption_refs: []
  escalation_policy: string
  residuals: []
  cost_quality_ledger: []
  non_claims: []

This record specializes planning into dependency-aware, cost-aware, tier-routed work with explicit scheduling states, adequacy contracts, verification burdens, merge conditions, assumption refs, escalation policy, residuals, cost-quality accounting, and non-claims.

D.7 Context Packet

context_packet:
  task_id: string
  source_handles: []
  summaries: []
  authority_labels: []
  adequacy_state: unknown
  open_uncertainties: []

D.8 Context ABI Record

context_abi_record:
  request_id: string
  task_id: string
  lifecycle_state: materialized
  request_validity: well_formed
  semantic_address: string
  version: string
  mount: string
  mount_scope: []
  snapshot_id: string
  resolution_validity: resolved
  resolver_policy: string
  representation_contract: string
  authority_labels: []
  authority_ceiling: string
  materialization_validity: materialized
  admission_state: admitted
  adequacy_state: adequate
  adequacy_requirement: string
  fault_state: none
  materialization_ref: string
  consumer_policy: string
  support_boundary: string
  lease_expiry: string
  replay_boundary: string
  source_refs: []
  residuals: []
  audit_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record is the stable ABI between planning, durable memory, context compilation, execution, and audit. It distinguishes lifecycle state, request validity, mount scope, resolution validity, resolver policy, materialization validity, admission, adequacy requirement, consumer policy, support boundary, lease expiry, replay boundary, source refs, support-state effect, residuals, and typed faults.

D.9 Context Transaction Record

context_transaction_record:
  transaction_id: string
  transaction_state: committed
  transaction_validity_state: shape_validated
  operation: derive
  snapshot_id: string
  snapshot_boundary: string
  mounts: []
  mount_policy: string
  read_set: []
  write_set: []
  branch_policy: string
  isolation_state: not_tested
  taint_labels: []
  taint_propagation: propagated
  deletion_obligations: []
  rollback_or_deletion_closure: string
  declassification_refs: []
  derivative_refs: []
  contradiction_refs: []
  materialization_state: materializable
  closure_state: satisfied
  faults: []
  context_abi_refs: []
  source_refs: []
  audit_refs: []
  consumer_policy: string
  verification_refs: []
  promotion_blockers: []
  replay_boundary: string
  support_state_effect: record_shape_only
  non_claims: []

This record gives context memory transactional semantics for reads, writes, derivations, branches, commits, transaction state, transaction validity state, snapshot boundary, mount policy, isolation state, deletion closure, taint propagation, declassification references, derivatives, context ABI refs, source refs, materialization state, contradictions, faults, consumer policy, verification refs, promotion blockers, replay boundary, support-state effect, non-claims, and audit.

D.10 Costed Route Record

costed_route_record:
  task_id: string
  route_state: candidate
  task_contract_ref: string
  quality_predicate: string
  authority_ceiling: string
  candidate_routes: []
  selected_route: string
  rejected_lower_cost_routes: []
  verification_result: partial
  outcome_state: not_evaluated
  cost_accounting:
    estimated_tokens: 0
    estimated_time_seconds: 0
    tool_cost_units: 0
  cost_classes: []
  hidden_cost_checks: []
  residual_obligations: []
  fallback_route: string
  promotion_candidate: false
  support_state_effect: record_shape_only
  non_claims: []

This record keeps efficiency claims tied to route state, task contract, route choice, quality predicates, outcome state, cost accounting, cost classes, hidden-cost checks, residual obligations, fallback behavior, support-state effect, and non-claims.

D.11 Resource Budget Record

resource_budget_record:
  budget_id: string
  task_id: string
  value_hypothesis: string
  risk_class: medium
  capacity_pool: string
  budget_state: dispatchable
  cost_estimate: []
  verification_tax: []
  protected_overhead: []
  displaced_costs: []
  quality_predicate: string
  safety_gates: []
  budget_decision: dispatch
  escalation_rule: string
  residuals: []
  evidence_refs: []

This record turns budget pressure into a governed decision. It ties value, risk, capacity, adjudication state, cost, verification tax, protected overhead, displaced costs, quality predicates, safety gates, dispatch or escalation, residuals, and evidence into one auditable artifact.

D.12 Generation Mode Record

generation_mode_record:
  task_id: string
  risk_tier: medium
  latency_budget: string
  compute_budget: string
  memory_budget: string
  context_packet_id: string
  generation_mode: hybrid
  draft_source: string
  verifier: string
  acceptance_predicate: string
  proposed_output_accounting: string
  accepted_output_accounting: string
  wall_clock_time: string
  quality_or_pass_result: string
  repair_or_fallback: string
  promotion_decision: not_evaluated
  measurement_status: not_run
  metric_definitions: []
  evidence_refs: []
  non_claims: []

This record makes fast-generation mode selection auditable. It separates proposed output from accepted output, forces verifier and fallback fields to be named, and allows a route to record not_run without implying a benchmark result.

D.13 Simulation Contract Record

simulation_contract_record:
  simulation_id: string
  claim_id: string
  contract_version: string
  claim_class: scenario_exploration
  scope: string
  fidelity_standard: string
  fidelity_state: declared
  temporal_semantics: string
  input_assumptions: []
  demand_estimate: []
  resource_bill: []
  capacity_bottlenecks: []
  omitted_variables: []
  approximation_liberties: []
  instrumentation_effects: []
  supported_claim_boundary: string
  observed_result_boundary: string
  transfer_decision: not_evaluated
  support_state_effect: record_shape_only
  failure_behavior: string
  residual_risks: []
  evidence_refs: []
  non_claims: []

This record bounds simulation claims by contract version, claim class, scope, fidelity state, temporal semantics, assumptions, demand, resource bill, bottlenecks, omissions, approximations, instrumentation effects, supported and observed-result boundaries, transfer decision, support-state effect, failure behavior, residual risks, evidence references, and non-claims.

D.14 Substrate Adoption Record

substrate_adoption_record:
  substrate_id: string
  substrate_kind: string
  intended_use: string
  expected_advantage: string
  baseline_refs: []
  baseline_obligations: []
  negative_controls: []
  proof_boundary: string
  experiment_requirements: []
  consumer_gate: string
  consumer_policy: string
  axis_ledger:
    - axis: string
      status: unmeasured
      evidence_refs: []
      non_claims: []
  falsification_condition: string
  adoption_state: exploratory
  routing_permission_effect: planning_only
  fallback_substrate: string
  retirement_or_supersession_path: string
  support_state_effect: record_shape_only
  residuals: []
  evidence_refs: []
  non_claims: []

This record keeps optional mathematical, search, cyclic, and representation substrates from becoming core architecture before baselines, baseline obligations, controls, proof boundaries, experiment requirements, consumer gates/policies, axis-specific evidence, routing-permission effects, fallback substrates, falsification and retirement paths, support-state effects, residuals, evidence, and non-claims are visible.

D.15 Cyclic Memory Contract

cyclic_memory_contract:
  contract_id: string
  memory_target: string
  memory_authority_scope: string
  vcm_packet_refs: []
  slot_count: 0
  residue_policy: string
  winding_policy: string
  state_carry_boundary: string
  freshness_window: string
  stale_read_policy: string
  coverage_claim: string
  recurrence_schedule: string
  loop_exit_condition: string
  fallback_attention: string
  admission_state: structural_guardrail
  baseline_refs: []
  probe_requirements: []
  authority_non_widening: string
  residuals: []
  non_claims: []
  evidence_refs: []

This record captures finite cyclic-memory, sparse-coverage, freshness, and recurrence facts, plus VCM chain-of-custody, state-carry boundaries, admission state, baselines, probes, non-widening authority, and residuals, without converting them into retrieval, reasoning, speed, memory, or quality claims.

D.16 Cyclic Mixer Evaluation Record

cyclic_mixer_evaluation_record:
  evaluation_id: string
  evaluation_state: structural_only
  substrate_id: string
  workload_target: string
  structural_invariant: string
  receipt_refs: []
  proof_or_receipt_boundary: string
  claim_partition:
    structural_claims: []
    quality_claims: []
    runtime_claims: []
    memory_claims: []
    deployment_claims: []
  alias_diagnostics: []
  load_diagnostics: []
  parameter_accounting: string
  hardware_kernel_notes: []
  hardware_refusal_path: string
  baseline_refs: []
  baseline_matrix_refs: []
  baseline_symmetry_policy: string
  negative_controls: []
  failure_case_refs: []
  resource_costs: []
  metrics_required: []
  metrics_status: not_run
  tradeoff_packet_ref: string
  consumer_policy: string
  adoption_state: structural_only
  adoption_decision_rationale: string
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []
  evidence_refs: []

This record separates cyclic adapter, RoPE, phase-bank, and mixer structural facts from quality, runtime, memory, context-length, and deployment claims, while requiring evaluation state, workload target, receipt refs, claim partitions, hardware refusal path, baseline matrix refs, baseline symmetry, negative controls, failure-case refs, resource costs, metrics status, tradeoff packet refs, consumer policy, adoption rationale, source refs, support-state effect, and non-claims before adoption.

D.17 Specialist Registry Record

specialist_registry_record:
  specialist_id: string
  registry_epoch: string
  owner: string
  capabilities: []
  authority_envelope: []
  authority_scope: string
  memory_lease_policy: string
  memory_refs: []
  tool_lease_policy: string
  tool_permissions: []
  runtime_tier: string
  cost_profile: string
  readiness_state: canary
  quality_predicates: []
  fallback_routes: []
  residual_refs: []
  evidence_refs: []
  route_limitations: []
  non_claims: []

This record describes a bounded specialist core before it can be routed to. It makes registry epoch, owner, capability, authority envelope, memory/tool lease policy, runtime tier, cost, readiness, quality predicates, fallback, residuals, evidence, route limitations, and non-claims visible.

D.18 Routing Decision Record

routing_decision_record:
  decision_id: string
  task_id: string
  capability_request: string
  candidate_specialists: []
  selected_specialist: string
  rejected_candidates: []
  non_selection_evidence: []
  route_shape: single
  route_receipt: string
  authority_check: passed
  granted_authority_subset: []
  denied_authority: []
  readiness_check: ready
  context_lease: string
  tool_lease: string
  verifier_requirement: string
  budget: string
  expiry: string
  cost_quality_reason: string
  fallback_route: string
  residual_owner: string
  residuals: []
  ledger_refs: []
  non_claims: []

This record turns router selection into an auditable decision. It separates candidate discovery, rejected candidates, non-selection evidence, selection, route shape, route receipt, authority subset, denied authority, leases, verifier requirement, budget, expiry, readiness check, cost-quality reasoning, fallback, residual owner, residuals, ledger references, and non-claims.

D.19 Reflexive Dispatch Trace Record

reflexive_dispatch_trace_record:
  schema_version: asi_stack.reflexive_dispatch_trace.v1
  trace_id: string
  source_id: reflexive_router_whitepaper
  event: {event_id, principal, authenticated, received_at, valid_time, authority_ref, context_handles, resource_budget, literal_payload}
  ingress: {mode, command_authenticated, requested_route, fallback_policy, inference_bypassed}
  proposals: []
  qualification: []
  selection: {kind, selected_proposal_ids, reason, fallback_used, terminal_outcome}
  plan_nodes: []
  effect: {required, state, authority_ref, receipt_ref, residuals}
  result: {result_id, schema_id, route_policy_ref, implementation_refs, input_digest, valid_time, recorded_at, epistemic_state, evidence_refs, verification_state, effect_receipt_ref, dependency_refs, dispatch_provenance_ref, authoritative_artifact_ref}
  chronicle: {record_refs, transaction_time, valid_time, update_state}
  compilation: {state, source_trace_refs, negative_case_refs, differential_test_ref, expiry, decompilation_route}
  metrics: {useful_outcome_state, fast_path, wrong_fast_path, route_regret_state, total_cost_record_ref}
  support_state_effect: none
  non_claims: []

This record joins the paper’s cross-layer ordering without creating a routing super-owner. It keeps authenticated event and command state, route proposals, qualification, selection, plan nodes, effect custody, typed-result provenance, bitemporal Chronicle updates, reflex lifecycle, joint metrics, and non-claims in one replayable design trace. The valid fixture and semantic validator establish only finite record and rejecting-mutation behavior; they do not establish a router, Effect Commit Kernel, Chronicle, compiler, useful outcome, safety, deployment, or support transition.

D.20 Device Resource Card

device_resource_card:
  device_id: string
  owner_principal: string
  guardian_principal: string
  trust_tier: owner_private
  locality_class: home
  compute_profile: string
  storage_profile: string
  network_profile: string
  allowed_data_classes: []
  allowed_tool_classes: []
  secret_handle_capability: handles_only
  operator_presence_mode: phone_approval
  enrollment_status: active
  revocation_path: string

This record describes a hive participant as eligible but bounded. It records identity, trust, locality, resource profile, allowed data/tool classes, secret-handle capability, operator-presence mode, enrollment state, and revocation path without granting open execution authority.

D.21 Hive Job Contract

hive_job_contract:
  job_id: string
  objective: string
  context_packet_refs: []
  data_classes: []
  tool_classes: []
  authority_ceiling: string
  physical_risk_tier: none
  federation_scope: local_only
  budget_limit: string
  energy_policy: string
  deadline: string
  required_approvals: []
  verification_predicate: string
  residual_policy: string
  non_claims: []

This record turns hive work into a bounded job with context refs, data/tool classes, authority ceiling, physical risk, federation scope, budget, energy policy, approvals, verification, residual handling, and non-claims.

D.22 Hive Scheduling Decision

hive_scheduling_decision:
  decision_id: string
  job_id: string
  eligible_nodes: []
  rejected_nodes:
    - node_id: string
      reason: string
  selected_node_id: string
  selected_reason: string
  policy_filter_status: passed
  approval_receipt_refs: []
  data_placement_refs: []
  secret_handle_plan: string
  estimated_cost: string
  estimated_energy: string
  isolation_mode: string
  expiration: string
  evidence_refs: []
  residuals: []
  non_claims: []

This record makes policy-first scheduling inspectable by preserving eligible nodes, rejected nodes with reasons, selected node, approvals, data placement, secret handling, cost/energy estimates, isolation, expiration, evidence, residuals, and non-claims.

D.23 Artifact Steward Charter

artifact_steward_charter:
  artifact_id: string
  steward_id: string
  mission: string
  non_goals: []
  maintainers: []
  governance_model: string
  authority_ceiling: string
  budget_policy: string
  evidence_policy: string
  release_policy: string
  contribution_policy: string
  federation_policy: string
  sunset_criteria: string
  protected_assets: []
  non_claims: []

This record binds a steward to an artifact mission and authority ceiling while keeping budget, evidence, release, contribution, federation, protected-asset, sunset, and non-claim boundaries explicit.

D.24 Project Work Contract

project_work_contract:
  contract_id: string
  artifact_id: string
  objective: string
  context_refs: []
  allowed_files_or_systems: []
  allowed_tools: []
  forbidden_tools: []
  required_outputs: []
  acceptance_tests: []
  review_requirements: []
  evidence_requirements: []
  budget_limit: string
  compute_limits: string
  deadline: string
  rollback_path: string
  dispatch_status: proposed
  non_claims: []

This record lowers project work into a bounded contract with allowed and forbidden surfaces, outputs, tests, review and evidence requirements, budget, compute limits, rollback, dispatch status, and non-claims.

D.25 Contribution Ledger Entry

contribution_ledger_entry:
  entry_id: string
  contributor_id: string
  work_contract_id: string
  artifact_refs: []
  authorship_credit: string
  review_credit: string
  evidence_credit: string
  compensation_ref: string
  reputation_signal: string
  governance_effect: string
  conflict_notes: string
  recorded_by: string
  non_claims: []

This record separates authorship, review, evidence, compensation, reputation, governance effect, conflicts, and non-claims so project credit does not collapse into one gameable surface.

D.26 Treasury Policy Record

treasury_policy_record:
  policy_id: string
  artifact_id: string
  treasury_mode: manual
  autonomous_spend_limit: string
  single_action_limit: string
  recurring_ops_limit: string
  compute_rental_limit: string
  bounty_limit: string
  approval_required_above: string
  protected_spend_classes: []
  emergency_freeze_authorities: []
  audit_requirements: []
  non_claims: []

This record keeps project spending proposal-first by recording mode, spend limits, compute and bounty boundaries, approval thresholds, protected classes, freeze authorities, audit requirements, and non-claims.

D.27 Event Taint Record

event_taint_record:
  event_id: string
  artifact_id: string
  event_source: string
  event_actor: string
  event_surface: issue
  taint_state: untrusted
  trusted_fields: []
  untrusted_fields: []
  forbidden_control_uses: []
  review_requirements: []
  sanitized_artifact_refs: []
  decision_refs: []
  residuals: []
  non_claims: []

This record separates trusted event metadata from untrusted event content so issue bodies, pull requests, comments, workflow events, worker outputs, benchmark artifacts, and external prompts cannot silently become privileged control instructions.

D.28 Steward Action Decision

steward_action_decision:
  decision_id: string
  artifact_id: string
  steward_id: string
  action_type: propose_contract
  authority_basis: string
  inputs: []
  rejected_options: []
  required_approvals: []
  approval_refs: []
  evidence_refs: []
  affected_artifacts: []
  residuals: []
  execution_status: proposed
  non_claims: []

This record explains what a steward proposed, approved, executed, blocked, escalated, or rejected, and preserves authority basis, approvals, evidence, affected artifacts, residuals, and non-claims.

D.29 Sunset Review Record

sunset_review_record:
  review_id: string
  artifact_id: string
  value_signal: string
  active_users_status: string
  active_maintainers_status: string
  funds_status: string
  open_risks: []
  dependencies: []
  sunset_recommendation: continue
  archival_plan: string
  fork_or_transfer_path: string
  appeal_path: string
  decision_status: proposed
  evidence_refs: []
  non_claims: []

This record makes project continuation, freeze, transfer, archive, split, replacement, or later review a documented decision rather than an artifact drifting indefinitely.

D.30 Readiness Gate Record

readiness_gate_record:
  gate_id: string
  target_id: string
  target_kind: specialist
  field_id: string
  current_state: shadow
  candidate_state: canary
  workload_family: string
  freshness_window: string
  evidence_state: fixture_validated
  gate_evidence: []
  floor_evidence: []
  frontier_evidence: []
  regression_results: []
  residual_escrow: []
  inherited_residuals: []
  authority_scope: string
  promotion_blockers: []
  quarantine_conditions: []
  allowed_routes: []
  blocked_routes: []
  diagnostic_permissions: []
  fallback_path: string
  expiry: string
  decision: canary
  closure_conditions: []
  review_refs: []
  next_review_trigger: string
  non_claims: []

This record governs promotion, quarantine, split, merge, retirement, and retraining decisions by tying lifecycle state to field identity, workload family, freshness, evidence state, floor/frontier evidence, regressions, residual escrow, inherited residuals, authority, route permissions, diagnostic permissions, blockers, quarantine conditions, fallback, expiry, closure conditions, review, stale-gate triggers, and non-claims.

D.31 Benchmark Ratchet Record

benchmark_ratchet_record:
  ratchet_id: string
  capability_ref: string
  benchmark_ref: string
  benchmark_state: proposed
  run_refs: []
  baseline_refs: []
  mastery_threshold: string
  saturation_state: unknown
  residual_escrow: []
  regression_refs: []
  anti_goodhart_checks: []
  promotion_decision: block
  support_state_effect: string
  negative_results: []

This record turns benchmark pressure into an evidence-gated decision. It preserves baselines, run records, saturation state, residuals, regressions, anti-Goodhart checks, promotion decisions, support-state effects, and negative results.

D.32 Policy Optimization Record

policy_optimization_record:
  update_id: string
  update_state: proposed
  target_layer: router
  policy_ref: string
  policy_delta_summary: string
  training_mode: not_run
  feedback_source: string
  feedback_admissibility: not_reviewed
  reward_or_preference_signal: string
  reward_boundary: string
  verifier_refs: []
  reward_hacking_probes: []
  update_constraint: string
  drift_bound: string
  holdout_refs: []
  regression_refs: []
  evaluation_refs: []
  governance_gate_refs: []
  authority_effect: not_evaluated
  rollback_plan: string
  monitor_window: string
  evidence_packet_refs: []
  deployment_scope: string
  promotion_decision: not_evaluated
  measurement_status: not_run
  support_state_effect: record_shape_only
  residuals: []
  non_claims: []

This record treats policy optimization as a behavior-change lease. It separates target layer, policy delta, feedback admissibility, reward boundary, probes, holdouts, regressions, governance gates, authority effect, rollback, monitoring, evidence packets, deployment scope, support-state effect, residuals, and non-claims before any update can be promoted.

D.33 MoECOT Orchestration Record

moecot_orchestration_record:
  run_id: string
  runtime_packet_state: design_example
  command_ref: string
  orchestrator_id: string
  route_head: string
  specialist_cores: []
  control_plane_gates: []
  route_authority_ledger: []
  ledger_refs: []
  readiness_gate_refs: []
  replay_refs: []
  denied_routes: []
  failed_gates: []
  missing_replay_refs: []
  handoff_refs: []
  promotion_blockers: []
  residuals: []
  source_reported_fields: []
  locally_reproduced_fields: []
  externally_corroborated_fields: []
  blocked_fields: []
  source_claim_state: argument
  non_claims: []

This record gives the MoECOT implementation-reference lane a conservative runtime crosswalk: packet state, command, compact orchestrator, route head, specialist cores, control-plane gates, route authority ledger, ledgers, readiness gates, replay refs, denied routes, failed gates, missing replay refs, handoff, blockers, residuals, evidence-state field partitions, source-claim state, and non-claims.

D.34 Context Adequacy Record

context_adequacy_record:
  adequacy_id: string
  target_claim_id: string
  claim_scope: string
  context_packet_ref: string
  context_scope: string
  risk_tier: high
  semantic_units: []
  compression_path: []
  verification_mode: pairwise_grinding
  adequacy_state: local_check
  residual_risks: []
  negative_evidence: []
  required_escalation: []
  verification_artifact_refs: []
  audit_refs: []
  support_state_effect: blocks_promotion
  non_claims: []

This record distinguishes context admission from context adequacy. It scopes the claim, context packet, verification mode, risk tier, negative evidence, escalation requirement, verification artifacts, audit refs, and support-state effect so a packet usable for drafting or local checking cannot be reused as support-state promotion evidence.

D.35 Semantic Atom

semantic_atom:
  atom_id: string
  atom_state: proposed
  source_plan_ref: string
  intent: string
  obligation_refs: []
  obligation_status: []
  inputs: []
  outputs: []
  constraints: []
  dependencies: []
  assumptions: []
  authority_required: []
  ir_validity_state: not_checked
  validator: string
  validator_status: not_run
  target: string
  lowering_state: not_lowered
  target_artifact_ref: string
  lowering_receipt: string
  repair_scope: same_atom
  repair_ledger_refs: []
  source_refs: []
  support_state_effect: record_shape_only
  residuals: []
  non_claims: []

This record is the small unit of cognitive compilation: one preserved intent fragment with atom state, source-plan refs, obligation refs/status, inputs, outputs, constraints, dependencies, assumptions, authority requirements, IR validity state, validator status, lowering state, target artifact, lowering receipt, bounded repair target, repair-ledger refs, source refs, support-state effect, residuals, and non-claims.

D.36 Semantic Node Record

semantic_node_record:
  node_id: string
  concept_label: string
  provenance_refs: []
  parent_refs: []
  child_refs: []
  relation_refs: []
  tokenization_contract: string
  grounding_state: partially_grounded
  version: string
  supersedes: []
  residual_uncertainty: []
  permitted_uses: []
  evaluation_refs: []

This record keeps explicit semantic representations grounded, versioned, and bounded by permitted uses. It separates semantic structure from proof of utility or lossless adequacy.

D.37 Semantic Page Certificate

semantic_page_certificate:
  page_id: string
  cell_type: summary
  source_bindings: []
  derived_from: []
  transaction_refs: []
  artifact_refs: []
  representation_kind: string
  loss_contract: string
  omissions: []
  authority_ceiling: string
  permitted_uses: []
  validity_window: string
  verification_state: adequate_for_drafting
  revocation_state: active
  residual_risks: []
  non_claims: []

This record keeps derived context cells honest by preserving provenance, transaction links, artifact links, representation loss, omissions, authority ceiling, permitted uses, validity, verification state, revocation state, residual risks, and non-claims.

D.38 Compression Receipt

compression_receipt:
  artifact_id: string
  receipt_state: candidate
  reconstruction_contract: string
  public_law_family: string
  seed: string
  search_bound: string
  generated_regions: []
  verification_result: partial
  repair_residual: string
  fallback_threshold: string
  interface_costs: []
  consumer_policy: string
  use_permissions: []
  proxy_rate_status: not_run
  final_serialization_status: not_run
  rate_accounting:
    proxy_bits: 0
    final_bits: 0
    literal_bits: 0
    proxy_gap: 0
  support_state_effect: record_shape_only
  evidence_refs: []
  non_claims: []

This record keeps generate-verify-repair compression honest by separating receipt state, search bounds, proxy compression claims, final serialized size, repair burden, interface costs, consumer policy, use permissions, support-state effect, evidence refs, and explicit non-claims.

D.39 Compact Generative Record

compact_generative_record:
  system_id: string
  target_system: string
  compact_seed: string
  rule_system: string
  memory_state: string
  generation_status: not_run
  residual_channel: []
  correction_mechanism: string
  verification_contract: string
  verification_status: not_run
  verifier_independence: string
  governance_interface: string
  authority_boundary: string
  use_envelope: []
  burden_ledger: []
  cost_accounting: []
  generative_leverage: string
  hidden_complexity_risks: []
  fallback_path: string
  fallback_status: not_tested
  residual_burden_status: unmeasured
  promotion_state: conceptual
  promotion_blockers: []
  retirement_condition: string
  support_state_effect: record_shape_only
  source_refs: []
  evidence_refs: []
  non_claims: []

This record describes a compact generative core without hiding the work it exports to generation, correction, verification, governance, fallback, human review, residual correction, authority review, promotion decisions, or retirement. It keeps generation status, verification status, fallback status, residual-burden status, promotion blockers, source refs, support-state effect, and non-claims visible before compactness can be treated as utility.

D.40 Compressed Artifact Record

compressed_artifact_record:
  artifact_id: string
  source_artifact: string
  task_family: string
  access_pattern: semantic_preview
  admission_state: preview_only
  compression_method: string
  reconstruction_contract: string
  declared_use_envelope: []
  ratio_claim_state: not_measured
  codec_parameters: []
  metadata_costs: []
  residual_coding: []
  probe_plan: []
  fallback_artifact: string
  fallback_trigger: string
  decode_determinism: string
  exact_replay_status: not_claimed
  consumer_policy: string
  utility_tests: []
  support_state_effect: record_shape_only
  evidence_refs: []
  non_claims: []

This record separates representation, reconstruction, compression, exact replay, access-pattern, and utility claims for compressed artifacts, while preserving metadata costs, residuals, probes, fallback triggers, decode assumptions, consumer policy, support-state effect, evidence refs, and explicit non-claims.

D.41 Authority Use Receipt

authority_use_receipt:
  handle_id: string
  principal: string
  purpose: string
  destination: string
  allowed_action: string
  clearance: string
  approval_record: string
  scif_lifecycle: []
  sanitized_output: string
  residual_leak_risk: []
  revocation_path: string

This record captures handle-mediated authority use for Digital SCIF workflows. It is meant to support least-privilege review, audit, revocation, and leak-risk accounting without exposing secret bytes in the public book.

D.42 Authority Transition Record

authority_transition_record:
  transition_id: string
  principal: string
  source_layer: string
  target_boundary: string
  requested_operation: string
  permission_class: write
  grant_lifecycle_state: receipted
  caller_ceiling: string
  authority_ceiling: string
  target_required_authority: string
  grant_id: string
  delegation_chain: []
  expiry_or_review: string
  revocation_epoch: string
  decision: allow
  denial_reason: string
  effect_receipt: string
  audit_refs: []
  non_claims: []

This record makes boundary crossings explicit. It distinguishes a request from an authorization and gives permission class, grant lifecycle state, caller ceiling, target-required authority, delegation chain, expiry/review condition, denials, grants, effect receipts, audit references, and non-claims a durable shape.

D.42.1 Governed Transition Calculus projection

The shared transition kernel is not a second universal wire format. Each domain record projects the same nine concerns into fields it can actually enforce or inspect:

governed_transition_projection:
  transition_id: string
  source_identity_refs: []
  target_identity_refs: []
  authority_ref: string
  obligation_refs: []
  evidence_refs: []
  residual_refs: []
  consumer_refs: []
  expiry_or_revocation_ref: string
  rollback_compensation_or_retirement_ref: string
  domain_record_type: string
  maximum_inference: record_shape_only
  non_claims: []

The projection is valid only when every reference resolves to the version used by the domain decision and the domain record states any stricter required fields. Empty evidence, residual, consumer, or closure references cannot be silently interpreted as success. A shape-valid projection establishes only joinability and missingness visibility; it does not establish premise truth, runtime enforcement, outcome quality, safety, or readiness.

D.43 Failure Boundary Map

failure_boundary_map:
  failure_id: string
  failure_class: context_pollution
  layer: string
  affected_contract_refs: []
  boundary_event_state: blocked
  severity: medium
  reversibility: reversible
  recurrence_count: 1
  trigger: string
  protected_invariant: string
  detection_route: string
  containment_action: string
  evidence_record: string
  receipt_refs: []
  downstream_owner: string
  promotion_blocker: string
  escape_path: string
  normalization_guard: string
  learning_path: string
  source_refs: []
  support_state_effect: record_shape_only
  residual_risk: []
  non_claims: []

This record maps a named failure to the boundary that should detect, contain, preserve evidence, prevent normalization, and feed learning obligations from blocked failures, near misses, repeated failures, or realized failures. It keeps failure class, affected contracts, promotion blockers, source refs, support-state effect, and non-claims visible so a failure taxonomy cannot become a support-state promotion by implication.

D.44 Constitutional Predicate Record

constitutional_predicate_record:
  predicate_id: string
  normative_source: string
  commitment: string
  operational_test: string
  protected_scope: []
  translation_status: partial
  conflict_behavior: string
  uncertainty: []
  review_route: string
  self_modification_rule: string
  migration_policy: string
  non_claims: []

This record keeps normative commitments tied to translation status, protected scope, conflict behavior, uncertainty, self-modification rules, and migration policy.

D.45 Agency Rights Checklist

agency_rights_checklist:
  plan_id: string
  affected_parties: []
  delegation_scope: string
  manipulation_risk: string
  reversibility: string
  material_usability: string
  timing_requirement: string
  review_channel: string
  appeal_channel: string
  shutdown_or_rollback_path: string
  accountable_principal: string
  residual_dependency_risk: []
  denial_or_degradation_reason: string
  approval_required: false

This record checks whether high-impact plans preserve materially usable refusal, review, appeal, rollback, and accountability pathways before the relevant effect becomes irreversible.

D.46 Value Conflict Record

value_conflict_record:
  conflict_id: string
  value_axes: []
  stakeholders: []
  stakes: string
  reversibility: string
  evidence_required: []
  review_route: string
  decision_state: bounded_decision
  decision: string
  authority_effect: string
  dissent_payload: []
  residual_uncertainty: []
  expiry_or_revisit_condition: string

This record makes contested values visible instead of hiding them inside a scalar objective or fluent recommendation. It records the decision state, authority effect, preserved dissent, residual uncertainty, and revisit condition.

D.47 Governance Right Record

governance_right_record:
  right_id: string
  right_type: audit
  request_state: granted
  holder: string
  scope: string
  required_artifacts: []
  material_available: []
  material_withheld: []
  safety_constraints: []
  access_path: string
  denial_or_redaction_reason: string
  appeal_path: string
  expiry_or_revisit: string
  challenged_party_independence: string
  preservation_rule: string
  preservation_obligation: string
  receipt_refs: []
  test_hook: string
  non_claims: []

This record turns fork, exit, audit, appeal, and dissent into technical rights with request states, artifacts, available and withheld material, access paths, appeal paths, independence notes, preservation obligations, receipt refs, and non-claims.

D.48 Stable Capability Field

stable_capability_field:
  field_id: string
  field_version: string
  owner: string
  semantic_boundary: string
  interface_contract: string
  authority_ceiling: string
  implementations: []
  lifecycle_state: canary
  qualification_context: string
  qualification_status: evidence_mapped
  qualification_lease:
    epoch: string
    expires_on: string
    review_triggers: []
  qualification_lease_status: fixture_only
  qualification_predicates: []
  evaluator_policy: string
  evaluator_independence: string
  route_validity: residual
  route_scope: string
  route_permission_effect: canary_only
  consumer_policy: string
  evidence_refs: []
  readiness_gate_refs: []
  field_history_refs: []
  incident_refs: []
  review_triggers: []
  state_migration: string
  regression_suite: []
  rollback_plan: string
  rollback_obligations: []
  default_route_blockers: []
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record separates a durable semantic capability boundary from replaceable implementations, while keeping field version, owner, authority, qualification status, qualification lease/status, evaluator policy, evaluator independence, route validity/scope, route permission effect, consumer policy, readiness gates, field history refs, source refs, support-state effect, evidence, incidents, review triggers, regression, migration, rollback obligations, default-route blockers, and non-claims visible.

D.49 Replacement Transaction

replacement_transaction:
  transaction_id: string
  transaction_state: canary
  field_id: string
  prior_implementation: string
  candidate_implementation: string
  identity_preservation: string
  precheck_results: []
  qualification_evidence: []
  regression_results: []
  authority_check: string
  evaluator_independence: string
  residual_escrow: []
  rollback_plan: string
  rollback_receipt:
    prior_artifact: string
    state_migration_status: string
    reversible_fields: []
    irreversible_effects: []
    dry_run_status: not_run
    trigger_conditions: []
    owner: string
  approval_record: string
  canary_scope: string
  monitor_window: string
  monitor_status: not_started
  decision: canary
  promotion_blockers: []
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record turns capability replacement into an evidence-gated transaction with transaction state, identity preservation, prior state, candidate state, regressions, evaluator independence, residuals, rollback receipt, approval, canary scope, monitoring status, promotion blockers, source refs, support-state effect, decision, and non-claims attached.

D.50 Self-Improvement Transition

self_improvement_transition:
  transition_id: string
  trigger_residual: string
  field_id: string
  proposal: string
  cheaper_interventions_tried: []
  protected_invariants: []
  boundary_delta_review: string
  verification_budget_preservation: string
  gate_freshness: string
  evaluator_independence: string
  replacement_transaction: string
  governance_approval: string
  monitor_window: string
  rollback_path: string
  outcome_state: canary

This record keeps recursive self-improvement bounded by explicit residuals, protected invariants, boundary-delta review, verification-budget preservation, gate freshness, evaluator independence, governance approval, monitoring, and rollback.

D.51 Typed Job

typed_job:
  job_id: string
  contract_id: string
  job_type: string
  lifecycle_state: dispatchable
  runtime_adapter: string
  inputs: []
  outputs: []
  permissions: []
  approval_state: not_required
  failure_behavior: []
  audit_events: []
  replay_status: not_run

This record is the executable unit of the Labor OS. It carries contract, type, lifecycle, adapter, permissions, approval state, failure behavior, audit events, and replay status.

D.52 Artifact Graph Record

artifact_graph_record:
  artifact_id: string
  artifact_type: string
  parent_job: string
  source_refs: []
  context_refs: []
  context_transaction_refs: []
  semantic_certificate_refs: []
  tool_refs: []
  claim_refs: []
  test_refs: []
  audit_events: []
  replay_metadata: string
  replay_grade: not_run
  environment_assumptions: []
  provenance_status: partial
  replay_limits: []
  evidence_gate: string
  residuals: []
  non_claims: []

This record turns outputs into durable artifacts with provenance, context-transaction links, semantic-certificate links, audit, replay grade, claim/test links, evidence gate, residuals, and non-claims.

D.53 Runtime Adapter Invocation

runtime_adapter_invocation:
  invocation_id: string
  invocation_state: requested
  job_id: string
  adapter_id: string
  target_type: string
  capability: string
  permission_required: string
  sandbox_mode: string
  impact_class: low_impact
  risk_tier: low
  approval_required: false
  approval_record: string
  approval_scope: string
  approval_expiry: string
  authority_handle: string
  inputs: []
  effect_lease: string
  effect_receipt: string
  pre_state_ref: string
  post_state_ref: string
  external_side_effects: []
  verification_refs: []
  rollback_handle: string
  irreversible_residuals: []
  incident_refs: []
  audit_refs: []
  residuals: []
  support_state_effect: record_shape_only
  non_claims: []

This record is the effects boundary: it records adapter capability, invocation state, permissions, sandboxing, impact/risk class, approval scope and expiry, authority handles, inputs, effect lease, pre/post state refs, external side effects, verification refs, rollback, irreversible residuals, incident/audit refs, support-state effect, residuals, and non-claims.

D.54 Procedural Tool Record

procedural_tool_record:
  tool_id: string
  source_traces: []
  invariant_structure: string
  parameters: []
  preconditions: []
  postconditions: []
  verification_result: not_run
  risk_tier: string
  runtime_tier: string
  monitoring_plan: string
  residuals: []
  regressions: []
  lifecycle_state: candidate
  retirement_criteria: []

This record governs cognitive loop closure from repeated traces into parameterized tools, keeping preconditions, postconditions, verification, risk, monitoring, regressions, lifecycle, and retirement visible.

D.55 Claim Record

claim_record:
  claim_id: string
  text: string
  claim_scope: string
  claim_label: Design rationale
  support_state: argument
  lifecycle_state: recorded
  source_mapping_status: none
  source_mapping_refs: []
  evidence_readiness_state: shape_validated
  source_handles: []
  surface_refs: []
  tests: []
  uncertainty: string
  evidence_bundle:
    source_hash: string
    code_revision: string
    environment_manifest: string
    baseline: string
    test_command: string
    metrics: {}
    raw_logs: []
    negative_results: []
    ablations: []
    failure_reproduction: string
    artifacts: []
    provenance: string
    conclusion: string
    limitations: string
    release_notes: string
  contradictions: []
  contradiction_state: none
  review_status: open
  revision_history_refs: []
  required_next_evidence: []
  promotion_blockers: []
  support_state_effect: record_shape_only
  non_claims: []

Claim labels and support states are separate. A claim can be a Hypothesized claim with argument support, or a Measured claim with synthetic-test-backed support after a recorded test run. Claim scope, lifecycle state, source-mapping status, source-mapping refs, evidence-readiness state, surface refs, contradiction state, revision history, required next evidence, promotion blockers, support-state effect, and non-claims keep repeated prose from laundering confidence. Conversation-mined author intent can explain lineage and drafting intent, but it is not by itself source-derived evidence.

D.56 Evidence Transition Record

evidence_transition_record:
  transition_id: string
  claim_id: string
  claim_surface_refs: []
  claim_record_refs: []
  old_support_state: argument
  new_support_state: argument
  transition_effect: no_change
  transition_validity_state: shape_validated
  scope_boundary: string
  evidence_roles: []
  transition_reason: string
  required_artifacts: []
  artifact_refs: []
  evidence_packet_refs: []
  source_mapping_refs: []
  verification_command: string
  verification_result: not_run
  negative_results: []
  negative_evidence_refs: []
  downgrade_triggers: []
  promotion_burden: string
  limitations: []
  review_status: open
  reviewer_refs: []
  reviewer_independence: string
  acceptance_blockers: []
  changelog_ref: string
  support_state_effect: record_shape_only
  non_claims: []

This record makes support-state movement reviewable. It names the claim, claim surface refs, claim record refs, prior and candidate support states, transition effect, transition validity state, scope boundary, evidence roles, required artifacts, artifact refs, evidence packets, source mappings, verifier command/result, negative results, negative evidence refs, downgrade triggers, promotion burden, limitations, reviewer refs, reviewer independence, acceptance blockers, changelog ref, support-state effect, non-claims, and review state before a claim can move.

D.57 Belief Revision Record

belief_revision_record:
  revision_id: string
  claim_id: string
  revision_action: no_change
  prior_support_state: unsupported
  new_support_state: argument
  evidence_refs: []
  contradiction_refs: []
  defeaters: []
  residual_refs: []
  revision_reason: string
  uncertainty: string
  review_status: open
  history_refs: []
  changed_surface_refs: []
  non_overwrite_attestation: string
  ledger_effect: string
  non_claims: []

This record preserves support-state changes, revision action, evidence, contradictions, defeaters, residual refs, uncertainty, changed surfaces, review state, non-overwrite attestation, ledger effect, revision history, and non-claims instead of overwriting prior belief state.

D.58 Proof-Carrying Claim

proof_carrying_claim:
  proof_claim_id: string
  claim_id: string
  claim_scope: string
  required_tier: procedure
  justification_type: schema_fixture
  interpretation_mapping: string
  interpretation_confidence: medium
  justification_artifact: string
  artifact_validity_state: not_checked
  semantic_adequacy: narrow
  verifier: string
  verifier_result: not_run
  verifier_artifact_refs: []
  failed_attempt_refs: []
  formal_scope: string
  limitations: []
  consumer_requirements: []
  downgrade_rule: string
  claim_validity_effect: no_change
  residual_route: string
  tribunal_ref: string
  ledger_update: string
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record makes proof or justification claims tiered and auditable, including claim scope, justification type, interpretation mapping and confidence, artifact validity state, semantic adequacy, verifier result, verifier artifacts, failed attempts, formal scope, limitations, consumer requirements, downgrade behavior, claim-validity effect, source refs, support-state effect, residual route, ledger impact, and non-claims.

D.59 Proof Contract Receipt Record

proof_contract_receipt_record:
  receipt_id: string
  receipt_state: source_reported
  source_project: string
  contract_family: string
  engineering_object: string
  finite_model: string
  proof_boundary: string
  theorem_refs: []
  proof_status: external_source_reported
  source_version: string
  content_fingerprint: string
  fingerprint_status: not_computed
  deterministic_fields: []
  verifier_command: string
  verifier_result: not_run
  resolver_status: source_reported
  replay_status: not_run
  consumer_gate:
    consumer_id: string
    allowed_uses: []
    blocked_uses: []
    required_downstream_evidence: []
  consumer_state: structural_only
  staleness_policy: string
  failure_behavior: string
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []
  evidence_refs: []

This record packages theorem-linked structural facts as receipts with receipt state, finite-model scope, proof boundary, theorem references, proof status, fingerprints and fingerprint status, deterministic fields, resolver/replay status, consumer permissions and consumer state, staleness policy, failure behavior, source refs, support-state effect, evidence references, and explicit non-claims. It records receipt shape only; it does not imply external theorem replay, model-quality evidence, runtime evidence, or substrate adoption.

D.60 Proof Target Record

proof_target_record:
  proof_id: string
  chapter_id: string
  lean_tag: string
  target_kind: schema_contract
  artifact_lane: schema
  formal_target: string
  artifact_refs: []
  verifier_command: string
  verifier_result: not_run
  support_state_effect: string
  consumer_requirements: []
  semantic_adequacy_review:
    status: planned
    review_note: string
  limitations: []
  non_claims: []

This record separates Lean proofs, executable specs, schema contracts, process contracts, and research targets. It keeps artifact lane, verifier status, artifact references, support-state impact, consumer requirements, semantic adequacy status, limitations, and non-claims visible before prose can imply formal support.

D.61 Reference Trace Record

reference_trace_record:
  trace_id: string
  trace_state: fixture_validated
  execution_boundary: fixture_only
  intent_ref: string
  parent_artifact_refs: []
  authority_chain: []
  authority_deltas: []
  layer_handoffs: []
  artifacts: []
  evidence_updates: []
  evidence_deltas: []
  residual_deltas: []
  stop_conditions: []
  missing_contracts: []
  validation_commands: []
  promotion_blockers: []
  source_refs: []
  support_state_effect: record_shape_only
  non_claims: []

This record makes an end-to-end architecture trace inspectable without claiming the full runtime exists. It records trace state, execution boundary, intent, parent artifacts, authority chain and deltas, layer handoffs, artifacts, evidence updates and deltas, residual deltas, stop conditions, missing contracts, validation commands, promotion blockers, source refs, support-state effect, and non-claims.

D.62 Tribunal Review Record

tribunal_review_record:
  review_id: string
  target_ref: string
  review_state: actions_recorded
  risk_class: medium
  dossier_boundary: string
  dossier_refs: []
  reviewer_independence: string
  reviewer_roles: []
  adversarial_probes: []
  cycle_cap: string
  prior_review_refs: []
  unchanged_evidence_guard: string
  retrieval_expansion_policy: string
  findings: []
  evidence_refs: []
  dissent: []
  unresolved_issues: []
  verdict: revise
  required_actions: []
  constraint_effects: []
  human_adjudication: string
  non_claims: []

This record keeps adversarial review bounded, reproducible, and actionable through review state, dossier boundary, reviewer independence note, dossier refs, reviewer roles, probes, cycle cap, repeated-review guard, retrieval-expansion policy, findings, evidence refs, dissent, unresolved issues, verdicts, required actions, constraint effects, adjudication state, and non-claims.

D.63 Prototype Phase Record

prototype_phase_record:
  phase_id: string
  phase_name: string
  unlocks: []
  required_artifacts: []
  acceptance_gates: []
  blocked_by: []
  validation_commands: []
  evidence_refs: []
  non_claims: []
  status: proposed

This record keeps the prototype roadmap evidence-aware by linking each phase to deliverables, acceptance gates, blockers, validation commands, evidence references, non-claims, and lifecycle status.

D.64 Living Book Release Record

living_book_release_record:
  release_id: string
  release_state: local_validated
  source_commit: string
  audience_profiles: []
  canonical_scope: string
  rendered_site: string
  scaffold_sync: string
  proof_manifest_sync: string
  validation_commands: []
  validation_status: pass
  changelog_refs: []
  public_url: string
  derived_artifacts: []
  support_state_effect: release_hygiene_only
  residuals: []
  non_claims: []

This record separates publication hygiene from claim truth and live publication from downstream human-consumption artifacts. It records release state, commit, audience profiles, canonical scope, render target, scaffold/proof sync, validation commands/status, changelog refs, public URL, derived-artifact status, support-state effect, residuals, and non-claims for a living-book release.

D.65 Edition Release Record

edition_release_record:
  record_type: edition_release
  release_id: string
  major_version: string
  source_commit: string
  source_tag: string
  edition_profile: reader_release
  primary_audiences: []
  derivation_source: string
  artifact_formats: []
  validation_commands: []
  validation_status: pending
  review_status:
    reader_continuity_review: not_started
    source_scaffold_removed: not_checked
    audio_script_review: not_required
    notes: string
  reader_manuscript:
    source_dir: string
    status: generated
    review_notes: string
  audio_package:
    script_dir: string
    status: not_required
    review_notes: string
  companion_material:
    path_or_uri: string
    status: generated
    review_notes: string
  human_consumption_gate:
    reader_spine_review: not_started
    ebook_layout_review: not_started
    diagram_image_review: not_started
    bedtime_readability_review: not_started
    companion_notes_status: not_started
    notes: string
  format_probe_closure:
    status: automated_probe_passed_release_blocked
    curated_format_probe_manifest: string
    pdf_page_review_manifest: string
    pdf_page_review_rows: integer
    release_boundary: string
  audiobook_gate:
    script_review: not_required
    spoken_treatment_review: not_required
    chapter_marker_review: not_required
    audio_spot_check: not_required
    embedded_epub_check: not_required
    status: not_required
    notes: string
  release_notes: string
  residuals: []
  non_claims: []

This record separates future major-version edition accountability from live-book publication hygiene. It records which research, reader, or audio profile was derived from which tagged live-book state, which artifact formats were actually rendered or generated, which human-consumption and audiobook review gates ran, and which residuals and non-claims remain. It does not claim that EPUB, PDF, DOCX, MP3, M4B, or audio-embedded EPUB artifacts exist unless the release record lists those artifacts with successful status.

D.66 Theseus Report Crosswalk Record

theseus_report_crosswalk_record:
  crosswalk_id: string
  stack_layer: string
  source_reports: []
  config_or_tool_refs: []
  gate_refs: []
  residual_refs: []
  public_claim_boundary: string
  verification_status: source_note_only
  missing_artifacts: []
  non_claims: []
  evidence_refs: []

This record keeps Project Theseus references public-safe by separating source notes, reports, configs, gates, residuals, public claim boundaries, verification status, missing artifacts, non-claims, and evidence refs.

D.67 Theseus Report

theseus_report:
  schema_version: string
  report_id: string
  trace_class: architecture_gate
  source_project:
    name: string
    repository_url: string
    local_checkout_ref: string
    git_commit: string
    worktree_state: dirty_at_import_review
  tool:
    name: string
    version_ref: string
    replay_command_if_clean: string
  input_class: string
  source_artifact:
    source_path: string
    source_artifact_sha256: string
    source_artifact_status: sanitized_static_import
    sanitization_summary: string
  public_safety:
    redaction_state: public_safe_static_summary
    private_payload_copied: false
    redactions: []
    public_safety_reviewer: string
  generated_artifact_refs: []
  gate_decisions: []
  decision_summary:
    status: string
    ready_for_heavy_training: true
    gate_count: 14
    passed_count: 14
    external_inference_calls: 0
  failed_attempts: []
  residuals: []
  replay:
    mode: digest_verification
    command: python3 scripts/validate_theseus_report.py
    ci_verifiable: true
    verifier: string
    expected_source_artifact_sha256: string
  connected_chapter_ids: []
  evidence_lane_refs: []
  support_state_effect: no_chapter_core_claim_promotion
  claim_boundaries: []
  non_claims: []

This record imports a public-safe Project Theseus report summary only when it names provenance, digest, redaction boundaries, gate decisions, failed attempts, residuals, replay or digest verification, connected chapters, support-state effect, claim boundaries, and non-claims. The current fixture validates one static architecture-gate import; it does not live-replay Theseus or promote a chapter core claim.

D.68 Research Backlog Record

research_backlog_record:
  backlog_id: string
  triage_state: mapped
  source_or_gap: string
  access_state: source_note_available
  source_storage_policy: repo_public_note_only
  public_safety_state: public_safe
  assigned_chapters: []
  chapter_action_policy: string
  chapter_decision_refs: []
  deduplication_state: overlaps_existing_chapter
  merge_or_split_policy: string
  boundary_decision_rationale: string
  source_note_state: available
  claim_mapping_state: partial
  passage_review_state: partial
  external_literature_need: []
  proof_or_test_backlog: []
  evidence_transition_precondition: []
  required_before_drafting: []
  insertion_decision: update_existing_chapter
  source_refs: []
  support_state_effect: backlog_only
  promotion_blockers: []
  residuals: []
  next_action: string
  non_claims: []

This record turns future-source and missing-evidence management into a reviewable backlog item. It records triage state, access state, source storage policy, public-safety state, chapter action policy, chapter-decision refs, deduplication state, merge/split policy, boundary-decision rationale, source-note state, claim mapping, passage-level review state, external literature work, proof/test backlog, evidence-transition preconditions, required pre-drafting work, insertion decision, source refs, support-state effect, promotion blockers, residuals, next action, and non-claims.

D.69 New Paper Triage Scenario

new_paper_triage_scenario:
  scenario_id: string
  scenario_scope: string
  case_validity_state: fixture_only
  cases:
    - case_id: string
      intake_kind: new_source
      access_state: available
      source_storage_policy: external_url_only
      public_safety_state: public_safe
      deduplication_state: overlaps_existing_chapter
      candidate_decision: update_existing_chapter
      chapter_manifest_action: add_source_to_existing_chapter
      existing_chapter_id: string
      proposed_chapter_id: not_applicable
      decision_rationale: string
      required_before_drafting: []
      evidence_transition_preconditions: []
      promotion_blockers: []
      non_claims: []
  validation_boundary: string
  support_state_effect: record_shape_only
  non_claims: []

This synthetic fixture suite tests the decision surface for future source intake. It covers update-existing, propose-new-chapter, defer-external-literature, and reject-duplicate decisions with storage/public-safety policy, deduplication state, manifest action, pre-drafting requirements, evidence-transition preconditions, promotion blockers, and non-claims. It validates triage shape only; it does not evaluate any real paper or edit the chapter manifest.