AI Build v0.7.0

v0.7.0 — live change requests / feature injection

AI Build can now accept new requirements after the roadmap has already been created:

ai-build change "Add Discord OAuth login"
ai-build change --file feature-request.md
ai-build changes

Applied changes are reconciled by Codex against the current target product, architecture, approved history, and future roadmap. Approved phases are immutable history. If a new request needs to alter behaviour that was already delivered, Codex creates forward corrective/migration work instead of rewriting the historical phase. Future unapproved phases may be added, removed, split, reordered, or replaced.

If ai-build change is called while a phase is actively being detailed/implemented/repaired/reviewed, the prompt is written to ignored runtime queue state and does not touch the current dirty worktree. The unattended build picks it up automatically at the next approved phase boundary, reconciles the future roadmap, creates a Git checkpoint, then continues.

Every applied change is persisted in two places:

• .ai-build/changes/CHANGE_<id>.md — audit record with request + Codex impact;
• .ai-build/REQUEST.md under Accepted change requests — so a later full ai-build plan cannot forget the new requirement.

A completed project can also be reopened with ai-build change; the previous phases stay approved and new work begins at the next phase number. Detailed executable phase specs remain just-in-time.

Claude model policy: balanced and quality use pinned claude-opus-5; --economy uses Sonnet for routine work.

v0.6.0 — quota-aware unattended mode + 5-hour usage optimisation

AI Build now treats provider usage exhaustion as saved waiting state, not an implementation/review failure.

When Codex or Claude reports a hard account usage limit, AI Build does not consume Codex retries, Claude recovery agents, review cycles, or the phase wall-clock budget. It records the exact phase stage and enters:

WAITING_FOR_CODEX
WAITING_FOR_CLAUDE

If the provider message includes a reset time and it is within usage.maxAutoWaitHours (default 6), unattended mode keeps the machine awake, waits through the reset, and resumes automatically. If a reset time is unavailable or too far away, the process exits safely and ai-build resume retries from the saved stage later.

Typical flow:

Claude implementation
      ↓
5-hour limit reached — resets 23:00
      ↓
WAITING_FOR_CLAUDE
      ↓
AI Build waits without spending recovery budget
      ↓
reset + safety buffer
      ↓
resume same phase/session automatically

The same behavior applies when Codex hits its plan usage allowance during just-in-time phase detailing or review.

Usage profiles

v0.6.1 keeps the v0.6 usage profiles and changes the default Claude model strategy for Max-plan users. Balanced is the default, including for older project configs that do not yet contain a usage block.

ai-build resume              # balanced
ai-build resume --economy    # maximum usage conservation
ai-build resume --quality    # deeper/more expensive routine work

The five-hour target is best-effort, not a guarantee: provider allowances are model/plan/task weighted and weekly limits also exist. The profile reduces burn rather than artificially sleeping between productive requests.

Claude model policy in v0.6.1: balanced and quality pin claude-opus-5; economy uses sonnet for routine work. Recovery/escalation can still move to Opus 5. An explicit claude.model value overrides the profile model choice.

Balanced/economy optimisations include:

• routine Claude implementation and repair on pinned claude-opus-5 in balanced mode; --economy explicitly switches routine Claude work to sonnet;
• medium Claude effort for routine work (low in economy mode), with higher effort reserved for recovery/escalation;
• routine Codex review at medium reasoning (low in economy mode), while escalated review remains deep;
• at most two ordinary review cycles in balanced/economy before switching to the existing escalated recovery path;
• just-in-time phase-detail prompts receive phase-relevant bounded excerpts instead of repeatedly embedding every full planning document;
• review diff context is capped at 100k characters instead of 200k;
• verification output passed to Codex is capped at 12k characters per command;
• Claude prompts explicitly prefer targeted reads/grep and avoid repeatedly dumping unchanged large files.

Anthropic explicitly recommends using Sonnet for execution after planning and documents effort as a token-spend control. OpenAI likewise documents reasoning effort as the main reasoning-token/latency tradeoff.

