GPAO for Codex

GPAO stands for Growth Personal AI Operating System.

GPAO for Codex is the Codex-native surface of that Growth Personal AI Operating System. It packages BEAI Harness, Context Mesh, Knowledge Loop, verification gates, scenario simulation, and growth-loop operating rules as one operating surface for Codex work.

BEAI Harness for Codex remains the internal development-runtime component: the engine that handles planning, verification, recovery, completion language, and release evidence. Context Mesh is the continuity/evidence layer. Knowledge Loop is the review-first learning layer.

The technical package and plugin ID currently remain beai-harness-for-codex for compatibility with the existing Codex plugin cache, marketplace entry, CLI, and release history. The user-facing product name is GPAO for Codex.

Current package version: 0.1.3.

Codex can write code, but users still need to understand what changed, what was verified, how to recover, and how the AI system learns from the work. GPAO for Codex turns Codex work into a growth-oriented operating flow with context continuity, planning, patch proposals, verification, recovery, Knowledge Loop review, and skill/OS upgrade candidates.

GPAO's automation default is active progress, not waiting. It should automatically observe, classify, diagnose, propose, replay, write local event ledgers, and audit future outcomes. User approval is reserved for the minimum necessary authority boundary: external sends, public release, credentials/accounts/payment/permissions, deletion or destructive mutation, durable memory promotion, live skill application, recurring automation activation, OS-level rule promotion, and live GPAO rule mutation.

It is designed for two groups at the same time:

• Developers who want faster agentic development without losing control of files, tests, risk, or release quality.
• Non-developers who want Codex to help turn an idea into a real product while explaining the screens, data, risks, and completion path in plain language.

The harness is not a chat prompt pack. It is a local CLI and documentation system that asks Codex workflows to move through observable stages:

route -> preflight -> brief -> plan -> draft -> patch-plan -> apply-patch -> verify -> recover

For setup-heavy work, the lifecycle adds a doctor pass before completion:

route -> preflight -> brief -> plan -> doctor -> verify -> recover

Who This Is For

• Non-developers who want to build an app with Codex while still understanding the project decisions, risks, and verification path.
• Solo founders using AI to move from product idea to a safer first usable build.
• Beginner developers who want Codex output to come with checks, evidence, and recovery steps.
• Consultants or builders who provide AI-assisted development work for clients and need reviewable artifacts.
• Users who want GPAO's BEAI-powered review-first development and growth loop around Codex.

What This Is Not

• Not a fully automatic app generator.
• Not a stable npm package or hosted SaaS.
• Not a cloud provider or hosted production monitoring system. It provides Codex-side service operations rails: endpoint selection, preview/deploy planning, secrets checks, health evidence, release readiness, rollback planning, and incident planning.
• Not a tool that prevents every bug, security issue, performance issue, or accessibility issue.
• Not a replacement for Codex.

Why This Exists

Agentic coding feels powerful, but users often lose track of what changed, whether the product is complete, and how to recover when a long session breaks.

GPAO for Codex sets a stricter product-building standard:

• Treat the user's stated goal as the first-class objective. BEAI serves the user; it does not govern the user.
• Know the workspace before changing it.
• Start from the problem being reduced, not the number of features being added.
• Route each request into no-ceremony, light, standard, or strict lifecycle before forcing ceremony or skipping gates.
• Convert vague intent into a usable product brief.
• Turn vague non-developer requests into scenario choices before asking a long questionnaire.
• Reduce what the user has to guess, approve, or verify manually.
• Design responsibilities, states, human approval boundaries, data storage, failure stops, and recovery paths before large implementation work.
• Adapt the workflow to project scale instead of forcing every task through the same ceremony.
• Separate user-facing decisions from developer tasks.
• Treat file changes as reviewable proposals before applying them.
• Track provenance, checksums, snapshots, evidence, session checkpoints, public feedback signals, and delegated work units.
• Map messy AI-native workspaces so Codex can classify source-of-truth projects, experiments, archives, artifacts, and cleanup risks before the user has to touch files manually.
• Verify not only tests, but product completion across frontend, backend, data, docs, build, run, delivery, and recovery surfaces.
• Classify failures before treating them as target product bugs: product, tool/runtime, provider/credential, budget/rate-limit, transient infrastructure, harness automation, or verification-assumption.
• Treat applicability as part of verification: not-applicable is not fail, unverified is not pass, and generated assumptions do not count as product evidence.

