BOB Forge

BOB Forge turns an issue into a verified fix.

BOB Forge is for solo developers and small teams that do not have dedicated SRE or DevOps staff. It is a local-first Build Week engineering demo that inspects one registered read-only project, asks a structured execution provider for a bounded repair proposal, copies the source into an isolated local Git workspace, validates and tests the change, then waits at one post-test human approval gate. An approved artifact can target only the local Docker sandbox. There is no VPS, hosted control plane, production deployment, source merge, or push path.

Why not just Codex? Codex is the repair intelligence and proposal engine; BOB Forge is the deterministic control plane around isolation, patch validation, testing, human approval, portable evidence, local deployment, health verification, and rollback. The model proposes a repair, while BOB Forge owns what may run and whether the tested release may deploy.

Honest hackathon scope: the current product supports one bundled target, reconnect-demo. It repairs a real intentionally broken WebSocket reconnect fixture; it is not yet a generic arbitrary-repository agent or a production deployer.

Judge demo path

1. Watch the product

The public demo URL is supplied in the Devpost entry. It shows the real reconnect-demo repair flow, including local Codex/GPT-5.6 analysis, isolated Docker gates, phone approval, measured health, explicit rollback, and the final evidence verdict.

2. Verify the preserved run

The final redacted Evidence Pack can be checked without Docker, a phone, an API key, or access to the developer's Codex login:

.\scripts\verify-evidence.ps1 C:\path\to\bob-forge-evidence-task_id.json

The verifier recomputes the canonical-payload self-consistency digest, stable run digest, and semantic verdict, then exits non-zero on a mismatch. Judge Mode also embeds the final application commit. This portable path is evidence verification, not a simulated model run or a hosted demo; see Judge test path for the trust boundary.

3. Run a complete local repair

From the repository root, run the clean-checkout preflight once. It validates the local ChatGPT Codex login, the project-pinned local Docker engine, tests, linters, reset, and fixture warmup without starting the server:

.\scripts\preflight.ps1

After committing the exact bytes under review, create a real local-Codex/Docker proof with:

.\scripts\run-e2e.ps1

For the timed run, keep the PC and phone on the same trusted Wi-Fi and start:

.\scripts\judge-demo.ps1 -LaunchOnly

Open the newly printed /pair URL on the phone, enter that restart's code, submit the prefilled reconnect-demo incident, inspect the isolated diff and Docker test evidence, approve the exact artifact, show reconnect health, roll back to the measured broken baseline, and tap Export evidence pack. The current export is schema v2: require verdict.status = "VERIFIED" and verdict.verified = true; INCOMPLETE or MISMATCH is evidence of a missing or contradictory proof, not a passing demo. The concise operator flow is in Judge quickstart, and the full cue sheet is in docs/JUDGING.md. If a physical phone is unavailable, use the same HUD on loopback and say so; never weaken the access checks.

Quick start

Requirements: Python 3.12+, PowerShell, Git, an installed Codex CLI signed in through ChatGPT, and a running local Docker Desktop engine for executable validation/deployment. Node.js is optional and is used only for frontend syntax checks. Setup now verifies the project-resolved local Docker endpoint and a real engine response; Docker absence fails before model-authored code can run, with no host or remote-daemon fallback. The default local Codex path uses the user's eligible ChatGPT Codex plan, explicitly pins Build Week runs to gpt-5.6-sol with ultra reasoning, and does not require an OpenAI API key.

Set-Location -LiteralPath '<path-to-cloned-bob-forge-repository>'
.\scripts\setup.ps1
.\scripts\start-demo.ps1

Open http://127.0.0.1:8138, select reconnect-demo, and submit the prefilled reconnect incident. Runtime state is stored under .bob-forge/ and can be removed safely with:

.\scripts\reset-demo.ps1