New config

New projects receive:

{
  "usage": {
    "profile": "balanced",
    "targetWindowHours": 5,
    "autoWaitForReset": true,
    "maxAutoWaitHours": 6,
    "resetBufferSeconds": 75
  },
  "claude": {
    "economyModel": "sonnet",
    "implementationModel": "claude-opus-5",
    "repairModel": "claude-opus-5",
    "recoveryModel": "claude-opus-5",
    "escalatedModel": "claude-opus-5",
    "qualityModel": "claude-opus-5",
    "escalatedModel": null,
    "implementationEffort": "medium",
    "repairEffort": "medium",
    "recoveryEffort": "high",
    "escalatedEffort": "high"
  }
}

Older .ai-build/config.json files do not need to be recreated; missing usage settings use the v0.6 defaults automatically.

Provider-wait recovery

ai-build status now surfaces the provider and reset information while waiting:

Status        WAITING_FOR_CODEX
Phase stage   REVIEWING
Waiting for   CODEX
Usage reset   2026-08-28T20:07:00.000Z

A process/PC restart during a provider wait is safe. Run ai-build resume; if the reset is still in the future and auto-wait is enabled, AI Build continues waiting, otherwise it retries the saved phase stage.

v0.5.1 — unattended autonomous build mode

AI Build now defaults to unattended delivery. Routine safety limits are circuit breakers that change strategy instead of stopping the build and waiting for an operator.

The unattended loop is:

Codex details current phase
        ↓
Claude implements
        ↓
max turns? → resume same Claude session
        ↓
still stuck? → fresh Claude recovery agent, preserve working tree
        ↓
Codex review
        ↓
CHANGES_REQUIRED → Claude repair → fresh Codex review
        ↓
ordinary review budget exhausted?
        ↓
fresh escalated Claude repair + higher-reasoning Codex review
        ↓
APPROVED → local Git checkpoint → next phase

AI Build stops only after autonomous recovery strategies are exhausted or before a phase whose roadmap objective itself requires a live external/production action such as a production deployment, production database mutation, DNS change, credential rotation, destructive production operation, or live payment configuration.

High-risk local code work such as authentication, RLS, billing logic, webhook handling, database migration files, and permission systems does not automatically stop unattended mode. Claude is still prohibited from performing live production mutations, and Codex reviews the implementation independently.

Default unattended controls

Old .ai-build/config.json files do not need to be recreated. Missing settings use these defaults:

{
  "automation": {
    "mode": "unattended",
    "preventSleep": true,
    "humanGatePolicy": "production-only",
    "maxPhaseHours": 4,
    "codexRetryCount": 1,
    "maxEscalatedRepairCycles": 1
  },
  "claude": {
    "maxTurns": 120,
    "maxTurnContinuations": 2,
    "maxRecoveryAgents": 2,
    "segmentTimeoutMinutes": 90
  },
  "codex": {
    "escalatedReviewReasoningEffort": "xhigh"
  }
}

Meaning:

• maxTurns: bounded Claude segment size.
• maxTurnContinuations: how many times AI Build resumes the exact same Claude session after error_max_turns.
• maxRecoveryAgents: fresh Claude sessions allowed after same-session continuation is exhausted or an agent segment fails/times out.
• codexRetryCount: fresh Codex retries for phase detailing and reviews after a CLI/timeout failure.
• maxEscalatedRepairCycles: fresh repair + escalated independent review cycles after ordinary review cycles are exhausted.
• maxPhaseHours: final wall-clock circuit breaker for one phase across implementation, repairs, and reviews.
• preventSleep: on Windows, a hidden helper requests system-awake while an unattended build is active. Display sleep remains allowed.

Commands

Unattended mode is the default:

ai-build start

or explicitly:

ai-build start --unattended

For the old stop-and-ask behavior:

ai-build start --interactive

