A local-first code audit system connecting requirements, architecture, security checks, behavioral evidence, specialty AI review, and actionable repairs.

CF Code Factory
Governance infrastructure for high-stakes agentic workloads

Audit code.
Review evidence.
Resolve defects.

Your agent has finished a change. Your review comes next. Follow a local finding back to its source, inspect the recorded checks, and choose the repair you want to make. Rerun the affected checks and keep the evidence with the change before deciding what to accept. This static preview shows the workflow; it does not scan or upload your repository.

Code Factory 0.49.6 binds collection evidence before native scan sealing and carries it into audit handoffs. PyPI package 0.49.6 · GitHub release 0.49.6.

✓ Local by default ✓ No source upload ✓ No model account required ✓ Human decides what may be applied ✓ Missing evidence stays visible
Factory Studio Product Mission draft with intent and review callouts
Factory Studio Product Mission with fictional example input.

Code Factory 0.49.6

The exposed N443-38 replay measured 88.24% decided actionable precision (30/34), up from 85.71% on the same observed cases. It returned 37 of 38 cases and retained all 30 original true positives. Two labels remained unclear. Case 005 timed out.

The original sealed reference measured 83.33% among 36 decided alerts and 78.95% across all 38 cases. Two AI reviewers supplied the labels. Read the case ledger.

Get the verified wheel · Zenodo record

What’s new in 0.49.6

  1. Pre-PR review. factory change pre-pr <manifest> combines candidate source, planned checks, oracle evidence, and feature verification in one receipt. Add --execute to run the declared checks.
  2. Repair continuity. factory senior fix returns NO_PROGRESS for a repeated failed candidate and STEP_BACK when the round budget is spent. The default budget stops before a fourth round.
  3. Incident intake. Reviewed incidents produce source-bound regression packets marked EXPOSED_NOT_EXECUTED. Replay evidence records what was exercised.
  4. Scan evidence. Native scans bind collection receipts before sealing. Collection drift marks the evidence incomplete and requires a fresh seal.
  5. CLI and editors. factory home prints a local invitation to star the repo. Editor releases are VS Code and Open VSX 1.3.3 and JetBrains 1.3.4.

The complete factory

  • FactoryLine Coordinates local audits, evidence, and review decisions.
  • ForgeLine Builds scoped changes and challenges their checks.
  • SpecLine Defines the intent, requirements, and acceptance criteria those checks must prove.

Coordinated code audits with visible evidence and limits

Inspect progress, findings, and repair tasks from one candidate-bound run. This static preview explains the workflow; it does not scan or upload your repository.

Workflow boundary: Native-harness evidence is separate from package inclusion and provider availability.
Keep useful context

Resume incident reviews and compare fixes

The native harness keeps incident checkpoints for recovery, binds review context shards to source, and compares candidate repairs without applying them. Budgeted Jev triage keeps unprocessed incidents visible as pending, not assessed.

Explicit controls

Choose when parallel audits and hooks run

Parallel audits are opt-in and require a signed policy declaring work non-mutating and resource-safe; serial remains the default, and the declaration does not prove isolation. Optional activation experiments call only hooks explicitly registered by the caller. Their observations are experimental, not model certification or accuracy evidence. The source taxonomy and manifest define the same routes for Junie while keeping execution and identity limits visible.

Fixed

Missing audit status

Native editor views distinguish unavailable, incomplete, failed, stale, and not-run checks. A static inventory no longer looks like a completed audit.

Changed

Review the evidence route

Junie's taxonomy now directs reviewers from intent and diff through bounded checks, concrete repairs, reruns, and independent specialty AI review.

Added

Project-neutral workflow audit

factory audit workflows evaluates declared checks and profiles against hash-bound candidate and execution evidence. Missing or stale evidence blocks a complete result.

Candidate fixes

Hollow assertions and tenant-read contracts

The Python scanner flags missing local assertions, constant-true assertions, and reflexive comparisons. Explicit tenant-read contracts check the declared tenant parameter binding; they do not authenticate tenants or prove runtime isolation.