In BEAI terms: planning reduces the problem, design separates responsibility and boundaries, development makes small verified changes, verification removes false confidence, and operations keep the program usable after release.

See docs/04-quality/GOOD-PROGRAM-PRINCIPLES-ko.md for the full good-program principles mapped to BEAI commands and gates.

Scenario Live Test Standard

BEAI Harness follows the BEAI common Scenario Live Test Product Evolution Standard.

The harness is not only a command sequence. It is a way to evolve products through realistic scenario evidence: first-use paths, incomplete user input, failure/recovery, approval transitions, verification language, and user-facing explanation quality.

Project standard:

• docs/00-standards/SCENARIO-LIVE-TEST-STANDARD-ko.md

Common source:

• Internal BEAI scenario live test standard, mirrored in this repository under docs/00-standards/.

Current Status

This repository is the GPAO for Codex source workspace. It is installed locally in the Codex plugin cache as GPAO for Codex while retaining the technical package/plugin ID beai-harness-for-codex.

Current identity:

GPAO
= Growth Personal AI Operating System

GPAO for Codex
= Codex adapter and user-facing product surface of GPAO

BEAI Harness for Codex
= internal development runtime / judgment, verification, recovery engine

Context Mesh
= continuity, evidence, and turn-start retrieval layer

Knowledge Loop
= review-first learning and knowledge refinement layer

Skill / Upgrade Loop
= user skill upgrades, workflow upgrades, and GPAO self-upgrade candidates

Do not collapse these layers. A source package can be valid, the Codex plugin cache can be installed, a restarted/new session can see the skill, and the current conversation can preserve GPAO behavior; each has its own proof.

Source/archive distributions do not include generated .beai-harness evidence. After unpacking a zip or tar archive, npm run readiness can report blocked until you regenerate local evidence by running the release checklist commands.

Current implemented surface:

