Merge pull request #520 from AssetOverflow/codex/amr-decision-substrate

[codex] add AMR decision substrate demo

demos/amr_decision_substrate/.gitignore

@@ -0,0 +1 @@
+out/

demos/amr_decision_substrate/README.md

@@ -0,0 +1,49 @@
+# AMR Decision Substrate Demo
+
+This demo is robotics-adjacent, not a robotics stack.
+
+It uses simulated abstract situation records to show CORE as a decision and
+accountability substrate around a bounded AMR-style proceed / stop / refuse
+choice. The inputs are not camera, LiDAR, odometry, SLAM, localization, motor,
+or fleet-control data.
+
+Claims-ledger framing: this is a preparation artifact over simulated records.
+It is not deployment readiness, not perception, not motion planning, and not
+motor control. The demo proves only its local trace/refusal/replay surface over
+these fixtures. It does not imply a CORE expert domain, a robotics capability
+claim, or working vision/motor. Per the ledger, text is the active capability;
+audio is substrate with the gate CLOSED; vision and motor are proposed only.
+
+What is real CORE here:
+
+- `ChatRuntime`
+- `CognitiveTurnPipeline.run(...)`
+- recognition-side typed refusal propagation
+- `CognitiveTurnResult.trace_hash`
+- CORE Trace Protocol canonical JSONL events
+- `verify_chain(...)` replay validation
+
+What is simulated:
+
+- the AMR situation record
+- the tiny policy reducer that maps already-abstracted facts to
+  `PROCEED`, `STOP`, or `REFUSE`
+
+The demo refuses under-determined input instead of guessing. It also runs the
+same scenarios twice through fresh runtime instances and asserts byte-identical
+trace JSONL.
+
+Run from the repository root:
+
+```bash
+UV_PROJECT_ENVIRONMENT=/tmp/core-amr-decision-uv uv run python demos/amr_decision_substrate/run_demo.py
+```
+
+Artifacts are written to:
+
+```text
+demos/amr_decision_substrate/out/
+```
+
+The important artifact is `summary.json`; `trace_a.jsonl` and `trace_b.jsonl`
+are the two replay runs that must match byte-for-byte.

demos/amr_decision_substrate/__init__.py

@@ -0,0 +1 @@
+"""AMR decision/accountability substrate demo."""