start-demo.ps1 always runs the BOB Forge control plane as a Windows host process so it can use the local Codex and Docker CLIs. docker-compose.yml now launches only the intentionally broken upstream and broken-demo fixtures; it is not a BOB Forge server or deployment adapter. The root control-plane image was removed. Deployment builds the reviewed demo_service/Dockerfile separately from the content-addressed pre-change baseline and the frozen candidate that already passed Docker tests.

Execution selection is explicit:

1. local_codex is the default and uses hardened direct codex exec --json --sandbox read-only with user config/rules ignored for the task boundary, explicitly passing --model gpt-5.6-sol and model_reasoning_effort="ultra"; the complete bounded event stream is rejected if it reports command, file-change, web-search, or tool actions;
2. the pinned beta SDK remains available only through explicit BOB_FORGE_CODEX_TRANSPORT=sdk_opt_in, because it does not provide an equivalent ignore-user-config/rules boundary;
3. deterministic fallback is disabled by default; only a prepared non-judge reconnect-demo may opt in with the exact BOB_FORGE_ALLOW_DETERMINISTIC_FALLBACK=YES setting;
4. openai_api is a separate paid opt-in requiring BOB_FORGE_EXECUTION_PROVIDER=openai_api, OPENAI_API_KEY, and BOB_FORGE_CONFIRM_PAID_API=YES.

Judge Mode forces BOB_FORGE_ALLOW_DETERMINISTIC_FALLBACK=NO and fails closed if local Codex is unavailable. There is never an automatic provider switch or paid-API fallback; an API key alone does not activate paid mode. See execution and cost and OpenAI integration.

BOB_FORGE_CODEX_MODEL and BOB_FORGE_CODEX_REASONING_EFFORT can override those local defaults with validated values. /api/system/status reports the actual configured model and effort so the HUD can show what will run rather than inheriting an invisible global Codex setting.

Optional paired phone view

Loopback is always the default. On a trusted same-WiFi network, an explicit exact RFC1918 address enables paired phone access:

.\scripts\start-demo.ps1 -LanAddress 192.168.1.25                 # lan-readonly
.\scripts\start-demo.ps1 -LanAddress 192.168.1.25 -AllowLanControl # lan-control

The script verifies that the address is assigned to this PC on a Windows Private network profile, prints a restart-scoped /pair URL/code, and creates no firewall rule. LAN mode uses plain HTTP: use it only on trusted WiFi. The pairing cookie protects static/API/SSE access; control mode additionally uses exact Origin checks and session-bound CSRF. No HTTPS tunnel or VPS path is implemented or enabled by default.

What is real

• SQLite tasks, versioned transitions, events, commands, artifacts, approvals, deployments, and crash-boundary recovery;
• durable SSE replay through Last-Event-ID, reload recovery, periodic persisted execution_provider / working heartbeats while local Codex is analyzing, and exact same-origin local HTTP enforcement;
• bounded repository inspection, a fresh isolated Git baseline per task, provider-mutation detection including .git, a client-only edit allowlist, AST checks, and real pre-approval tests inside hardened local Docker;
• one post-test release approval bound to the current task version, diagnosis/plan evidence, immutable pre-change baseline, tested candidate, and canonical deployment manifest; both frozen source-plus-Git trees are re-hashed before deployment and captured as deterministic Docker tar/stdin bytes;
• local-only Docker build, health proof, and rollback adapters;
• schema-v2 redacted judge evidence with a self-digest and semantic VERIFIED / INCOMPLETE / MISMATCH verdict over local-Codex execution, integrity, tests, approval, deployment, health, and rollback bindings.
• a portable evidence verifier, stable run digest across repeat exports, and Judge-Mode application-commit binding; these prove internal consistency and release provenance but are not claimed as third-party signatures.

The WebGL/Canvas Core, Orbit, animation engine, and timing constants are prior Hermes OS work reused with disclosure. BOB Forge adds the standalone backend, workflow panels, API adapter, and engineering pipeline. See prior work, HUD audit, and UI reuse.

How Codex and GPT-5.6 fit