• Project intelligence and preflight checks.
• Route contracts that classify request scale, risks, required gates, required commands, and blocked completion claims.
• Doctor diagnostics for route, install, environment, automation, guidance, and completion-claim readiness.
• Guided product brief and build plan generation.
• Adaptive no-ceremony/light/standard/strict flow selection for different project sizes and risk levels.
• Adaptive loop policy that selects direct, guided, standard-loop, strict-loop, or product-completion-loop by work size, risk, measurable evidence, and cost/benefit.
• Scenario-first clarification for vague ideas and non-developer product requests.
• Developer companion contract: AI does the work, user keeps authority.
• Scenario-first developer verification before final user testing.
• Completion gate for CLI, frontend, backend, and full-stack projects.
• Frontend design-quality gate for browser visual evidence, responsive coverage, UI states, design-system signals, and accessibility basics.
• GPAO Launch Copilot for vibecoders: classifies websites/apps into local, preview, service-hardening, or production-candidate launch paths, then names platform candidates, missing launch assets, and approval boundaries before any live action.
• Phase gates and completion language guard for complete, done, and ready claims.
• Codex-facing AGENTS and skill draft/apply helpers.
• Proposal-first patch planning and safe apply flow.
• Manifest/provenance tracking.
• Session checkpoint and recovery summary.
• Snapshot listing and guarded rollback.
• Codex package draft generation.
• Installer preflight/apply/verify/uninstall flow.
• Real repo benchmark fixtures for CLI, frontend, and full-stack projects, including loop validation for app fixtures.
• Loop fit planning and bounded loop reports for work that truly needs repeated improvement, with an explicit loop notice explaining why the loop improves speed, accuracy, and precision.
• Loop engineering operating mode for BEAI product work: measurable gates, budget, stop rules, evidence, and recovery.
• Field-Readiness Engineering protocol for pre-field user simulation, actor profiles, real-case libraries, weighted evaluation, reinforcement loops, failure ownership classification, applicability-aware verification, and evidence contracts.
• Engineering-quality and self-quality gates that check module boundaries, explicit state models, failure paths, evidence contracts, CLI output clarity, and release integration before public confidence claims.
• Local Codex plugin package with marketplace metadata and the BEAI Harness skill surface.
• Public feedback ledger that separates attention signals from usage, contribution, field-validation, and external insight triage signals, then routes insight candidates toward the next BEAI command plan.
• Delegation unit planning that turns long Codex work into AI-owned cards with budgets, evidence, stop rules, and user authority boundaries.
• Resource discovery router that selects applicable local CLI, Codex plugin capabilities, browser inspection, artifact tools, image generation, service-ops, field-readiness, MCP read/proposal adapters, and public-feedback resources by task surface, with evidence contracts for selected plugins.
• Ecosystem adapter readiness matrix for Codex, Claude Code, MCP, OpenClaw, and generic CLI expansion. It separates supported surfaces from adapter candidates before compatibility claims.
• OpenClaw adapter candidate that maps OpenClaw requests into BEAI work orders with execution policy, approval gates, evidence contracts, result mapping, and user-visible next actions without copying the Codex plugin or changing OpenClaw core.
• MCP read-and-proposal adapter preview for exposing status, readiness, ecosystem matrix, public docs, MCP expansion policy, and proposal-only work routing to MCP clients without write actions.
• Scenario rotation queue that prioritizes stale, high-risk, failed, or recently changed field-readiness scenarios instead of rerunning everything blindly.
• Human-facing HTML reports for plan, closeout, final-check, and readiness review. JSON and Markdown remain the evidence source; HTML is for quick browser review.
• Cost-aware verification profiles in route and plan output. Tiny direct work uses the smallest sufficient local check; public, release, high-risk, or explicitly requested simulation work can escalate to field-readiness evidence.
• User-goal supremacy and user-direct-request priority in skill guidance, route/plan contracts, and response coaching. BEAI gates make risk, cost, and evidence visible, but do not overrule a safe user request or turn ceremony into the work.
• Engineering method selector that chooses the smallest sufficient method set from prompt discipline, context retrieval, skill surface, agent delegation, cron/automation, orchestration, harness gates, and loop engineering. The default target remains a finished production-grade product or the strongest local production-candidate unless the user explicitly asks for MVP, demo, draft, or test-only scope.

Latest local verification:

• npm run verify: passes full verification in the source workspace (check, tests, preflight, beai verify --run --scenario --meaning). Source/archive users may need to regenerate local .beai-harness scenario evidence before scenario-specific readiness reports show ready.
• npm run smoke: passing.
• npm run ledger: regenerates the public verification ledger.
• node bin/beai.js perceived-quality --apply: validates 210/210 user-perceived quality scenario cases, including user burden and completion-honesty checks.
• node bin/beai.js real-world-simulation --apply: validates 24/24 external benchmark-derived simulation tuning cases, including user-goal-supremacy checks.
• node bin/beai.js field-readiness --apply: writes the Field-Readiness Engineering protocol and public evidence contract.
• node bin/beai.js engineering-quality --apply: checks senior-developer design standards across boundaries, states, failures, evidence, output, and release integration.
• node bin/beai.js self-check --apply: checks BEAI Harness internal quality, including engineering-quality readiness.
• node bin/beai.js benchmark --apply: 3/3 fixtures passing.
• node bin/beai.js external-smoke --sample <path> --apply: copies a real local sample and runs the companion smoke flow without modifying the source.
• npm run release: writes the GPAO for Codex release manifest and archive plan.
• npm run release:archive: creates and verifies the GPAO for Codex release tar archive.
• npm run release:smoke: unpacks the archive and runs the bootstrap script end to end.
• npm run readiness: regenerates the release-readiness decision from current evidence.
• npm run baseline: regenerates the production baseline decision. This means local product, plugin, release, recovery, and field-readiness gates are aligned enough for future work to be treated as upgrades, while stable market claims remain blocked until real user validation exists.
• node scripts/install-from-archive.mjs: preflight-first bootstrap for an unpacked archive.
• ./installer/install-team-plugin.sh: verifies and registers the local Codex plugin from an unpacked archive.