ai-build resume uses the same unattended default. AI Build persists implementation/review stage, Claude session id, continuation/recovery counters, and phase timing in ignored .ai-build/state.json, so process interruption can resume from legitimate in-progress work rather than requiring a clean restart.

Windows keep-awake

While an unattended start/resume process is alive on Windows, AI Build uses SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED) from a hidden PowerShell helper. It does not request ES_DISPLAY_REQUIRED, so the monitor can turn off. The request is released when AI Build exits.

v0.4.1 — resilient Claude implementation sessions

Claude Code's --max-turns flag exits with an error when the limit is reached. AI Build now detects the error_max_turns result, captures the Claude session id, and automatically resumes the same session up to claude.maxTurnContinuations times (default 2). Interrupted implementation state is persisted so ai-build resume can continue from legitimate dirty working-tree changes instead of rejecting them. Set claude.maxTurns to null to use Claude Code's unlimited default, or tune maxTurnContinuations for a bounded multi-segment implementation.

v0.4.0: Existing-project planning now uses just-in-time phase detailing. ai-build plan creates the repository assessment, target product spec, completion architecture, and concise remaining-phase roadmap, then commits roadmap stubs. ai-build start expands only the next phase into a full executable Codex specification, commits that specification, and only then lets Claude Code implement it. This avoids spending tens of minutes pre-generating dozens of phase specs that may be stale by the time they run.

Recovery from v0.4.0 turn-limit pauses

If v0.4.0 stopped with Claude Code exited with code 1 after showing a run at roughly the configured maxTurns, upgrade in place and run ai-build resume. Do not reset the working tree. v0.4.1 recognizes that legacy interrupted-implementation shape and continues from the existing edits.

During new runs, the final Claude stream result is classified by subtype. error_max_turns is resumable; other error subtypes remain failures. The active Claude session id and continuation count are stored in ignored .ai-build/state.json while implementation is in progress.

v0.4.0 just-in-time existing-project delivery

Large existing repositories use a bounded repository evidence pack during planning. AI Build reads high-signal repository material itself, excerpts large files, excludes secrets/build output, and gives Codex a capped evidence pack instead of allowing open-ended repository dumps.

Existing-project ai-build plan now has only three Codex stages:

1. Repository assessment + target product from bounded evidence.
2. Incremental completion architecture.
3. Concise remaining-work roadmap.

It deliberately does not pre-generate full implementation specifications for every remaining phase. A large project may have dozens of phases; generating all of them up front is slow, expensive, and later phase detail can become stale after earlier implementation changes.

Instead, ai-build start / ai-build resume uses just-in-time detailing:

roadmap committed
    ↓
Codex details Phase N only
    ↓
detailed Phase N spec committed locally
    ↓
Claude implements Phase N
    ↓
Codex reviews / Claude repairs
    ↓
approved phase checkpoint
    ↓
Codex details Phase N+1

The roadmap phase identity is locked. Just-in-time detailing is rejected if Codex changes the approved phase number, slug, name, risk, human-gate flag, or objective. The detailed phase spec is committed before Claude edits application code, so each implementation starts from a clean, reviewable Git baseline.

New optional config control (old project configs do not need editing):

{
  "codex": {
    "justInTimeDetailTimeoutMinutes": 8
  }
}

Each phase-detail call has its own timeout. A timeout pauses the build before Claude starts; rerunning ai-build resume retries only that current phase detail. Earlier approved phases remain untouched.

Previous release notes

v0.3.2

v0.3.2 staged existing-project planning

Existing repositories now use the same staged planning philosophy as greenfield projects, but with repository inspection isolated to the first stage:

1. Repository assessment + target product — Codex inspects high-signal application files only and records what already exists, what is incomplete, the current milestone, architecture/security invariants, migration state, CI/tests and the remaining-work basis.
2. Completion architecture — zero repository/tool calls; Codex synthesizes the incremental architecture from the assessment and target product spec.
3. Remaining implementation phases — zero repository/tool calls; Codex creates phases for remaining work only and explicitly excludes already-complete capabilities.

