Handbook

L3 — Use-case slice

Status: Demonstrated (grade b) — PoC runs with cross-layer and E2E evidence (lenses-production-l3-ci; retro-tag L3.1b).

Updated 2026-07-26

Level at a glance


Autonomous unit	End-to-end user-visible flow inside one existing app (UI + logic + data + tests)
What stays fixed	Existing architecture, single platform
Human gate	Intent + acceptance in; review out

Canonical policy: Autonomy levels (Blueprints).

Sub-levels

Sub-level	Autonomous unit	Status	Page
L3.1	Slice in sandbox app	Demonstrated (retro-tag L3.1b)	L3.1
L3.2	Slice in a production repo on a branch	Defined	L3.2
L3.3	Slice including data/schema migration	Defined	L3.3
L3.4	Multiple slices under one campaign	Defined	L3.4

L3.x E2E evidence must come from a registered runner allowlist — a test name that merely resembles an E2E runner does not count.

Building blocks at this level

Building block	Role at L3	Handbook link
Forge Dark Factory (PoC)	Multi-unit plan across layers; E2E verification script	Bounded execution examples
forge-lcdl	Patch units tagged by layer (`logic`, `docs`, `ui`); proof with E2E	Platform reference architecture §5
forge-workcells	Worker ladder per layer unit	Forge micro-agent
forge-lenses	Evidence review posture (intent in, review out)	Workflows and runs
blueprints	L3 assay: ≥2 layers, .py + non-.py, E2E in `tests_run`	Autonomy levels

Reference architecture flow

L3 use-case slice flow

How intent and acceptance criteria become a cross-layer slice with E2E proof and assay before human review.

[Intent + acceptance criteria in]Human supplies bounded intent and acceptance criteria before execution starts.
Dark Factory PoCDecomposes the slice into a multi-unit plan across layers.
plan: 3 unitsSchedules logic, docs, and ui patch units for apply and verify.
[.py]Logic-layer unit applies changes and runs bounded verify.
[md]Docs-layer unit applies changes and runs bounded verify.
[html]UI-layer unit applies changes and runs bounded verify.
E2E verificationEnd-to-end runner confirms the user-visible flow passes.
assay gateRecords multi-layer, mixed-file, and E2E pass evidence when status is pass.
[Human: review out + merge]Operator reviews evidence and approves merge after gates pass.

    [Intent + acceptance criteria in]
          |
          v
    +------------------+
    | Dark Factory PoC |
    | decompose (M)    |
    +--------+---------+
             |
             v
    +------------------+
    | plan: 3 units    |
    | logic | docs | ui|
    +--------+---------+
             |
       +-----+-----+-----+
       v     v     v
    [.py]  [md]  [html]   apply+verify per unit
       |     |     |
       +-----+-----+
             |
             v
    +------------------+
    | E2E verification |  verify-docs-health-l3.py
    | (Playwright etc.)|
    +--------+---------+
             |
             v
    +------------------+
    | assay gate       |  layers >= 2
    |                  |  .py + non-.py changed
    |                  |  e2e_pass recorded
    +--------+---------+
             |
             v
    [Human: review out + merge]

Gates and evidence

All L2 evidence, plus when final_status == pass:

≥2 distinct layers touched (logic, docs, ui, etc.)
Both .py and non-.py files in the changed-files union
E2E pass recorded in tests_run (Playwright, verify-docs-health-l3, or equivalent)

PoC evidence: L3-ui-smoke and L3-scan-flow (lenses-production-l3-ci campaign) — sandbox docs-health-l3:

app/scanner.py (logic)
README.md (docs)
ui/index.html (ui)
E2E: scripts/verify-docs-health-l3.py

Implemented vs planned


Implemented	L3 assay rules in `assay_gate.py`; multi-layer PoC campaigns; E2E verification hook
Not implemented	Platform ForgeRun-native L3 enforcement; production app slices outside PoC sandbox
Planned	Lenses ForgeRun campaigns with L3 manifest constraints; Playwright integration in workcells

Forge Platform