See Verification Ledger.

Quickstart

Requirements:

• Node.js 20 or newer.
• A local checkout of this repository.

Install dependencies:

npm install

Verify the harness itself:

npm run verify

Use npm run verify:dry only when you want command detection and planning output without recording executed verification evidence.

Inspect a target workspace:

node bin/beai.js preflight --cwd /path/to/your/project

Create a product brief:

node bin/beai.js brief --cwd /path/to/your/project --idea "Build a small habit tracker" --apply

Create a build plan:

node bin/beai.js plan --cwd /path/to/your/project --goal "Build the first usable habit tracker flow" --apply

Verify product completion:

node bin/beai.js verify --cwd /path/to/your/project

Run the built-in benchmark:

node bin/beai.js benchmark --apply

Run the public quickstart smoke:

npm run smoke

More detail: Quickstart.

Practical usage guides:

• Usage Prompt Templates: prompts for existing threads, vague ideas, developer work, plugin/distribution work, frontend quality, and service operations.
• Practical Use Cases: examples for non-developer app ideas, plugin packages, automations, frontend quality, and GPAO for Codex release work.
• Plugin Apply Check: how to distinguish installed plugin, active conversation use, and recovery.

Codex Plugin

This repository also includes a local Codex plugin package:

• Marketplace: .agents/plugins/marketplace.json
• Plugin: plugins/beai-harness-for-codex
• Skill: plugins/beai-harness-for-codex/skills/beai-harness/SKILL.md

The plugin makes GPAO for Codex visible as an installable Codex surface. BEAI Harness is the internal runtime skill inside that plugin. It still expects the BEAI CLI and repository files to provide the actual verification, recovery, and release commands.

Team install from an unpacked release archive:

./installer/install-team-plugin.sh

On macOS, teammates can also double-click:

installer/install-team-plugin.command

The team installer checks the source plugin package, runs the harness verification suite, registers the local marketplace with Codex, installs the plugin, and verifies that the current plugin version is present in the Codex plugin cache.

The default plugin install and verification target is the standalone Codex home ~/.codex. OpenClaw-managed Codex homes are explicit compatibility targets only:

./installer/install-team-plugin.sh --target openclaw

More detail: Codex Plugin.

Installed does not always mean applied in an already-open conversation. For existing Codex threads, explicitly ask Codex to apply GPAO for Codex from the current state. See Plugin Apply Check.

Command Map

