([]);
+
+ const request = useMemo(() => pendingRuntimeRequest(events), [events]);
+
+ async function startRun() {
+ setStatus("starting");
+ setError(null);
+ setDiagnostic(null);
+ setTrace(null);
+ setParity(null);
+ setRunId(null);
+ setEvents([]);
+ eventsRef.current = [];
+ setSnapshot(null);
+ snapshotRef.current = null;
+
+ try {
+ const startResponse = await fetch("/api/phase2/runs", {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({ scenario }),
+ });
+ const started = (await startResponse.json()) as {
+ id?: string;
+ metadata?: Phase2RunMetadata;
+ error?: string;
+ };
+ if (!startResponse.ok || started.id === undefined || started.metadata === undefined) {
+ throw new Error(started.error ?? "The local runner did not start.");
+ }
+ setRunId(started.id);
+ const initial = createPhase2LiveSnapshot(started.metadata);
+ setSnapshot(initial);
+ snapshotRef.current = initial;
+ setStatus("running");
+
+ const streamResponse = await fetch(`/api/phase2/runs/${started.id}/events`);
+ if (!streamResponse.ok || streamResponse.body === null) {
+ throw new Error("The live event stream did not open.");
+ }
+ const reader = streamResponse.body.getReader();
+ const decoder = new TextDecoder();
+ let buffered = "";
+ while (true) {
+ const part = await reader.read();
+ buffered += decoder.decode(part.value, { stream: !part.done });
+ const lines = buffered.split("\n");
+ buffered = lines.pop() ?? "";
+ for (const line of lines) {
+ if (line.trim().length > 0) {
+ handleRecord(JSON.parse(line) as Phase2StreamRecord, started.metadata);
+ }
+ }
+ if (part.done) {
+ if (buffered.trim().length > 0) {
+ handleRecord(JSON.parse(buffered) as Phase2StreamRecord, started.metadata);
+ }
+ break;
+ }
+ }
+ } catch (cause) {
+ setStatus("error");
+ setError(cause instanceof Error ? cause.message : String(cause));
+ }
+ }
+
+ function handleRecord(record: Phase2StreamRecord, metadata: Phase2RunMetadata) {
+ if (record.kind === "event") {
+ const current = snapshotRef.current;
+ if (current === null) {
+ return;
+ }
+ const applied = applyPhase2LiveEvent(current, record.event);
+ if (!applied.ok) {
+ setStatus("error");
+ setError(applied.issues.join("; "));
+ return;
+ }
+ snapshotRef.current = applied.snapshot;
+ setSnapshot(applied.snapshot);
+ eventsRef.current = [...eventsRef.current, applied.event];
+ setEvents(eventsRef.current);
+ return;
+ }
+ if (record.kind === "diagnostic") {
+ setDiagnostic(record.message);
+ return;
+ }
+ if (record.kind === "error") {
+ setStatus("error");
+ setError(record.message);
+ return;
+ }
+ setTrace(record.trace);
+ const replay = replayPhase2Events(metadata, record.trace.events);
+ setParity(
+ snapshotRef.current === null
+ ? false
+ : phase2SnapshotsMatch(snapshotRef.current, replay),
+ );
+ setStatus("terminal");
+ }
+
+ async function postAction(action: "interrupt" | "resolve", body?: unknown) {
+ if (runId === null) {
+ return;
+ }
+ const response = await fetch(`/api/phase2/runs/${runId}/${action}`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify(body ?? {}),
+ });
+ if (!response.ok) {
+ const failure = (await response.json()) as { error?: string };
+ setError(failure.error ?? `The ${action} command failed.`);
+ setStatus("error");
+ }
+ }
+
+ return (
+
+
+
+ Local runner controls
+
+ Start one Rust runner and one scripted fake harness. No network or model is used.
+
+
+
+
+
+
+
+
+
+
+
+ Runner status
+
+ {humanizeProtocolLabel(status)}
+
+
+
+ {request?.requestKind === "runtime" ? (
+
+
+
{request.type} request
+
{request.prompt}
+
+ {request.type === "permission" ? (
+
+ ) : (
+ <>
+
+
setInput(event.target.value)}
+ />
+
+
+ )}
+
+
+
- Harness process exit
+ - {trace.harnessProcessExit.exitCode ?? "signal"}
+
+
+
- Semantic result
+ - {trace.result?.reportedWorkDisposition ?? "missing"}
+
+
+ ) : null}
+
+ {parity !== null ? (
+
+ Live and replay reducer output
+
+ {parity ? "Match" : "Mismatch"}
+
+
+ ) : null}
+ {diagnostic ? {diagnostic}
: null}
+ {error ? {error}
: null}
+
+
+
+
+ {snapshot ? (
+
+ ) : (
+
+
Validated live snapshot
+
Start a local run
+
Each incoming event will pass the Phase 1 validator before the reducer applies it.
+
+
+
+
+ Fixture input
+
+ Choose a conformance case or edit the JSON, then validate and replay it.
+
+
+
+
+
+
+
+
+
+
+ Enter steer · Shift+Enter newline · End jump to latest
+
+
+
+
+
+
+
+
+
+
Annotations — interaction map sections (docs/design/phase-4b-interaction-map.md)
+
+ - §1 Transcript & composer — reducer-ordered `role="log"`, streaming affordance, jump-to-latest pill, composer tri-state (Send → Steer/Stop).
+ - §2 Steering — pending chip → acknowledged / stale-rejected with “Send as new message” recovery; `expectedTurnId` shown in status line.
+ - §3 Interruption — interrupted divider preserves partial output; three races get distinct terminal states; session never replaced.
+ - §4 Request cards — inline at timeline position + blocking banner; actions only as offered upstream; single-response guarantee.
+ - §5 Goal capability — durable banner + fixed five-verb menu; unsupported verbs disabled with the exact upstream diagnostic.
+ - §6 Lineage — parent/child tree from upstream identities; child steering shown as unsupported, never emulated.
+ - §7 Reconnect/replay — connection status, replayed-to-here divider, REPLAY vs LIVE eyebrow badge, cursor/gap state.
+ - §8 Protocol inspector — canonical events + raw upstream names, requests, capabilities, identities; redaction markers verbatim.
+ - §9 Demo manifests — scenario list with expected observations, per-manifest outcome, reset with explicit destruction copy.
+
+