During Build Week, Codex was the implementation partner for the independent BOB Forge control plane, reconnect fixture, deterministic validation and Docker gates, phone workflow, failure handling, tests, security review, and submission documentation. It accelerated repository inspection, implementation, debugging, and repeated verification. The product scope and release-authority decisions stayed human: one bounded repair scenario, local Windows execution, explicit phone approval, no source merge or push, and no automatic paid-provider fallback. The dated commit history and prior-work disclosure keep that authorship boundary reviewable.

At runtime, BOB Forge invokes the locally authenticated Codex CLI with gpt-5.6-sol and ultra reasoning for a structured diagnosis and repair proposal. GPT-5.6 receives no patch, command, approval, or deployment authority. Proposal turns use the CLI's read-only sandbox, action-bearing results fail closed, and BOB Forge alone validates and applies the bounded proposal, runs fixed Docker gates, binds the tested bytes to human approval, and verifies local deployment and rollback.

Verification ledger — 2026-07-16

• Historical explicit-sdk_opt_in proof controlled installed Codex 0.144.1 through an existing ChatGPT subscription with no API key. That non-degraded task kept source plus .git unchanged, passed sandbox_build, containerized compile, and containerized demo_tests, completed local deployment at 12 messages/6 reconnects, and verified rollback at 2 messages/0 reconnects.
• A historical direct-CLI proof also succeeded through codex exec --json --sandbox workspace-write, returned valid structured JSONL, and reported ChatGPT-subscription billing rather than paid API billing.
• The current two-fixture Compose file built and reached readiness: upstream became healthy and broken-demo reproduced the stalled two-message close-1012 baseline.
• A real protected LAN HTTP client connected through an assigned private address, paired, obtained its session/CSRF contract, approved the task, and completed local deployment health at 12 messages/5 reconnects. Rollback verified the baseline at 2 messages/0 reconnects.
• The current submission-candidate clean-commit proof passed through local_codex / codex_cli_jsonl / gpt-5.6-sol / ultra with the read-only/action-event acceptance gate, ChatGPT-subscription billing, degraded = false, and no automatic paid fallback. The candidate exceeded the required four messages and one reconnect; rollback restored exactly 2 messages/0 reconnects/close 1012; nested schema-v2 evidence was VERIFIED; the proof commit matched git rev-parse HEAD; and managed Docker resources were cleaned up. Any later tracked change invalidates this statement until scripts/run-e2e.ps1 is repeated.
• The trusted Wi-Fi profile was manually set to Windows Private, so normal explicit-LAN preflight was eligible. BOB Forge did not elevate, change the OS profile, or create/modify a firewall rule. A physical Android phone paired on that address, drove approval, displayed the healthy local deployment, drove exact rollback, and requested the redacted export. The external submission package preserves the schema-v2 VERIFIED phone export and manual QA record bound to the submitted commit; any later tracked change requires a fresh run and export.
• The earlier host task task_9baa2e64d3be412285b3fa924adc15fe remains additional historical proof of local deployment/health/rollback. The current unit suite contains 214 tests and reports OK (skipped=1) on Windows; the skip is the expected Windows symlink case. Ruff and strict mypy across 19 source files also pass. See Testing.

Documentation

• Setup
• Execution, cost, and network boundary
• Demo guide
• Testing
• Troubleshooting
• Architecture
• Build Week scope
• Architecture decisions
• Progress and verified limitations
• Architecture roadmap reconciliation
• Judge quickstart
• Judge test path
• Legacy three-minute video outline (superseded)
• 2:48 English voiceover and shot list
• AI voiceover production handoff
• Devpost submission copy
• Submission checklist
• Final gap audit
• Security model
• Known limitations
• Final competitive audit
• Final test report
• Manual phone QA

License

BOB Forge is released under the MIT License. Dependency and reused-foundation notices are recorded in THIRD_PARTY_NOTICES.md, with the Build Week prior-work boundary preserved in the linked provenance documents.