Command	Purpose
beai work [--request "..."] --apply	Use the lightweight front door when the right BEAI command is unclear. It routes the request, recommends the smallest sufficient verification profile, keeps tiny work direct, and points to route, workspace init-deep, plan, or closeout as needed.
beai method --request "..." --apply	Select the right engineering method set: prompt, context, skill, agent, cron, orchestration, harness, loop, or a small combination, while preserving the production-grade default target.
beai start --request "..." --apply	Run the product front door: mode, intake, shape, problem frame, design flow, architecture plan, route, scenario, and progress evidence for vague product work.
beai lifecycle --request "..." --apply	Show the whole BEAI work lifecycle: understand, plan, build, verify, closeout, and operate.
beai context packet --request "..." --apply	Save a resume packet for long BEAI work so the next Codex session can find the current goal, master-plan anchor, latest evidence, and next action.
beai core contract --apply	Record the shared BEAI Core contract so Codex, Claude Code, OpenClaw, and MCP adapter work cannot drift into copied or inconsistent judgment logic.
beai route --request "..." --apply	Classify work into no-ceremony/light/standard/strict lifecycle, adaptive loop mode, cost-aware verification profile, user-direct-request boundary, and required gates before implementation.
beai status	Summarize route, loop, verification, ops-check, readiness, session blockers, risks, and next action.
beai progress	Explain current phase, completed/missing phases, user decisions, AI next actions, and blockers in plain language.
beai doctor	Diagnose install, setup, secret, automation, guidance, and completion-claim readiness.
beai mode --request "..." --apply	Detect beginner, owner, vibecoder, or developer mode before intake.
beai intake --request "..." --apply	Turn a vague user request into user-centered intake evidence.
beai shape --apply	Cut the request into a v0 goal, first workflow, included scope, non-goals, and review questions.
beai problem-frame --apply	Write the product problem, target user, first value moment, success/failure signals, and human decisions before implementation.
beai design-flow --apply	Write user flow, screen map, state matrix, copy rules, visual evidence, and accessibility basics before frontend/product build work.
beai architecture-plan --apply	Write implementation boundaries, data model, API boundaries, security notes, dependency map, rollback, and verification plan.
beai creator brief --apply	Turn vague non-developer intent into scenario choices, a recommended first workflow, AI-owned next moves, and user-only decisions.
beai creator scenario --apply	Turn vague non-developer intent into endpoint and workflow scenario guidance.
beai service plan --apply	Decide whether the work should stop at idea/local use, move to preview, require service operations readiness, or become a production candidate. It does not force deployment.
beai service status --apply	Summarize current service-readiness evidence and gaps.
beai service blueprint --apply	Map the operating layers needed after deployment.
beai secrets check --apply	Check whether secrets and public environment names are safe before preview, deploy, or handoff.
beai deploy plan --target preview --apply	Write a plan-only preview deployment decision.
beai deploy plan --target production --apply	Write a plan-only production deployment decision. Production remains blocked without explicit user approval.
beai health check --apply	Check whether local/service evidence exists before claiming a project is shareable or operable.
beai launch map --apply	Create a vibecoder-facing launch map: project type, recommended preview/service route, platform candidates, missing assets, and approval boundaries.
beai launch plan --target preview --apply	Write the preview-first command path from local checks to secrets, deploy plan, health, operations, and approval gates without executing external deployment.
beai launch deploy-prep --target preview --provider cloudflare --apply	Prepare provider-specific build output, preview deploy commands, handoff text, and approval boundaries without logging in or deploying.
beai launch readiness --target preview --apply	Summarize whether the app is preview-ready, service-hardening-needed, production-candidate, or blocked before handoff language.
beai ops status --apply	Summarize operating condition before service or production handoff language.
beai ops release --apply	Write release-readiness evidence before release claims.
beai ops rollback --apply	Write rollback evidence before service or production handoff language.
beai ops incident --apply	Write incident evidence before service or production handoff language.
beai approval status --apply	Summarize current deferred approval boundaries.
beai approval defer --apply	Record a deferred approval boundary so Codex can keep working locally.
beai approval pending --apply	Record pending user approval for external account, secret, deploy, payment, data, send, or public release execution.
beai adapter plan --adapter cloudflare-supabase --apply	Plan Cloudflare/Supabase adapter evidence without connecting accounts or deploying.
beai adapter dry-run --adapter cloudflare-supabase --apply	Dry-run Cloudflare/Supabase adapter evidence without migrations or real customer data.
beai adapter scaffold --adapter cloudflare-supabase --apply	Prepare local Cloudflare/Supabase candidate files without connecting accounts.
beai ecosystem readiness --request "Codex, Claude Code, MCP, OpenClaw" --apply	Write a multi-ecosystem adapter readiness matrix that keeps Codex as the supported primary surface and marks Claude Code/MCP/OpenClaw as evidence-gated adapter paths until proven.
beai adapter completion --request "Codex, Claude Code, MCP, OpenClaw" --apply	Close the local adapter completion suite across Codex, Claude adapter, OpenClaw adapter, MCP read/proposal, and Knowledge Loop pairing without granting external action authority.
beai claude-adapter scaffold --apply	Create a local Claude Code adapter candidate scaffold with plugin manifest, skill guidance, slash command guidance, inert hooks, read-only MCP bridge config, and non-overclaiming evidence.
beai claude-adapter smoke --apply	Verify the Claude Code adapter candidate from its plugin install root, including manifest, skill, slash commands, inert hooks, read-only MCP config, and wrapper paths; keep status candidate-only until real Claude CLI smoke exists.
beai-mcp or node bin/beai-mcp.js	Start the MCP read-and-proposal adapter preview. It exposes status/readiness/docs/policy and proposal-only work routing; it does not edit files or trigger actions.
npm run mcp:smoke	Start the MCP server as a stdio child process and verify initialize, tool listing, ecosystem readiness, public doc reads, policy reads, and proposal-only routing.
beai mcp policy --apply	Write the MCP expansion policy: read supported, proposal-only supported-preview, local apply blocked until dedicated smoke, authority actions blocked until explicit user approval.
beai scenario --apply	Save first success, empty state, failure/recovery, approval gates, and AI-first verification paths.
beai scenario test-plan --apply	Plan AI-owned scenario checks before asking the user for final review.
beai scenario run --apply	Record AI-owned scenario checks before asking the user for final review.
beai workspace plan	Plan the BEAI working structure without generating app code.
beai workspace init	Create the BEAI working structure without generating app code.
beai workspace check	Verify the BEAI working structure without generating app code.
beai preflight	Read-only workspace, risk, and project intelligence check.
beai init --apply	Create .beai-harness/ state files.
beai brief --idea "..." --apply	Turn an idea into a guided product brief.
beai plan --goal "..." --apply	Create a user path, developer work plan, delegation-unit outline, and recommended cost-aware verification profile.
beai verify	Detect test/build/run paths, evaluate completion gates, classify failure ownership, and separate not-applicable from failed evidence.
beai verify --run	Run detected verification commands and record evidence.
beai verify --scenario --meaning	Check saved scenario coverage and user-language product meaning before completion claims.
beai design-check --apply	For frontend work, require browser visual evidence plus responsive, state, design-system, and accessibility review before completion claims.
beai design-check repair-plan --apply	Turn design-check blockers into AI-owned repair actions before asking the user for visual feedback.
beai complete --apply	Write the completion decision, allowed language, blocked language, blockers, and final next action.
beai ops-check --apply	Translate service, data, authority, external-action, automation, operations, and launch readiness into user-facing operating conditions.
beai closeout --apply	Run the end-of-work hygiene loop: changed files, temporary artifacts, docs drift, verification evidence, history, distribution alignment, completion language, and handoff.
beai recover	Summarize latest checkpoint, blockers, evidence, and next action.
beai recover snapshots	List rollback snapshots.
beai recover rollback --target <path>	Plan or apply a guarded rollback.
beai agents ...	Draft, review, apply, or patch-plan Codex AGENTS.md.
beai skill ...	Draft, review, apply, or patch-plan a Codex skill.
beai codex doctor	Check Codex integration and packaging readiness.
beai codex package --apply	Write Codex package draft artifacts.
beai install preflight	Check install conflicts before writing files.
beai install apply --apply	Install Codex-facing surfaces when safe.
beai install verify	Verify install manifest checksums.
beai install uninstall --apply	Remove installer-managed files when unchanged.
beai benchmark --apply	Run multi-fixture benchmark with app loop validation and write a ledger.
beai smoke --apply	Run the public quickstart flow in a temporary project.
beai companion-smoke --apply	Validate companion behavior across vague owner, messy non-developer, developer package, setup-heavy automation, and tiny safe-edit scenarios.
beai companion-crosscheck --apply	Crosscheck broader real-use companion behavior across owner app, vague website, developer CLI, automation, plugin distribution, and tiny direct edit scenarios.
beai response-coach --apply	Draft audience-aware, surface-aware response guidance before substantial user-facing handoff.
beai response-finalizer --apply	Validate final answer quality against evidence, unverified work, user-work handoff, and current/next stage summaries.
beai html-report closeout	Generate a human-facing browser report under reports/ from existing BEAI evidence. Supports closeout, final-check, readiness, plan, and plugin-check.
beai flow-replay --apply	Replay multi-step conversation-style flows across vague owner, developer CLI, automation, loop, and tiny direct work.
beai perceived-quality --apply	Run a large user-perceived quality benchmark across audience, surface, risk, work-size, user-burden, and completion-honesty scenarios.
beai real-world-simulation --apply	Run evidence-led simulation tuning from external benchmark-derived patterns before field use.
beai field-readiness --apply	Formalize Field-Readiness Engineering with actor profiles, real-case sources, evaluation rubric, reinforcement loop, and evidence contract. This is release/public-confidence or explicit-simulation evidence, not the default for small direct work.
beai engineering-quality --apply	Check senior-developer design standards: module boundaries, explicit states, failure paths, evidence contracts, CLI clarity, and release integration.
beai self-check --apply	Check BEAI Harness internal quality and require engineering-quality readiness before final release confidence.
beai final-check --apply	Crosscheck final release truth across docs, plugin metadata, archive receipt, archive verification, bootstrap smoke, readiness, engineering-quality, self-check, ops-check, closeout, and dirty-tree release review warnings.
beai final-check --apply --html	Write final consistency evidence and a human-facing report in reports/.
beai public-feedback --apply	Record public GitHub/release/community feedback without treating attention as validation.
beai delegate --request "..." --apply	Turn longer work into AI-owned delegation cards with budgets, evidence, stop rules, approval boundaries, production/MVP intent, parallelization policy, and merge-review conditions.
beai resources --request "..." --apply	Select applicable tools, skills, and evidence resources by task surface.
beai rotation --apply	Choose the next field-readiness scenario by stale, risk, failure, and recent-change signals.
beai ecosystem readiness --apply	Crosscheck ecosystem expansion claims before MCP, Claude Code, OpenClaw, or generic CLI adapter work.
beai adapter completion --apply	Verify the local adapter layer as a single completion surface while keeping marketplace publication, external account connection, live runtime activation, and write-capable MCP actions outside the completion claim.
`beai claude-adapter scaffold	smoke --apply`
beai ledger --apply	Regenerate the public verification ledger from smoke and benchmark ledgers.
beai external-smoke --sample <path> --apply	Run the companion smoke flow against a copied external local sample.
beai release --apply	Write the GPAO for Codex release manifest and archive plan.
beai release archive --apply	Create the GPAO for Codex release tar archive.
beai release verify-archive	Verify archive entries against the release manifest.
beai release smoke-archive --apply	Unpack the archive and run bootstrap smoke.
beai readiness --apply	Regenerate the release-readiness decision.
beai readiness --apply --html	Regenerate readiness evidence and a human-facing readiness report in reports/.
beai baseline --apply	Regenerate the production baseline decision. This closes local product/release/plugin evidence enough for future work to start as upgrades, while keeping external stable-market validation separate.
beai baseline --apply --html	Write production baseline evidence and a browser-readable baseline report.
beai loop fit --goal "..."	Check whether a loop is justified before running one.
beai loop intent --goal "..." --apply	Convert a fuzzy improvement request into a loop intent contract with inferred intent, user benefit, included/excluded scope, verification basis, recommended loop design, stop condition, and clarification questions.
beai loop hold --goal "..." --apply	Record a deliberate no-loop decision when direct work is better.
beai loop plan --goal "..."	Write the loop plan with intent alignment, gates, budget, and stop rules.
beai loop run --goal "..." --apply	Run the evidence-recording loop scaffold with budget and stop rules.
beai loop compare --apply	Compare pre-patch and post-patch visual observations after a loop patch.
beai loop report	Show the latest loop report.
node scripts/install-from-archive.mjs	Bootstrap an unpacked archive in preflight-first mode.