demos/amr_decision_substrate/run_demo.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import sys
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from chat.runtime import ChatRuntime
+from core.cognition.pipeline import CognitiveTurnPipeline
+from core.protocol import (
+    CtpEpistemic,
+    CtpInvariant,
+    CtpProof,
+    JsonlEventReader,
+    JsonlEventSink,
+    canonical_bytes,
+    canonical_hash,
+    evidence_observed,
+    turn_completed,
+    turn_refused,
+    turn_requested,
+    verify_chain,
+)
+from generate.exhaustion import RefusalReason
+from recognition.anti_unifier import derive_recognizer
+from recognition.outcome import EvidenceSpan, FeatureBundle, NegativeEvidence
+
+
+Decision = Literal["PROCEED", "STOP", "REFUSE"]
+
+SCENARIO_PATH = Path(__file__).with_name("scenarios.jsonl")
+DEFAULT_OUTPUT_DIR = Path(__file__).with_name("out")
+
+
+@dataclass(frozen=True, slots=True)
+class Scenario:
+    scenario_id: str
+    description: str
+    simulated_input: dict[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class DecisionRecord:
+    scenario_id: str
+    decision: Decision
+    reason: str
+    core_input: str
+    core_surface: str
+    core_refusal_reason: str
+    trace_hash: str
+    versor_condition: float
+    ctp_message_id: str
+
+
+def _span(tokens: tuple[str, ...], start: int, end: int) -> EvidenceSpan:
+    return EvidenceSpan(start=start, end=end, text=" ".join(tokens[start:end]))
+
+
+def _bundle(
+    tokens: tuple[str, ...],
+    *,
+    agent: str,
+    count: int,
+    unit: str,
+) -> FeatureBundle:
+    return FeatureBundle.from_mapping(
+        {
+            "agent": (agent, _span(tokens, 0, 1)),
+            "count": (count, _span(tokens, 2, 3)),
+            "modality": (
+                "simulated",
+                NegativeEvidence(0, len(tokens), "abstract fixture, not sensor data"),
+            ),
+            "polarity": ("+", NegativeEvidence(0, len(tokens), "no negator present")),
+            "relation": ("has", _span(tokens, 1, 2)),
+            "unit": (unit, _span(tokens, 3, 4)),
+        }
+    )
+
+
+def _recognizer():
+    examples = []
+    for tokens, agent, count in (
+        (("alpha", "has", "1", "path"), "alpha", 1),
+        (("beta", "has", "0", "path"), "beta", 0),
+    ):
+        examples.append((tokens, _bundle(tokens, agent=agent, count=count, unit="path")))
+    return derive_recognizer(examples)
+
+
+def _load_scenarios(path: Path = SCENARIO_PATH) -> tuple[Scenario, ...]:
+    rows: list[Scenario] = []
+    for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        raw = json.loads(line)
+        rows.append(
+            Scenario(
+                scenario_id=str(raw["scenario_id"]),
+                description=str(raw["description"]),
+                simulated_input=dict(raw["simulated_input"]),
+            )
+        )
+    if not rows:
+        raise ValueError(f"{path} did not contain scenarios")
+    return tuple(rows)
+
+
+def _policy_decision(simulated_input: dict[str, Any]) -> tuple[Decision, str]:
+    required = {
+        "route_state",
+        "path_count",
+        "path_confidence",
+        "obstacle_state",
+        "operator_authorized",
+        "zone",
+    }
+    missing = sorted(required - simulated_input.keys())
+    if missing:
+        return "REFUSE", f"under_determined: missing {','.join(missing)}"
+    if simulated_input["route_state"] != "mapped":
+        return "REFUSE", "under_determined: route is not mapped"
+    if isinstance(simulated_input["path_confidence"], bool) or not isinstance(
+        simulated_input["path_confidence"], (int, float)
+    ):
+        return "REFUSE", "under_determined: path_confidence is not numeric"
+    if float(simulated_input["path_confidence"]) < 0.85:
+        return "REFUSE", "under_determined: path confidence below bound"
+    if simulated_input["operator_authorized"] is not True:
+        return "STOP", "operator not authorized"
+    if simulated_input["obstacle_state"] in {"occupied", "blocked"}:
+        return "STOP", f"path not clear: {simulated_input['obstacle_state']}"
+    if simulated_input["obstacle_state"] != "clear":
+        return "REFUSE", f"out_of_distribution: obstacle_state={simulated_input['obstacle_state']!r}"
+    if isinstance(simulated_input["path_count"], bool) or not isinstance(
+        simulated_input["path_count"], int
+    ):
+        return "REFUSE", "under_determined: path_count is not numeric"
+    if int(simulated_input["path_count"]) < 1:
+        return "STOP", "no admissible path in simulated record"
+    return "PROCEED", "mapped route, clear path, sufficient confidence"
+
+
+def _core_input_for(scenario: Scenario, decision: Decision) -> str:
+    sim = scenario.simulated_input
+    if decision == "REFUSE":
+        return f"ambiguous telemetry for {scenario.scenario_id} cannot bind route evidence"
+    path_count = int(sim["path_count"])
+    return f"{scenario.scenario_id.replace('-', '_')} has {path_count} path"
+
+
+def _proof_for(result, *, replay_digest: str, decision: Decision) -> CtpProof:
+    invariants = (
+        CtpInvariant(
+            name="versor_condition",
+            status="passed" if result.versor_condition < 1e-6 else "failed",
+            value=float(result.versor_condition),
+            threshold=1e-6,
+        ),
+        CtpInvariant(
+            name="decision_domain",
+            status="passed",
+            value=decision in {"PROCEED", "STOP", "REFUSE"},
+            threshold=True,
+            detail="bounded proceed/stop/refuse domain",
+        ),
+    )
+    return CtpProof(
+        trace_hash=result.trace_hash,
+        replay_digest=replay_digest,
+        admissibility_trace_hash=result.admissibility_trace_hash,
+        operator_invocation=result.operator_invocation,
+        versor_condition=float(result.versor_condition),
+        refusal_reason=result.refusal_reason,
+        invariants=invariants,
+    )
+
+
+def _run_once(scenarios: tuple[Scenario, ...], trace_path: Path) -> tuple[DecisionRecord, ...]:
+    if trace_path.exists():
+        trace_path.unlink()
+    sink = JsonlEventSink(trace_path)
+    pipeline = CognitiveTurnPipeline(ChatRuntime(no_load_state=True), recognizer=_recognizer())
+    records: list[DecisionRecord] = []
+
+    for sequence_base, scenario in enumerate(scenarios):
+        decision, reason = _policy_decision(scenario.simulated_input)
+        core_input = _core_input_for(scenario, decision)
+        correlation_id = f"amr-demo:{scenario.scenario_id}"
+
+        observed = evidence_observed(
+            "simulated_amr_fixture",
+            scenario.scenario_id,
+            correlation_id=correlation_id,
+            sequence=sequence_base * 10,
+        )
+        requested = turn_requested(
+            core_input,
+            correlation_id=correlation_id,
+            sequence=sequence_base * 10 + 1,
+        )
+        result = pipeline.run(core_input, max_tokens=4)
+
+        if decision == "REFUSE" and result.refusal_reason != RefusalReason.RECOGNITION_REFUSED.value:
+            raise RuntimeError(
+                f"{scenario.scenario_id} was expected to materialize CORE recognition refusal; "
+                f"got {result.refusal_reason!r}"
+            )
+
+        replay_material = {
+            "core_refusal_reason": result.refusal_reason,
+            "decision": decision,
+            "reason": reason,
+            "scenario_id": scenario.scenario_id,
+            "trace_hash": result.trace_hash,
+        }
+        replay_digest = canonical_hash(replay_material)
+        epistemic = CtpEpistemic(
+            state="REFUSED" if decision == "REFUSE" else "GROUNDED",
+            grounding_source=(
+                "core_recognition_refusal"
+                if decision == "REFUSE"
+                else "simulated_fixture_plus_core_trace"
+            ),
+            normative_clearance="UNASSESSABLE" if decision == "REFUSE" else "CLEARED",
+        )
+        proof = _proof_for(result, replay_digest=replay_digest, decision=decision)
+        if decision == "REFUSE":
+            terminal = turn_refused(
+                refusal_reason=result.refusal_reason,
+                trace_hash=result.trace_hash,
+                epistemic=epistemic,
+                causation_id=requested.message_id,
+                correlation_id=correlation_id,
+                sequence=sequence_base * 10 + 2,
+            )
+        else:
+            terminal = turn_completed(
+                surface=f"decision={decision}; reason={reason}",
+                trace_hash=result.trace_hash,
+                epistemic=epistemic,
+                causation_id=requested.message_id,
+                correlation_id=correlation_id,
+                sequence=sequence_base * 10 + 2,
+                proof=proof,
+            )
+
+        sink.append(observed)
+        sink.append(requested)
+        sink.append(terminal)
+        records.append(
+            DecisionRecord(
+                scenario_id=scenario.scenario_id,
+                decision=decision,
+                reason=reason,
+                core_input=core_input,
+                core_surface=result.surface,
+                core_refusal_reason=result.refusal_reason,
+                trace_hash=result.trace_hash,
+                versor_condition=float(result.versor_condition),
+                ctp_message_id=terminal.message_id,
+            )
+        )
+
+    verify_chain(tuple(JsonlEventReader(trace_path)))
+    return tuple(records)
+
+
+def run_demo(output_dir: Path = DEFAULT_OUTPUT_DIR) -> dict[str, Any]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    scenarios = _load_scenarios()
+    trace_a = output_dir / "trace_a.jsonl"
+    trace_b = output_dir / "trace_b.jsonl"
+    records_a = _run_once(scenarios, trace_a)
+    records_b = _run_once(scenarios, trace_b)
+
+    byte_identical_replay = trace_a.read_bytes() == trace_b.read_bytes()
+    if not byte_identical_replay:
+        raise RuntimeError("fresh-runtime replay traces were not byte-identical")
+    if records_a != records_b:
+        raise RuntimeError("fresh-runtime decision records diverged")
+
+    decisions = [r.decision for r in records_a]
+    payload = {
+        "demo_id": "amr_decision_substrate",
+        "scope": {
+            "core_role": "decision/refusal/replay accountability substrate",
+            "not_claimed": [
+                "perception",
+                "SLAM/localization",
+                "motion planning",
+                "motor control",
+                "robot fleet integration",
+            ],
+            "input_kind": "simulated abstract AMR situation records",
+        },
+        "claims": {
+            "bounded_decision_domain": sorted(set(decisions)) == ["PROCEED", "REFUSE", "STOP"],
+            "refuse_path_present": "REFUSE" in decisions,
+            "byte_identical_replay": byte_identical_replay,
+            "all_versors_closed": all(r.versor_condition < 1e-6 for r in records_a),
+        },
+        "records": [asdict(r) for r in records_a],
+        "trace_a_sha256": hashlib.sha256(trace_a.read_bytes()).hexdigest(),
+        "trace_b_sha256": hashlib.sha256(trace_b.read_bytes()).hexdigest(),
+    }
+    summary_path = output_dir / "summary.json"
+    summary_path.write_bytes(canonical_bytes(payload))
+    return payload
+
+
+def main() -> int:
+    payload = run_demo()
+    print(json.dumps(payload, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

demos/amr_decision_substrate/scenarios.jsonl

@@ -0,0 +1,3 @@
+{"scenario_id":"sim-clear-corridor","description":"Simulated clear corridor with a mapped route and sufficient confidence.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.94,"obstacle_state":"clear","operator_authorized":true,"zone":"public_floor"}}
+{"scenario_id":"sim-occupied-aisle","description":"Simulated occupied aisle; the route is known, but the path is blocked by an abstract obstacle state.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.91,"obstacle_state":"occupied","operator_authorized":true,"zone":"public_floor"}}
+{"scenario_id":"sim-underdetermined","description":"Simulated under-determined record; the obstacle state is absent, so the policy cannot decide safely.","simulated_input":{"route_state":"mapped","path_count":1,"path_confidence":0.88,"operator_authorized":true,"zone":"public_floor"}}

docs/research/brain_corp_dossier.md

@@ -0,0 +1,163 @@
+# Brain Corp Dossier
+
+This is primarily external research. When CORE status is mentioned for
+conversation framing, it is reconciled to `docs/claims_ledger.md` on main.
+
+## Snapshot
+
+Brain Corp presents BrainOS as a deployed autonomy platform for commercial
+robots, with applications across cleaning, inventory, remote site management,
+and newer physical-AI directions. Public materials position BrainOS as a
+platform combining robotic autonomy, analytics/operations management, and
+autonomy services. The BrainOS page states that the platform integrates a
+sensor kit, UL-certified controller, and autonomy software for perception,
+motion planning, localization, and navigation. [BrainOS platform](https://www.braincorp.com/brainos)
+
+Brain Corp's safety page emphasizes computer vision, 3D LiDAR, real-time path
+adjustment, global replanning, path optimization, redundant safety systems, and
+real-time obstacle detection. It also states the controller has independent UL
+60730-1 and SIL2 verification and gives public fleet scale/reliability claims.
+[Brain Corp safety](https://www.braincorp.com/safety)
+
+## Public Architecture Reading
+
+The public architecture is a deployed robotics autonomy stack:
+
+- Sensors and perception: computer vision and 3D LiDAR are explicitly named in
+  safety materials.
+- Localization/navigation/planning: BrainOS describes perception, precise motion
+  planning, localization, and advanced navigation.
+- Runtime safety: the safety page describes layered and redundant safety, plus
+  obstacle detection in dynamic environments.
+- Fleet/ops layer: BrainOS includes BrainOS Mobile, Fleet Ops Portal, weekly
+  summaries, remote monitoring/diagnostics, and remote route optimization.
+- Data flywheel: BrainOS describes "crowdsource learning," where field robot
+  experience is applied across the fleet.
+
+The important CTO inference: Brain Corp does not need a generic "robot brain."
+They already operate a vertically integrated autonomy-plus-operations platform.
+Any CORE conversation must be about a narrow substrate underneath or adjacent to
+decision accountability, not replacing their stack.
+
+## Safety and Determinism Positioning
+
+Brain Corp's public "deterministic safety" equivalent sits in conventional
+robotics safety architecture: sensors, obstacle detection, real-time replanning,
+multi-layer redundancy, controller certification, and fleet operational support.
+Public materials do not describe an inspectable cognitive trace substrate that
+turns an abstract decision into a replayable refusal/proceed/stop proof. That is
+the possible opening for CORE, but it should be framed as a gap hypothesis, not
+as a proven product-market fit.
+
+## Partnerships and Commercial Signals
+
+Tennant is the clearest floor-care partner signal. Tennant and Brain Corp
+announced an exclusive technology agreement in February 2024 to accelerate
+robotic floor-cleaning innovation. Tennant said Brain Corp technology powered
+more than 6,500 Tennant cleaning robots in the field and described the X4 ROVR
+as the first of planned future AMR cleaning products powered by Brain Corp's
+next-generation technology for Tennant equipment. [Tennant/Brain Corp agreement](https://investors.tennantco.com/news/news-details/2024/Tennant-Company-and-Brain-Corp-Sign-Exclusive-Technology-Agreement-To-Accelerate-Robotic-Floor-Cleaning-Innovation-and-Adoption/default.aspx)
+
+Tennant's X4 ROVR release says the machine is powered by the next-generation
+BrainOS Robotics Platform and emphasizes computer vision, compact dimensions,
+and operation in narrow/congested spaces. [X4 ROVR release](https://investors.tennantco.com/news/news-details/2024/Tennant-Announces-Full-Specification--Capabilities-of-X4-ROVR-Autonomous-Floor-Cleaning-Machine-its-First-Purpose-Built-Robotic-Scrubber-/default.aspx)
+
+SoftBank Robotics' Whiz materials also name BrainOS. SoftBank Robotics America
+describes Whiz as powered by BrainOS, and SoftBank Robotics Group describes
+Whiz/Whiz i as co-developed with Brain Corp in 2017. [SoftBank Robotics Whiz](https://us.softbankrobotics.com/whiz), [SoftBank Robotics solution page](https://www.softbankrobotics.com/solution/)
+
+Brain Corp also announced a May 20, 2026 UC San Diego collaboration focused on
+semantic mapping and contextual grounding for physical AI. That announcement is
+especially relevant because it names the same adjacent problem space where CORE
+should avoid overclaiming: contextual understanding, grounding, and reliability
+in complex physical environments. [Brain Corp/UC San Diego](https://www.braincorp.com/resources/brain-corp-and-uc-san-diego-partner-to-advance-the-foundational-intelligence-layer-for-physical-ai)
+
+## Eugene Izhikevich Lineage
+
+Brain Corp's own about page identifies Dr. Eugene Izhikevich as co-founder and
+chairman. It says the company began in 2009 with computational neuroscientists
+providing research services, guided by Izhikevich, and later launched BrainOS in
+2014. The same page ties Izhikevich to spiking-network theory, a large
+thalamo-cortical model, the Neurosciences Institute, and Scholarpedia.
+[Brain Corp about](https://www.braincorp.com/about)
+
+Takeaway for the CTO conversation: do not present CORE's geometric/cognitive
+language as exotic relative to Brain Corp. Their origin story already includes
+computational neuroscience and brain-inspired robotics. The differentiator must
+be a concrete accountable substrate, not philosophical novelty.
+
+## Patent Signals
+
+US11467602B2, assigned to Brain Corp, is titled "Systems and methods for
+training a robot to autonomously travel a route." The patent page names route,
+map, robot, and user as key terms and describes learning a route by
+demonstration, mapping/localization, autonomous navigation, sensor data,
+actuator association, map evaluation/correction, and cases where the robot
+determines not to autonomously navigate a portion of a route. [US11467602B2](https://patents.google.com/patent/US11467602B2/en)
+
+This patent signal reinforces that Brain Corp's core lane is teach/repeat,
+mapping, localization, navigation, route quality, and commercial cleaning
+robotics. CORE should not enter the conversation as a competing route-learning
+or navigation system.
+
+## Adjacent Players
+
+- Avidbots: autonomous floor-care competitor. Avidbots public autonomy material
+  says its proprietary AI software powers Neo for autonomous floor scrubbing.
+  [Avidbots autonomy PDF](https://avidbots.com/assets/Knowledge/Avidbots_Autonomy.pdf)
+- SoftBank Robotics: Whiz is a commercial cleaning robot line, with official
+  pages naming BrainOS and Brain Corp involvement. [Whiz](https://us.softbankrobotics.com/whiz)
+- Locus Robotics: warehouse AMR/orchestration competitor in a different
+  vertical. Locus publicly describes AMRs, LocusONE orchestration, Locus Origin,
+  Locus Vector, and newer Locus Array for more autonomous fulfillment.
+  [Locus Robotics](https://www.locusrobotics.com/)
+
+## Gap CORE Can Honestly Target
+
+The precise gap is not perception, not navigation, not motion planning, and not
+fleet operations. Brain Corp already owns those deployed surfaces.
+
+The possible gap is a substrate-level accountability layer for bounded decisions:
+
+- preserve an abstract decision record as a deterministic trace;
+- distinguish proceed, stop, and refusal;
+- refuse under-determined input rather than forcing a fluent answer;
+- make replay equality a first-class artifact;
+- expose invariant checks and refusal reason in a canonical protocol.
+
+The current AMR demo should be described only as a preparation artifact that
+shows this shape over simulated records. It does not prove deployment readiness.
+Ledger framing keeps that boundary sharp: no CORE domain is at `expert`;
+`audit-passed` means claim-shape compliance, not raw capability; text is an
+active modality, audio is substrate with its gate CLOSED, and vision/motor are
+proposed only. Determinism should be framed as byte-stable trace/digest evidence
+and fail-closed drift detection, not robotics-grade control.
+
+## Conversation Posture
+
+Strong opening:
+
+"BrainOS is the robotics stack. We are not here to claim perception, planning,
+or motor control. We prepared a tiny simulated AMR-adjacent accountability demo
+to discuss whether a deterministic refusal/replay substrate could be useful
+beneath bounded decisions in a system like yours. The demo is a preparation
+artifact over simulated records, not deployment readiness."
+
+Weak opening:
+
+"CORE is a new kind of robot intelligence that could sit under BrainOS."
+
+## Source List
+
+- [BrainOS platform](https://www.braincorp.com/brainos)
+- [Brain Corp safety](https://www.braincorp.com/safety)
+- [Brain Corp about](https://www.braincorp.com/about)
+- [Brain Corp / UC San Diego physical AI collaboration](https://www.braincorp.com/resources/brain-corp-and-uc-san-diego-partner-to-advance-the-foundational-intelligence-layer-for-physical-ai)
+- [Tennant / Brain Corp exclusive technology agreement](https://investors.tennantco.com/news/news-details/2024/Tennant-Company-and-Brain-Corp-Sign-Exclusive-Technology-Agreement-To-Accelerate-Robotic-Floor-Cleaning-Innovation-and-Adoption/default.aspx)
+- [Tennant X4 ROVR release](https://investors.tennantco.com/news/news-details/2024/Tennant-Announces-Full-Specification--Capabilities-of-X4-ROVR-Autonomous-Floor-Cleaning-Machine-its-First-Purpose-Built-Robotic-Scrubber-/default.aspx)
+- [Tennant T380AMR product page](https://www.tennantco.com/en_us/1/machines/scrubbers/product.t380amr.robotic-floor-scrubber.M-T380AMR.html)
+- [SoftBank Robotics Whiz](https://us.softbankrobotics.com/whiz)
+- [SoftBank Robotics solution page](https://www.softbankrobotics.com/solution/)
+- [US11467602B2 patent](https://patents.google.com/patent/US11467602B2/en)
+- [Avidbots autonomy PDF](https://avidbots.com/assets/Knowledge/Avidbots_Autonomy.pdf)
+- [Locus Robotics](https://www.locusrobotics.com/)

docs/research/cto_pressure_test.md

@@ -0,0 +1,188 @@
+# Skeptical CTO Pressure Test
+
+Purpose: a hard-question rubric for a first technical conversation with Brain
+Corp. The standard is honesty under pressure. Any answer that converts "not yet"
+into "basically done" fails the product.
+
+## 1. Where is the external validation?
+
+Honest answer:
+
+CORE has internal deterministic evidence and demos, but external validation is
+not established unless a named third party has reviewed a specific artifact.
+The claims ledger says no domain is at `expert`; `mathematics_logic`,
+`physics`, and `systems_software` are `audit-passed`, with the prior expert
+promotion fail-closed-reverted. `audit-passed` means CORE claim-shape compliance
+per ADR-0113: signed digest, replay determinism, typed refusal, exact recall,
+and grounding provenance. It is not a raw-capability or expert-level claim.
+
+Weak answer to avoid:
+
+We have strong results and are already ahead of conventional systems. The exact
+external validation can come later.
+
+## 2. Show me working vision and motor control.
+
+Honest answer:
+
+Do not claim working CORE-native vision or motor. The current robotics-adjacent
+demo is an abstract decision/accountability substrate over simulated situation
+records. It is not perception, SLAM, localization, path planning, motor control,
+or a robot integration. Ledger multimodal status is: text is an active
+capability; audio is substrate with the capability gate CLOSED; vision and
+motor are proposed only.
+
+Weak answer to avoid:
+
+The same substrate naturally extends to vision and motor, so this is basically
+a robot brain.
+
+## 3. Why should Brain Corp care if BrainOS already handles perception,
+navigation, safety, fleet telemetry, and operations?
+
+Honest answer:
+
+They should not replace BrainOS with CORE. The possible fit is beneath or beside
+the autonomy stack: replayable decision provenance, refusal-on-ambiguity, and
+accountability records for bounded decisions where a system must show why it
+proceeded, stopped, or refused. BrainOS is the deployed robotics platform; CORE
+is only a candidate substrate for traceable cognition/control evidence.
+
+Weak answer to avoid:
+
+BrainOS is conventional robotics infrastructure and CORE is the more advanced
+foundation.
+
+## 4. What exactly works today?
+
+Honest answer:
+
+Say only what the prepared demo proves: a simulated AMR-style situation record
+can be reduced into `PROCEED`, `STOP`, or `REFUSE`; the under-determined case
+materializes a CORE refusal reason; two fresh runs produce byte-identical replay
+artifacts; the demo preserves the versor closure invariant. Ledger-wide
+determinism framing is stronger and still bounded: byte-identical replay/digest
+evidence is stable across processes and `PYTHONHASHSEED`; the expert revert was
+a single-source evidence-drift in a non-gating coverage metric, and the system
+caught that drift by failing closed to `audit-passed`, never to a false expert.
+None of this proves robotics-grade control.
+
+Weak answer to avoid:
+
+This demonstrates reliable robotics decision-making.
+
+## 5. Are you using LLMs, stochastic generation, or hidden heuristics?
+
+Honest answer:
+
+For the demo, the policy reducer is explicit and tiny; CORE supplies the real
+runtime trace/refusal/replay surfaces. The demo should name what is simulated
+and should not hide the reducer as "emergent cognition." If any future surface
+uses stochastic models, that must be disclosed as outside CORE's deterministic
+substrate.
+
+Weak answer to avoid:
+
+No heuristics; the geometry handles the decision.
+
+## 6. What happens on out-of-distribution or ambiguous input?
+
+Honest answer:
+
+The demo refuses. More generally, the desired contract is refuse rather than
+guess. If a current component fails to refuse where it should, that is a defect
+to report, not a behavior to explain away. Use the ledger's exact GSM8K framing
+if the subject comes up: A sealed-real `0/0/1319` is the honest external number,
+showing zero-confabulation discipline plus an honest coverage gap, not an
+accuracy result; B synthetic-public `150/150/0` is CORE-authored and never "100%
+on GSM8K"; C train_sample `6/44/0` has exit-criterion NOT met, and the stricter
+probe reads `4/46` on the same 50; D composite `185/14/40/50 wrong=0` is
+CORE-authored and currently reverted.
+
+Weak answer to avoid:
+
+It generalizes gracefully because the manifold structure is robust.
+
+## 7. Who besides the founder has verified this?
+
+Honest answer:
+
+Name only actual reviewers, tests, audits, or PRs that have occurred. If the
+answer is "not yet externally verified," say that. The Brain Corp conversation
+is preparation for scrutiny, not proof of validation.
+
+Weak answer to avoid:
+
+Several technical people have looked at it and found it promising.
+
+## 8. Why is this not just a fancy audit log?
+
+Honest answer:
+
+An audit log records what happened. The intended CORE distinction is that
+decision, refusal, trace hash, invariant checks, and replay equality are
+load-bearing in the runtime contract. The current demo shows the trace/replay
+surface, not a full robotics-grade control proof.
+
+Weak answer to avoid:
+
+Audit logs are passive; CORE is intelligent.
+
+## 9. Can this improve Brain Corp's deployed safety case?
+
+Honest answer:
+
+Not by assertion. The narrow possible value is a secondary accountability layer
+that can refuse under-determined decisions and replay the same trace
+byte-for-byte. Whether that helps a deployed safety case requires Brain Corp's
+requirements, certification constraints, and integration boundaries.
+
+Weak answer to avoid:
+
+Yes, because deterministic refusal is inherently safer.
+
+## 10. What would a real pilot have to prove?
+
+Honest answer:
+
+A credible pilot would need a bounded decision interface, a written non-goal
+list, replayable traces, refusal cases, operator-review flow, and a comparison
+against an existing BrainOS decision/audit mechanism. It would also need failure
+criteria: if CORE cannot add clearer accountability without increasing
+integration risk, the pilot should stop. Single-signer attestation is also a
+known boundary: the reviewer registry has one signer, `shay-j`, and a partner
+may reasonably probe that.
+
+Weak answer to avoid:
+
+Give us data and we can show broad improvement.
+
+## 11. What are the hardest objections?
+
+Honest answer:
+
+- CORE does not currently demonstrate robot perception or motor emission.
+- The demo uses simulated facts, not sensors.
+- External validation is pending.
+- The domain-policy reducer is not CORE-native robotics intelligence.
+- Brain Corp already has a mature deployed stack; CORE must earn a narrow
+  interface, not demand architectural replacement.
+
+Weak answer to avoid:
+
+The objections are mostly about maturity, not architecture.
+
+## 12. What should Opus's brief be graded against?
+
+It should pass these checks:
+
+- No benchmark numbers unless copied from the approved claims ledger.
+- No claim that CORE has working vision/motor.
+- No claim that any domain is `expert`; `audit-passed` is claim-shape compliance,
+  not expert capability.
+- No implication that BrainOS is obsolete.
+- No hidden slide from simulated demo to real robot readiness.
+- Clear distinction between substrate, policy reducer, perception, planning,
+  actuation, and fleet operations.
+- Every strong claim has either a cited external source, a repo artifact, or
+  the exact claims-ledger value and framing.