Seeded demonstration

Review a finding and a repaired case

This seeded local example applies a declared tenant-read contract to sample inputs and presents the review workflow. It is illustrative only, not a release certification. CI verification is still required.

Current editor releases

Review evidence in your IDE

VS Code and Open VSX 1.3.3 show local evidence and source locations in Explorer. JetBrains 1.3.4 carries forward saved-file synchronization before local commands and starts Factory Studio in the background.

During a run

Progress with evidence

Deep-audit execution records lane progress, cancellation, source bindings, and coverage gaps. Unsupported or missing evidence remains incomplete.

After a run

Actionable repair tasks

Findings include source locations and remediation guidance. Fresh candidate evidence is required after a repair; a disappearing finding alone does not prove a fix.

Agent review

A separate specialty reviewer

Specialty AI audit evidence is available: source reviews, identified defects, and reviewed corrections. Open the agent review and evidence → Test and CI receipts remain separately identified.

Current limits: CF pattern and guard-path audits require a project policy; its security scan inspects Python ASTs. ForgeLine repo-wide QA is a static inventory. Native Gitleaks input accounting and full-depth certification remain incomplete. Muse catalogues and workflows do not establish Meta marketplace approval.

Read the audit implementation and limits →

JUnit cases appear after a local test runner writes .factory/test-reports/pytest.xml. Reports over 10,000 cases or malformed inputs are marked incomplete.

Useful before code, during review, and when tests say green.

Choose the smallest proof surface that answers the question in front of you. A fresh starter stays blocked until product-specific checks replace hollow coverage.

01 · Decide

Pin down intent

Bind the human-chosen framework, outcome, acceptance evidence, and external-effects boundary to exact PRD bytes.

02 · Clarify

Grill the PRD

Surface source-bound questions and incompatible requirements before code exists.

03 · Review

Challenge the green check

Delete, invert, and corrupt declared controls. A surviving mutation blocks the claim.

04 · Retry only with evidence

Stop repeated failures

Require a changed candidate and fresh evidence for a supervised retry, or deliberately halt.

Supervised proof of survival

Can this behavior survive the exact failure you are worried about?

Gauntlet turns human-written E2E sabotage cases into one inspectable batch. A named reviewer admits one current local run; the resulting Survival Card shows every declared case as survived, hollow, or blocked. A green card is not a production, security, coverage, performance, quality, or release certificate.

factory gauntlet plan --root . --source gauntlet.json --json
# Review the exact local E2E pairs, then make a named one-run admission.
factory gauntlet run .factory/gauntlets/<source>/<proposal>.proposal.json \
  --root . --admission .factory/gauntlets/<source>/<admission>.admission.json --json
factory gauntlet card verify .factory/gauntlets/<source>/<card>.card.json --json
Your reviewer stays in control

Use AI review suggestions and deterministic proof on the same PR.

Code Factory complements CodeRabbit or another reviewer with one neutral, commit-bound proof walkthrough: exact scope, declared proof gaps, and the next fact-derived action. It does not need their account, copy their comments into receipts, approve, or merge code.

factory github proof-review \
  --root . \
  --base origin/main \
  --head-sha <pull-request-head-sha> \
  --json
LangGraph resume assurance

Compare the reference path with a resume, before review.

Record transitions in your own LangGraph test harness, then compare sealed, hash-only reference and resumed lineages. The assurance bridge reports parity only when supplied transitions match and no deterministic stale state, duplicate completed effect, or unsafe parallel write is present. A divergence produces a Mermaid incident capsule with the first divergent node and a review-only causal cone. It never invokes a graph or replays an effect.

factory langgraph replay-verify \
  --root . \
  --reference .factory/langgraph/reference.json \
  --resumed .factory/langgraph/resumed.json \
  --out .factory/langgraph/assurance.json --json
Journey proof · audited healing

Prove the real journey. Audit the agent that repairs it.