Full reference: Command Reference.

Safety Model

The default posture is review-first.

• Most commands are read-only unless --apply is provided.
• Existing user files are classified before write.
• Applied files are tracked in a manifest with SHA-256.
• Existing targets are snapshotted before modification.
• Writes use atomic file replacement helpers.
• Rollback is blocked if a target changed after the recorded snapshot.
• Project config, hooks, connectors, and external integrations are not silently enabled.

See Safety Model.

For Non-Developers

The harness is meant to make Codex easier to direct without pretending software is magic.

brief and plan separate:

• What the product is.
• Who it is for.
• What the first usable outcome is.
• Which scenario should be built first: fast useful, safe complete, or growth-ready.
• Which screens are expected.
• Which data the product needs.
• Which integrations or risks require a decision.
• What a developer or Codex should build next.

For setup-heavy requests such as calendar/news/message automations, the harness should first surface a dry-run or safe scheduled scenario, keep automation paused until explicit approval, and route the work through doctor before completion is claimed.

The scenario engine is not tied to one example. It includes domain-aware paths for commerce, booking, dashboards, learning tools, task managers, messaging workflows, briefing automations, and developer workflow tools. Each domain can recommend a different first path when the user's words imply payments, reservations, team work, external messaging, or other safety-sensitive behavior.