This prevents large existing repositories from spending one monolithic planning session inspecting code and then timing out while also trying to synthesize the entire product spec, architecture and phase plan.

Existing-project planning now writes an additional file:

.ai-build/plans/REPOSITORY_ASSESSMENT.md

The Windows assessment prompt is PowerShell ConstrainedLanguage-safe: it forbids [pscustomobject], custom .NET types and other FullLanguage-only constructs, and it still avoids stale .ai-build metadata.

Default existing-project planning controls (old configs do not need editing):

"codex": {
  "existingAssessmentReasoningEffort": "medium",
  "existingSynthesisReasoningEffort": "low",
  "existingAssessmentTimeoutMinutes": 8,
  "existingSynthesisTimeoutMinutes": 5
}

The repository snapshot is also smaller and more targeted: top-level entries, likely guidance/manifests/CI/phase docs, and a representative path sample are surfaced instead of dumping up to 500 arbitrary paths into the prompt.

v0.3.1 version reporting fix

• ai-build --version now reads the version directly from package.json.
• Fixes v0.3.0 incorrectly reporting 0.2.5 because of a stale hard-coded CLI constant.
• Prevents the displayed version drifting from the installed package in future releases.

A local orchestration CLI for this loop:

Codex architect → Claude Code implementer → Codex adversarial review → Claude repair → Codex approval → local Git checkpoint → next phase

Designed primarily for Windows + PowerShell, but the Node CLI is cross-platform.

v0.3.0 staged greenfield planning

Greenfield planning is now split into three visible Codex stages instead of one large structured response:

1. Product specification
2. Architecture
3. Master plan + implementation phases

This avoids long periods where the terminal can only show heartbeat messages while Codex builds one very large JSON object. Each stage has its own live session, completion line and log file. Greenfield stages default to low reasoning because there is no repository archaeology to perform; existing-project assessment defaults to medium, existing-project synthesis defaults to low, and adversarial reviews remain high.

No private chain-of-thought is displayed. AI Build streams normal agent/tool activity and explicit stage progress only.

Existing projects do not need to edit config.json; the new greenfield reasoning setting defaults safely when absent. Optional override:

"codex": {
  "greenfieldPlanReasoningEffort": "low"
}

v0.2.6 greenfield planner / Windows CLM fix

• REQUEST.md and config.json are now embedded directly into the Codex stdin prompt by the orchestrator. Codex no longer needs a shell command just to read the brief.
• On greenfield repositories, Codex is instructed to make zero shell/tool/MCP calls during planning and return the structured plan directly.
• Avoids PowerShell ConstrainedLanguage failures caused by richer constructions such as [pscustomobject] inside the Codex Windows sandbox.
• Existing repositories still allow a bounded set of read-only application-repository inspection calls, but .ai-build is never re-read from disk during planning.
• Keeps the v0.2.5 hard timeouts, inspection budgets, live activity renderer, stale-plan recovery, Windows shell workaround, and Git Bash command-resolution fixes.

v0.2.5 planner hang protection

• Adds an orchestrator-generated repository snapshot before Codex starts. Empty/greenfield repositories are identified without asking Codex to recursively inspect them.
• Adds a strict planner inspection budget: at most 8 repository-inspection tool calls, no repeated probes, no MCP enumeration, and an explicit stop condition once enough evidence is gathered.
• Planning now defaults to medium Codex reasoning while adversarial reviews remain high.
• Adds a 5-minute hard planning timeout and a 10-minute hard review timeout. Both are configurable.
• Timeout handling kills the complete Codex process tree and rejects partial structured output.
• Prevents ai-build/agent-recovery problems from becoming application implementation phases.
• Keeps the v0.2.4 stale-plan isolation and all earlier Windows/Git Bash fixes.