Journey Reality compares declared and observed states, transitions, requirements, and outcomes without turning missing evidence into success. Failure Capsules keep the failed step and adjacent evidence bounded. Stateful Workflow Proof checks producer and consumer state, cleanup, and idempotency. Healing stays human-controlled or supervised-auto, and a candidate is accepted only when its positive proof passes, its negative control fails, and the repairing agent passes an independent scope-and-evidence audit.

BYOK and local execution remain the default. A future managed tier must use the same verifier. No mode grants approval, merge, release, credential, or production authority.

factory journey reality declared.json observed.json --root . --json
factory journey capsule failure.json --root . --json
factory journey workflow-proof workflow.json --root . --json
factory journey heal-verify request.json --root . --json
Verified counterfactual repair

Compare every plausible fix. Accept only the proven winner.

Graph Forensics identifies the first semantic divergence. ProofSearch binds its exact proof slice to 2–12 local candidates, rejects failed proofs, surviving mutants, scope escapes, test weakening, and error suppression, then explains the minimum-risk and minimum-scope winner. Evidence Frontier ranks supplied, non-executing checks by how many viable repair pairs they separate. Predictions are hypotheses, never proof or authority. Time, token, and cost savings stay unavailable until paired measurements exist.

factory proofsearch plan --root . \
  --baseline baseline.lineage.json \
  --candidate failed.lineage.json \
  --changed src/service.py --out repair.plan.json
factory proofsearch evaluate candidates.json \
  --root . --out repair.evaluation.json --json
factory proofsearch frontier plan frontier.request.json \
  --root . --out frontier.json --json

Explore the current Factory Studio and Graph Ops views.

These annotated views use the released interface and a fictional local workspace.

Observed creator use

One 60-day case, with the estimate separated from the evidence.

Local Codex metadata identified 25 FactoryLine-related tasks, 133 completed turns, 2,710 command runs, 785 MCP or app calls, and 555 file-change events. A transparent counterfactual model estimates 30–110 hours of gross manual-equivalent capacity over 60 days after a 50% overlap haircut. This is a one-user case, not a benchmark or guaranteed ROI; net savings must subtract tool cost and human oversight.

Code Factory 60-day personal case study separating observed local Codex metadata from a modeled capacity range.
Starter example · one check in the audit system

See Code Factory catch a hollow test in under two minutes.

Run a safe negative-control demonstration, receive a local receipt, and explore one small part of the audit system. The demo runs only in a generated local sandbox. It proves the positive control can pass, catches the hollow negative control as HOLLOW_E2E_TEST, and writes a privacy-safe Proof Card. No account, model key, or source upload is required.

pip install factoryline-code-factory
factory first-proof --root .

# Then use it on real work:
factory mvp "Build an approval tracker" --root .
factory coverage --root .\my-mvp --json
factory graph ops --root .\my-mvp --json
SaaS Reality · provider-neutral local proof

Did the customer who paid receive the right access?

A successful login is not authorization, and a successful checkout is not entitlement proof. Code Factory follows supplied local evidence from OAuth/OIDC identity and tenant role through checkout, verified webhook, entitlement, feature access, and revocation. It works across standards-compliant providers, keeps unknowns blocked, rejects raw credentials, and never contacts or mutates the provider.

factory saas verify --root . \
  --contract saas-contract.json \
  --evidence observed-events.json \
  --json
AppForge · catch the review gap early

Improve your app before Apple finds the missing proof.

Move from a story-led iOS storyboard to 30 exact-build checks spanning completeness, purchases and restore, iPad navigation, authentic screenshots, accessibility, privacy, metadata, reviewer access, and export compliance. Conditional rules must be explicitly required or not applicable with a named reviewer—omission never becomes green.

AppForge is designed to save avoidable rework and days of review waiting by surfacing preventable gaps before submission. It does not guarantee Apple approval.

factory revenue appforge-design --root . \
  --brief appforge-design-brief.json --json

factory revenue app-review-gate --root . \
  --contract app-review-contract.json \
  --evidence app-review-evidence.json --json