plan carries the recommended scenario forward into a concrete user path, approval gates, verification path, and developer work. For example, a safe test order scenario should expose a payment/test-mode boundary before implementation, not bury it as a generic development detail.

verify, status, doctor, and recover then reuse that saved plan as scenario completion context. A project is not treated as confidently complete just because generic checks exist; the harness also reports the chosen scenario, approval gates, verification path, scenario verification evidence, and missing scenario steps. verify --scenario --meaning adds an explicit scenario verification gate for first success, empty or first-time state, failure or recovery state, and user-language acceptance hints.

The completion language guard blocks complete, done, and ready claims until route, plan, scenario completion, passing verify --run --scenario --meaning evidence, project completion gates, and unresolved blockers agree. Before that point, the correct language is applied but unverified or implemented but needs review.

The goal is not only to generate code. The goal is to help a user understand the project as it becomes real.

Developer Companion Contract

BEAI Harness follows this product rule:

AI does the work. User keeps authority.

For non-trivial development work, Codex should first shape the scenario, implement the smallest useful path, and verify success, empty, and failure states before asking the user for final review. The user's role is direction judgment, preference, real-world approval, and lived-context feedback.

More detail: Developer Companion Contract.

Documentation

• Quickstart
• Usage Prompt Templates
• Practical Use Cases
• Plugin Apply Check
• Command Reference
• MCP Read-Only Adapter
• MCP Expansion Policy
• Safety Model
• Install and Uninstall
• Codex Plugin
• Codex Plugin Orchestration
• OpenClaw Adapter Candidate
• Developer Companion Contract
• Security and Privacy
• Known Limitations
• Verification Ledger
• Release Checklist
• GitHub Release Notes v0.1.0
• Final Hardening Audit
• External Sample Smoke

Internal Korean planning documents remain under docs/00-charter through docs/05-implementation.

License

MIT. Copyright (c) 2026 윤 (@aigis0927). See LICENSE.