Existing projects do not need to recreate .ai-build/config.json; missing v0.2.5 settings use the safe defaults automatically. To override them, add:

"codex": {
  "model": null,
  "reasoningEffort": "high",
  "planReasoningEffort": "medium",
  "greenfieldPlanReasoningEffort": "low",
  "reviewReasoningEffort": "high",
  "planTimeoutMinutes": 5,
  "reviewTimeoutMinutes": 10,
  "existingAssessmentReasoningEffort": "medium",
  "existingSynthesisReasoningEffort": "low",
  "existingAssessmentTimeoutMinutes": 8,
  "existingSynthesisTimeoutMinutes": 5
}

v0.2.4 planning hygiene

Fresh planning now treats .ai-build as orchestrator metadata rather than application source. Codex is allowed to read only .ai-build/REQUEST.md and .ai-build/config.json; stale generated plans, phases, logs, reviews and state are explicitly excluded from repository inspection so a failed earlier plan cannot bias the replacement plan.

On Windows the planner also no longer assumes Ripgrep (rg) exists. It is instructed to verify rg first and otherwise use Git/PowerShell-native file inspection without repeated failed tool calls.

v0.2.4 Git Bash / Windows command discovery fixes

• Handles Git Bash / MINGW64 command discovery without relying on cmd.exe to search a potentially MSYS-shaped PATH.
• Normalises duplicate Windows PATH / Path environment keys before launching children.
• Runs the same node.exe that is already executing AI Build.
• Resolves git.exe directly instead of routing Git through a shell.
• Prefers the supported native Claude Code binary at %USERPROFILE%\.local\bin\claude.exe when present.
• Resolves npm-installed Codex/Claude .cmd shims and, when they are standard npm shims, unwraps them to their underlying JavaScript entry point and launches it with Node directly.
• ai-build doctor now displays the executable/shim path it resolved for each tool on Windows.
• Keeps the v0.2.2 Codex WindowsApps / PowerShell sandbox workaround.

v0.2.2 Windows fixes

• Removes Microsoft Store / WindowsApps PowerShell aliases from the environment passed to Codex, avoiding the current Codex Windows sandbox CreateProcessAsUserW failed: 1920 failure. This does not change your system PATH.
• Prefers a machine-wide PowerShell 7 install when present, with Windows PowerShell available as a fallback on PATH.
• Stops using Node shell:true with argument arrays, removing the Node DEP0190 deprecation/security warning.
• Planner/reviewer prompts now explicitly forbid apply_patch, write probes, and sentinel edits. Codex remains read-only.

Why Codex never writes application files

ai-build deliberately runs Codex in read-only mode for both planning and review.

For planning, Codex returns a JSON-schema-constrained plan to the Node orchestrator. The orchestrator writes the markdown plan/phase files itself.

That gives the two agents clear responsibilities:

• Codex: architecture, planning, adversarial review
• Claude Code: application implementation and repair
• ai-build: state, safety gates, test command execution, Git checkpoints

Prerequisites

• Node.js 20+
• npm
• Git
• OpenAI Codex CLI, already authenticated
• Claude Code CLI, already authenticated

Verify manually:

node --version
npm --version
git --version
codex --version
claude --version

Install

Published npm package:

npm install -g @real_fuzzed/ai-build@latest
ai-build doctor

Local development install on Windows

Unzip this folder somewhere permanent, for example:

C:\AI-Tools\ai-build

Open PowerShell in that folder:

Set-ExecutionPolicy -Scope Process Bypass
.\install.ps1

Or install manually:

npm link
ai-build doctor

Once linked, ai-build is available globally.

First project

Go to an existing repo or an empty folder:

cd C:\Projects\my-app
ai-build init

If the folder is not a Git repo, ai-build initializes Git.

Now edit:

.ai-build\REQUEST.md

Describe the application in detail.

Then:

ai-build plan

AI Build injects the request/config directly into Codex. Codex inspects only the actual application repo when needed, in read-only mode, and produces:

.ai-build/
  REQUEST.md
  config.json

  plans/
    REPOSITORY_ASSESSMENT.md   # existing projects only
    PRODUCT_SPEC.md
    ARCHITECTURE.md
    MASTER_PLAN.md

  phases/
    index.json
    PHASE_001_....md
    PHASE_002_....md
    ...

  completions/
  reviews/

  # ignored local runtime state:
  state.json
  logs/
  runtime/

ai-build plan creates a local Git planning checkpoint. It never pushes.

Read the plan, then:

ai-build start

Live agent activity

ai-build now renders both agent CLIs live instead of leaving the terminal on a single status line.

During Codex planning/review you can see useful activity such as:

[Codex] Session ... started
[Codex] Analysing repository and requirements…
[Codex] → Command: git status --short
[Codex] ✓ Command finished (exit 0)
[Codex] → Command: cat package.json
[Codex] ✓ Command finished (exit 0)
[Codex] ✓ Structured result produced
[Codex] ✓ Turn complete

During Claude implementation/repair you can see normal assistant messages plus tool activity:

[Claude] I’ll inspect the existing routing and tests first.
[Claude] → Glob: src/**/*.ts
[Claude] → Read: src/routes/index.ts
[Claude] → Edit: src/routes/index.ts
[Claude] → Bash: npm test
[Claude] ✓ Bash finished
[Claude]   output:
    42 tests passed
[Claude] ✓ Agent run complete

This is activity visibility, not private chain-of-thought. The renderer deliberately ignores any hidden thinking/reasoning blocks. It shows ordinary agent messages, commands, files/tools used, command/test output, progress events and final review results. If an agent is silent while processing, a heartbeat is printed after the configured interval so you can tell the process is still alive.

Raw machine-readable streams are still saved under .ai-build/logs/ for troubleshooting.

Live-output configuration

The defaults are:

"live": {
  "enabled": true,
  "showToolOutput": true,
  "maxToolOutputChars": 4000,
  "heartbeatSeconds": 15
}

Set showToolOutput to false if command output is too noisy, or set enabled to false to return to quiet mode.

The phase loop

For each phase:

1. The worktree must be clean.
2. Claude Code receives only the current phase + master architecture/spec.
3. Claude implements it and writes a completion report.
4. The Node orchestrator runs only allow-listed local test/lint/build/check commands from the plan.
5. The orchestrator captures git status, git diff, and verification output.
6. Codex reviews the real repo in read-only mode using a strict structured schema.
7. If CHANGES_REQUIRED, the review is written to .ai-build/reviews/ and Claude gets a repair prompt.
8. Review/repair repeats up to maxReviewCycles (default 3).
9. APPROVED creates a local Git commit.
10. Next phase starts.

In unattended balanced/economy mode, ordinary review rejection changes strategy rather than immediately stopping: after at most two routine review cycles AI Build launches the existing escalated repair + deep Codex review. Only exhausted autonomous recovery becomes BLOCKED. Interactive mode retains stop-and-inspect behavior.

Human gates

The planning schema lets Codex mark a phase:

"humanGate": true

for high-risk work such as production deployment, payments activation, destructive/irreversible operations, DNS/infrastructure, or credentials.

Before Claude can even start that phase, ai-build stops.

Review the phase and then:

ai-build approve
ai-build resume

The implementation prompt still forbids autonomous production mutations. Human-gate approval only allows the local implementation/preparation phase to continue.

Commands

ai-build
ai-build doctor
ai-build init
ai-build plan
ai-build change "Add a feature or revise a requirement"
ai-build change --file feature-request.md
ai-build changes
ai-build start
ai-build resume
ai-build status
ai-build approve
ai-build help

Configuration

Edit:

.ai-build/config.json

Default:

{
  "version": 1,
  "maxReviewCycles": 3,
  "codex": {
    "model": null,
    "reasoningEffort": "high",
    "planReasoningEffort": "medium",
    "reviewReasoningEffort": "high",
    "planTimeoutMinutes": 5,
    "reviewTimeoutMinutes": 10
  },
  "claude": {
    "model": null,
    "maxTurns": 120,
    "permissionMode": "acceptEdits",
    "allowedTools": "Bash,Read,Edit,Write,Glob,Grep"
  },
  "live": {
    "enabled": true,
    "showToolOutput": true,
    "maxToolOutputChars": 4000,
    "heartbeatSeconds": 15
  },
  "verification": {
    "runPlanCommands": true,
    "commandTimeoutMinutes": 20
  },
  "git": {
    "autoCommitApprovedPhases": true
  }
}

model: null means use the model currently configured/defaulted by that CLI.

Pinning a Codex model

For example:

"codex": {
  "model": "gpt-5.6-sol",
  "reasoningEffort": "high"
}

If a specific Codex CLI/model combination has a local-tool regression, set model back to null and let the installed CLI use its current default.

Claude model

You can similarly set the Claude Code model string accepted by your installed CLI, or leave it null.

Git safety

ai-build:

• refuses to start a phase when the Git worktree is already dirty
• creates local commits only
• never runs git push
• blocks automatic checkpointing if staged filenames look like secrets such as .env, .pem, .key, credentials.json, etc.
• keeps runtime logs/state ignored under .ai-build/

This is a safety net, not a secret scanner. Your repository should still have a correct .gitignore.

Verification command safety

Codex can propose neutral verification commands per phase, but the orchestrator will execute only an allow-list of common test/lint/build/typecheck/check commands.

Examples commonly accepted:

npm test
npm run lint
npm run build
npm run typecheck
pnpm test
pytest
python -m pytest
cargo test
go test ./...
dotnet test

Commands involving deployment, Git push, destructive DB actions, network tooling, infrastructure apply, etc. are rejected.

Important limitations of v0.2

• This is intentionally CLI-to-CLI orchestration, not the Codex/Claude SDKs yet.
• The orchestrator has no third-party runtime npm dependencies; it uses Node's built-in process APIs.
• It assumes the CLIs are already logged in.
• Different repositories have different tool/test needs; expand the verification allow-list carefully rather than allowing arbitrary shell commands.
• Agent prompts are strong guardrails, but Claude Code still has real local coding capabilities. Use a development repo, not a directory full of unrelated sensitive files.
• No automatic production deployment is implemented.
• No automatic network/credential mutation is implemented.
• No cloud background daemon is implemented.

Recovery

State is stored in:

.ai-build/state.json

If the terminal or PC closes:

cd C:\Projects\my-app
ai-build status
ai-build resume

The state file is local and intentionally ignored by Git.

Prompt templates

The actual agent prompts are plain text files in the installed ai-build package:

prompts/plan.txt
prompts/implement.txt
prompts/review.txt
prompts/repair.txt

So you can inspect and tune exactly what each agent receives.

v0.2.2 recovery fixes

This release also fixes a planning-checkpoint failure seen on Windows where a commit message could be split into Git pathspecs by the old shell launcher. The new launcher keeps arguments intact. Replanning now removes stale ai-build-owned PHASE_*.md/plan files only after Codex has successfully returned a valid new plan, and git add -A is used for the planning paths so deletions from failed or older plans are staged correctly. REQUEST.md and config.json are preserved.

If a v0.2.0/v0.2.1 planning attempt failed after writing files, simply install v0.2.2 and run ai-build plan again. You do not need to run ai-build init again or manually delete the stale generated phase files.

v0.5.1 reliability fix

• Claude result.subtype === "success" is now the authoritative completion signal (with is_error !== true), even if the CLI wrapper process reports a non-zero OS exit code.
• A process/result disagreement is logged as a warning instead of triggering unnecessary recovery agents.
• The npm package is scoped as @real_fuzzed/ai-build and includes all runtime-required schemas/ and templates/ files.
• The executable remains ai-build.