Process Design (build a new agent-runnable process)

Stand up the design engagement from the sponsor's brief — what process they want, what it must accomplish (the target outcome), any provided information/data, and typed constraints — and crystallize it into the ONE design source-of-truth: (1) a one-page Process Charter (name, single testable purpose, named terminal deliverable, scope in/out, trigger, owner, mode=New), (2) a FROZEN, versioned, hashed PROCESS-DESIGN OBJECTIVES RUBRIC (the meta-acceptance criteria every later review scores bricks against by line id), (3) an Assumption Register (each row tagged source=sponsor|assumption|process-default), and (4) an Open-Questions-to-Sponsor log. The sponsor PROVIDES information throughout but NEVER gates. Intake COMPLETES, never waits. CLARIFY-AND-SIZE (Sprint 117): Forge ASKS clarifying questions until the brief is properly scoped and captures a 1-10 SIZING score that drives the functional depth/breadth, user/access model, and controls.

Capture the ideal end-to-end flow as a SIPOC-grounded step map — an ordered sequence of steps each with actor, inputs, outputs, and handoff, plus the natural loops (rework/approval bounce-backs) and branches (it-depends-on-X) that become real control flow later. AUGMENT: Forge elicits and structures; the sponsor/SME supply facts and recognize it as real.

For each step decide whether and how AI should do it — grounded in the AI Opportunity Decision Tree (chatura-method-internal.md), not enthusiasm — classifying every step AUTOMATE / AUGMENT / ELIMINATE / CREATE / RESTRUCTURE, deciding AI-vs-human-vs-hybrid, and confirming the sponsor WANTS each AI step.

Turn each retained step into an agent-runnable contract per the step-contract schema (_SCHEMA.md) — the part that makes the process executable and stops agents improvising. CREATE: Forge generates a structured, testable contract per step that did not exist before.

Put the right worker on each brick — derive each brick's required skill from its contract, match a single accountable agent, and flag any skill gap as a new-agent spec for Pulse to create. AUGMENT: Forge proposes the RACI staffing.

Replace per-step human sign-off with an AI-owned review-and-iterate loop applied to EVERY brick contract. A non-author panel — Verdict (objectives-coverage + independence + adjudication), Proof (acceptance-criteria testability), and Cipher (guardrail/abuse-case completeness AND the adversarial red-team pass) — critiques each contract line-by-line against the FROZEN Objectives Rubric. A domain specialist is added ONLY when the brick's subject demands it and ONLY if staff_and_match_agents actually assigned one (never a phantom panelist); when present it produces its own verdict-deliverable and is named in the convergence record. Every gap becomes a GapLog entry; Forge fixes; the loop re-reviews (delta + regression). Each brick converges only on receipt-backed SOLID with open sev>=major gaps == 0.

Review the ASSEMBLED process for integration, not just brick-by-brick: no orphan handoffs (every output consumed, every input sourced), loop/branch/exception paths defined end-to-end, schema-lint clean, 0 unintended human gates, and alignment with the platform moat (contract-per-step, receipt honesty) and the 3-pillar vision. Atlas reviews against the moat/vision; Verdict runs convergence. Iterate to SOLID.

Freeze the converged design for the dry-run: stamp a semantic version, write a changelog, record the Source-of-Truth manifest (artifact hashes, register ids+versions+row counts, rubric hash), and write the binary DRY-RUN ACCEPTANCE CRITERIA a clean run-through must satisfy.

Pulse instantiates the finalized design in the platform via the receipt-backed authoring capabilities — create_process, add_step, set_step_contract, assign_agent_to_step, and create_agent for any new specialist — in a STAGING posture: attachable to a flow but isolated from production, so it can be run end-to-end as a dry-run. Every authoring action writes a ledger receipt.

A NON-author AI — the Proxy (Sponsor Proxy) — plays the human: it STARTS a real process run on the staged design, supplies the brief + intake exactly as a human sponsor would, and thereafter ONLY observes and performs human-assigned actions when a brick requests human-only input. This is the literal 'AI acting as human to initiate the run and take the actions assigned to humans, then observe.' Proxy must not be an author of the design (independence).

The process's own assigned agents execute the ENTIRE run end-to-end autonomously (the executor auto-advances; the design's own review-loop bricks gate, not a human; Proxy observes + supplies sponsor input). Every brick must produce a deliverable that passes its own acceptance criterion. This is 'AI running through the whole process run.'

Verdict independently reviews the dry-run against the finalized Dry-Run Acceptance Criteria: did every brick complete with an acceptance-passing deliverable? Where did an agent stall, improvise (claim without a receipt), loop unbounded, or fail acceptance? Each defect is a GapLog entry tied to the offending BRICK; Forge/Pulse fix the brick CONTRACT (not the run); re-provision + RE-RUN until the run completes cleanly and Verdict signs a receipt-backed SOLID. The dry-run is the design's acceptance test.

Pulse publishes the dry-run-proven process under semantic versioning with a changelog and receipts; prior versions preserved (nothing a running Flow depends on is overwritten); status flips active. Publication is gated by the dry-run convergence receipt, not a human approval.

Register the published process as live, link the dry-run evidence, and log residual follow-ups + the telemetry to watch in production (real-run completion rates, stalls, acceptance failures) so the next improvement is data-driven via process-redesign.