assemble

name	assemble
description	Assemble — deterministic impl-level orchestrator. Loops over implementation.useCaseRefs[], drives Forge per useCase, aggregates into edition CSVs + manifest. Pure transformation; AI judgment lives behind handshake beacons.
disable-model-invocation	false
argument-hint	[implementation-code] [--useCase <code>]

Assemble

The impl-level deterministic orchestrator. Reads implementation.json (selection record) + referenced useCase YAMLs at data/industries/<industry>/useCases/<code>/useCase.yaml, drives Forge per useCase, aggregates per-useCase artifacts into impl-level outputs. See .claude/rules/forge-as-ide.md.

This skill is a translator. Every action maps 1:1 to a registered subcommand of @commission/assemble. No improvised chains, no ad-hoc tsx scripts. AI invocation goes through @artifactjs/handshake beacons (assembleAiBeacons triple, requestAi() helper) — never through direct model calls inside Assemble code paths.

Reference

• .claude/rules/forge-assemble-split.md — load-bearing architectural rule (Forge per-useCase vs Assemble impl-level)
• .claude/rules/handshake-protocol.md — the broader handshake rule
• commission/assemble/CLAUDE.md — package contract
• data/industries/<industry>/useCases/<code>/useCase.yaml — self-contained canonical artifacts Assemble reads via Forge's composeUseCaseShape

Determinism guarantee

Given identical inputs (same implementation.json + same useCase YAMLs + same directive YAMLs + same shared catalog), Assemble produces byte-identical output every run. No model calls, no judgment, no observation-based branching in the code path. When a gap requires AI judgment (a useCase YAML referenced but missing on disk, a binding that needs human clinical authoring), Assemble publishes a structured request beacon and waits for the AI session to publish a response. Code stays deterministic; AI lives strictly on the OTHER side of the beacon.

CLI surface

Pipeline verbs (deterministic transformation):

pnpm --filter @commission/assemble exec tsx src/cli.ts compose      --impl <code> [--useCase <code>]
pnpm --filter @commission/assemble exec tsx src/cli.ts trace        --impl <code> [--useCase <code>]
pnpm --filter @commission/assemble exec tsx src/cli.ts source       --impl <code> [--useCase <code>]
pnpm --filter @commission/assemble exec tsx src/cli.ts all          --impl <code> [--useCase <code>]

Implementation editing primitives (Forge-as-IDE):

pnpm --filter @commission/assemble exec tsx src/cli.ts impl list                    [--industry <code>] [--useCase <code>]
pnpm --filter @commission/assemble exec tsx src/cli.ts impl show           --code <code>
pnpm --filter @commission/assemble exec tsx src/cli.ts impl create         --code <code> --useCases <a,b,...> [--label <text>]
pnpm --filter @commission/assemble exec tsx src/cli.ts impl add-usecase    --code <code> --useCase <code>
pnpm --filter @commission/assemble exec tsx src/cli.ts impl remove-usecase --code <code> --useCase <code>
pnpm --filter @commission/assemble exec tsx src/cli.ts impl fork           --from <code> --to <code> [--note <text>]

Verb	What it does
compose	For each useCase in implementation.useCases[], invoke composeUseCaseShape(implementationId, useCaseCode). Writes per-useCase shape.yaml.
trace	Materialise trace.yaml from shape.yaml per useCase.
source	Aggregate per-useCase trace files into edition CSVs.
all	Run the full pipeline (compose → trace → source).
impl list / show / create / add-usecase / remove-usecase / fork	Edit canonical implementation.json artifacts. The registered translator-role bindings for implementations — never hand-edit implementation.json or implementations.csv.

--useCase <code> scopes the pipeline run to one useCase. When omitted, all useCases on the implementation are processed.

Invocation

When the user runs /assemble <implementation-code>:

1. Resolve the implementation at data/industries/<industry>/implementations/<implementation-code>/implementation.json. If missing, stop with a clean error.
2. Validate the implementation carries selection-record shape: useCases[] with { code, bindings }.
3. Run assemble all --impl <implementation-code>.
4. If a useCase YAML referenced by the implementation is missing or lacks entityScope, compose throws with actionable guidance. For genuinely novel structural gaps, Assemble's handshake protocol can publish a usecase-author or gap-resolution request beacon and wait for an AI session to fulfil it.
5. On success, summarize: useCases processed, directives counted, CSVs written.
6. On failure, surface the structured envelope (category, hint).

When to use this vs /commission

• /commission <impl> runs the FULL lifecycle (Forge per useCase → Assemble → Audit → Charter → Mount → Certify → Appraise). Use this when you want to take an implementation through end-to-end.
• /assemble <impl> runs ONLY the Forge-per-useCase + Assemble portion — useful when you've changed a binding or template and want to re-emit the per-useCase artifacts + edition CSVs without re-running downstream stages.
• For a single useCase: /assemble <impl> --useCase <code> scopes to that useCase only.

Outputs

• data/industries/<industry>/useCases/<code>/views/{shape,trace,...}.yaml — per-useCase derived artifacts
• data/industries/<industry>/implementations/<impl>/forge/{appoint,constitution,pillar-verdicts}.yaml + manifest.yaml — impl-level
• data/health/editions/<edition>/application/*.csv — aggregated edition CSVs (after source; new emissions land at data/industries/<industry>/implementations/<code>/edition/application/)

Don't

• Don't call composeUseCaseShape from a tsx one-liner — go through the CLI verb.
• Don't add model calls inside commission/assemble/src/ — issue an AI handshake request via requestAi() instead.
• Don't bypass the handshake when a template is missing — the structural guarantee is that AI invocation is observable through beacons, not ad-hoc.