Agent workflows · verify the path

Keep the workflow. Independently verify every handoff.

Import a secret-free workflow envelope and check its typed stage graph, scoped capabilities and handoffs, checkpoint continuity, exact source bytes, resume lineage, and sealed intent binding. Code Factory rejects drift without starting the workflow or inheriting its authority.

factory atomic import --root . \
  --envelope .factory/atomic/run-envelope.json --json

factory atomic status --root . --json
See the proof state

Follow the proof path without giving it authority.

Unified Graph Ops connects the local Product Graph, value slices, missions, approvals, completions, proofs, gate plans, traces, receipts, supplied-policy dossiers, and artifacts into one bounded visual result. Its Proof Observatory makes current coverage, blocked gates, and supplied-policy drift legible in a responsive graph, bar, and donut view. It recommends one next action from current facts and never executes a gate or release action.

factory graph ops --root . --json
factory graph ops --root . --mermaid
factory studio --root .
Independent verification

Keep the builder and verifier separate.

Proof Review, Verified Repair Sandbox, and Workspace Load Advisor make the local handoff visible before a repair or environment change. The Verifier Plane binds a worker receipt to distinct verifier evidence, immutable check files, deterministic checks, and hard budgets. These surfaces never edit code, call a model, or claim a production sandbox. Start with factory prd grill PRD.md --root . --mode quick.

factory verifier session .factory/missions/<mission>/mission.json ./candidate \
  --bundle ./verification/checks.json --owner engineering-owner --root .
factory verifier verify ./session.json ./worker-result.json ./verifier-result.json --root . --json
factory verifier progress ./attempts.json --json
Design is part of the review

Make UI quality visible before a human says yes.

For UI-scoped work, the optional Prestige Design Review adds a purpose-led brief and reviewer-visible checks for hierarchy, responsive behavior, affordances, consistency, and declared design tokens. Deterministic findings can inform a gate; heuristic critique stays a human prompt. It does not claim conversion, WCAG certification, or production readiness.

pip install code-factory-4-design
prestige init --root .
prestige pr app.html --design DESIGN.md --root . --out-dir .prestige/pr
Proof reuse

Reuse evidence only when the inputs still match.

Content-addressed receipts route read-only gates to RUN, REUSE, SKIP, or BLOCK. Exact reuse verifies every bound input and output; ambiguity runs again, and side effects stay blocked.

factory proofs record proofs.json \
  --gate python-tests --elapsed-ms 600000 --root .
factory proofs plan proofs.json --changed src/app.py \
  --auto-savings --out proof-plan.json --root .
First local run

Start locally. See the next proof gap immediately.

Create a contained MVP, then let Graph Ops reveal the requirement or receipt that needs evidence. A starter is useful starting state, not a readiness claim.

pip install factoryline-code-factory
factory mvp "Build an approval tracker" --root .
factory studio --root .\my-mvp
# Open Graph Ops in the local Studio
Launch terms

Clear dates. No surprise paid change.

The GitHub Assurance Seat is free through December 1, 2026, with a $5.95 USD per named seat per month offer scheduled for December 2, 2026. It is built around commit-bound proof review, visible Proof Debt, supplied-policy drift dossiers, governed exceptions, and exportable evidence—not source access or opaque AI-token resale. The separate JetBrains Marketplace plan remains $4.95 USD per month from January 1, 2027, subject to JetBrains approval and a planned 30-day trial. Neither checkout nor entitlement is live; total price, taxes, fees, and billing terms must be shown before any approved purchase.

Marketplace count: check the current listing
Unique installs: not exposed by the listing
Adapter publication status: consult each Marketplace listing

Never substitute CI or repository traffic for installs.

Creator case study and visual identity.

The 60-day creator case documents one historical workflow.

Actual product capture set. The interface captures show actual product behavior. The case-study image separates observed metadata from an assumption-based capacity model; it is not universal productivity, cash-savings, conversion, Marketplace approval, or production-readiness evidence. Open the visual policy →

Make the next change carry its own proof.