Role Fabric Runtime productization overview

Role Fabric Runtime productization overview

Status: historical exact BUILT_LOCAL and LIVE_LOCAL evidence retained; exact-subject local
source/unit evidence is accepted for this delivery; Quality Fabric MCP availability is separately
tracked by CON-4964 and is not a Role Fabric blocker; no image supply or public deployment
Date: 2026-08-22
Updated: 2026-08-30
Product name: Role Fabric
Current boundary: local, single-host, SQLite, effect NONE

P1 landing-root source migration — 2026-08-30

The active product boundary now uses
role-fabric coherently across descriptor,
authority code, workflows and systemd source. The external
role-fabric-tools root is unchanged. This successor
is source-only: the occupied host checkout has not been migrated, mounted,
admitted, deployed or observed. Historical evidence below remains bound to its
explicit commit/tree and cannot be transferred to this change. The Operator
has clarified that no current server hold exists; later hold language is a
historical observation, not present control state. That correction does not by
itself authorize a runtime or deployment effect.

D1 fresh-host prerequisite controller — 2026-08-30

The source candidate adds
infra/scripts/role_fabric_prerequisite_provision.py as a root-intended,
prerequisite-only boundary. Its closed plan/apply/readback contract binds the
exact clean protected-main landing commit/tree; rejects worktrees; creates or
readbacks the exact Role Fabric and Temporal volumes plus shared and internal
client networks; and validates fixed secret-file custody/readability metadata
without reading values into a receipt. Exact replay is idempotent. Existing
wrong, incomplete or unowned objects are never adopted or relabelled. Partial
cleanup is limited to exact newly created objects that remain unused.

This closes the missing source procedure for fresh-host external-resource
provisioning. It does not close operational provisioning: the controller has
not run on a disposable or Dev host. It also does not issue certificates,
start the persistent Temporal Compose stack, initialize its schemas or
namespace, install/activate systemd, deploy the first Role Fabric runtime, or
prove product effectiveness. D2 first runtime deployment remains a separate
boundary. Quality Fabric is not required to implement D1; external QF
availability remains the independently tracked CON-4964 concern.

Correction status — 2026-08-28 locally committed, pending push/merge/landing

The delivery-control correction now present in the dedicated worktree is pinned to local commit
f49659801206070230d56745c252d497c9a2fab9, tree
9af321da4247affeefc15705ea4e9ca2d147d4e3. Its honest state is *SOURCE / COMMITTED LOCALLY /
UNPUSHED / UNMERGED / NOT LANDED / NOT DEPLOYED*. The Dev
server is under an operator-announced maintenance hold, so this correction authorizes no runtime,
container, service, CI, SUPPLY or deployment effect. Exact-subject local source/unit testing is an
accepted delivery route; the frozen-source result below is assigned to this exact committed subject. The
worktree is temporary and must never be a runtime, container/service-test or deploy
source. For the current correction, this section supersedes later /opt release, copied-code and
selector directions; those passages and earlier local or QF results remain evidence only for their
explicitly named historical subjects and do not validate the correction.

The correction source adds or tightens these productization boundaries:

• durable asynchronous status: broker admission and status polling are separated from the

controller's long-running operation. SUBMITTED and EXECUTING come from the durable ledger;
closed terminal response artifacts and recovery-time reconciliation are source-defined. This is
not yet interruption evidence;

• verified-SUPPLY producer/import custody: the local self-hosted supply workflow produces the

signed image/SBOM/custom predicate, but cannot write broker evidence. A root-operated verifier
admits one exact selection and produces a closed HMAC-authorized verified-SUPPLY record; a
separately invoked offline importer validates and installs it into the broker's fixed evidence
root and replay ledger. Workflow artifact availability is not broker admission;

• canonical project and exact landing: services/role-fabric-deployer/ is the standard project

home and its closed runtime.v1.json declares the admitted inputs and boundaries. Runtime units
execute only from the fixed root-custody clean-main checkout
role-fabric. No worktree or Actions workspace is a landing source;

• automated root-owned exact-main advancement: each integrated, SUPPLY or promotion job on a

named local self-hosted runner requests a whole-workflow lease through
/run/conduir/role-fabric-landing-advance.sock. The root-owned
infra/scripts/role_fabric_landing_advance.py verifies the requested SHA against the protected
GitHub main tip, performs an authenticated exact fetch, refuses non-fast-forward movement,
quiesces the broker, advances the standard landing, invokes admission and restores the broker's
prior activation state only after successful admission or an unchanged landing. The workflow
receives only the source tree and opaque lease token, not Git or landing-write authority;

• admission and bounded freshness: infra/scripts/role_fabric_landing_admit.py records the

exact commit, tree, descriptor digest and runtime-input hashes in
/var/lib/conduir/role-fabric-landing/landing-identity.v1.json; no /opt copy, selector,
temporary worktree or Actions workspace is an admitted code source;
systemd entrypoints verify that receipt before start, and the controller independently
revalidates it and the exact landing source before each operation and afterward. Workflow socket
root service execution is bounded to 2,700 seconds, all five clients to 3,000 seconds and every
job to 4,200 seconds, lease release is attempted in an
always() step, and the root policy gives abandoned leases a finite expiry. Drift refuses rather
than inheriting a prior read;

• incumbent Temporal identity and drain: apply must bind and repeatedly re-observe the live

incumbent's address, namespace, Docker network and network ID, TLS server name, CA fingerprint
and client-certificate fingerprint through its exact read-only certificate mounts. Target
Temporal values cannot substitute. Workflow and task-queue JSON must match a closed recognized
shape and the requested incumbent queue name/type or cutover refuses;

• activation freshness: after incumbent stop, source requires an unchanged signed quiescence

receipt, unchanged operator fence evidence, exact store census and drained incumbent. It repeats
the drain and all receipt/fence/store/freshness checks immediately before candidate activation;

• local-only automation: integrated diagnostic and image SUPPLY select the named Conduir

self-hosted pool; manual promotion selects the isolated local Dev request pool. There is no
GitHub-hosted runner path and no automatic deployment after supply; and

• test acceptance: retained exact-subject local source and unit results are accepted for this

delivery. Quality Fabric MCP availability remains separately tracked by CON-4964; it is not a
merge, landing, supply or deployment prerequisite for Role Fabric. Runtime/container/browser
execution remains paused by the maintenance hold and must later use the canonical landing.

The following are still unresolved and prevent a product-ready or deployed claim: exact-head
failure-terminal/interruption and systemd-timeout behavior; the asymmetric external-ingress fence
custody in which apply verifies a root/operator measurement rather than independently measuring
the host refusal; complete Dev-host provisioning of the canonical landing, root-custody identity,
landing-advance socket/service/policy/read credential/request group, units, credentials, request
runner, verified-SUPPLY verifier/importer, Temporal mTLS material and fence/quiescence authority;
initial bootstrap of the admitted advancer; and exact-head advancement/lease, CI,
signed-supply, import, drain, protected-apply, same-digest restart/recovery and public-runtime gates.
The maintenance hold must be released before any runtime gate is attempted. Until those gates run,
this remains source-defined automation, not a landed or operating pipeline.

Frozen-source evidence and custody census

The exact locally committed subject passed 130 tests plus 13 subtests in 2.13 seconds across the nine
Role Fabric contract, broker/client/controller, quiescence, runner-admission, store and landing
control-plane modules enumerated in the testing artifacts document. py_compile, Ruff, the runtime
descriptor, duplicate-key YAML/JSON validation, static systemd verification and git diff --check
passed. The only systemd diagnostic was the host's unrelated legacy acpid warning.

The staged tracked index contains *16,798 100644 regular files, 327 100755 executable files and 12
safe tracked 120000 symlinks. Regular files are exact Git-blob/mode bound; tracked symlinks are
lstat/readlink-checked without traversal and their link text must equal the exact Git blob.
Runtime/request inputs remain regular-only, and gitlinks, non-zero index stages and other modes
refuse. Ordinary execution remains in role-fabric. The one closed
pre-verifier exception is the immutable recovery helper at
/usr/local/libexec/conduir/role_fabric_landing_recover.py; it still requires separate maintenance
installation through infra/scripts/install_role_fabric_landing_recovery.py plus principal,
credential, unit, socket and admission provisioning. No runtime, Docker, systemctl, Quality
Fabric, CI, SUPPLY or deploy action is claimed. The lifecycle state remains COMMITTED LOCALLY /
UNPUSHED / UNMERGED / NOT LANDED / NOT DEPLOYED*; CON-4964 remains separate and non-blocking.

First-bootstrap circularity is closed in source by requiring the exact
BOOTSTRAP-ROLE-FABRIC-LANDING-RECOVERY-TCB confirmation, durably retaining one source-bound
partial record across the installed-copy, identity-history and current-identity crash windows,
rerunning the complete admission gate, and cleaning the partial only after full admission succeeds.
Eight installer/bootstrap tests are included in the 130-test denominator; no bootstrap or
maintenance effect was performed.

The only untracked path is .artifacts/; it is excluded from the pinned commit/tree and from every
landing, runtime and deployment input.

0. 2026-08-28 integrated recomposition delta

This pass preserves the original Role Fabric product boundary and adds an integration and delivery
harness around it. The classifications are binding for interpreting the artifacts:

The work is isolated in branch feat/role-fabric-compose-cicd-20260828 and dedicated worktree
.wt/conduir-evolution/role-fabric-compose-cicd-20260828. The branch is based
on the open, unmerged Role Workflow MCP edge PR #3442, head
42a46c0bde9792b5552afb969b1d0639cac70d01. The integrated harness depends on that PR's mounted
/v1/mcp/role-workflow surface and five-tool contract. The executable follow-on is committed at
3ac2a1dcfa735d1909fa494e80ab9cf0561f352d, tree
546d49b0dd825b9075a77ad2d303285d53ddd0d3; until #3442 and this follow-on are admitted, it is
feature-branch rather than mainline SOURCE evidence.

External review PR #3470 assessed earlier snapshot bf48b307. Its finding-by-finding disposition
against this newer candidate is recorded in Section 9.2 of
ROLE-FABRIC-INTEGRATED-STACK-CICD-2026-08-28.md. The current workflow removes PR/manual
execution, path filters, registry writers and delivery claims. Main execution, signed same-digest
supply and deployment remain open; QF browser tooling is separate under non-blocking CON-4964.

The prepared automation consists of:

• infra/compose/role-fabric/compose.e2e.yaml, a private, no-host-port recomposition topology;
• infra/scripts/role-fabric-compose-e2e.sh, which checks deep readiness, immutable version

binding, the MCP OpenAPI and five-tool contract, role-bound dispatch, live Webchat BFF reads,
page rendering, write refusal and cross-site refusal, and writes a subject-bound JSON summary;

• .github/workflows/role-fabric-integrated-cicd.yml, a tracked post-merge diagnostic candidate on

the named local pool; it has no PR/manual trigger, registry writer, image supply or deployment
authority; and

• delivery/team-role-queue-temporal-execution/ROLE-FABRIC-INTEGRATED-STACK-CICD-2026-08-28.md,

the operator and evidence contract for this layer.

Current evidence ruling: the historical pre-selector MCP slice passed outside the sandbox with
26 passed and zero skipped; current selector-rejection tests require a fresh exact-subject local
source/unit run. The
corrected seven-unit integrated harness passed locally in r11 labelled as executable
commit 3ac2a1dc..., including supported Auth session minting, selector-free six-duty MCP custody,
terminal kernel state, exact Temporal PASS, and authenticated Webchat HTTP/refusal checks. The local
result is admissible for its named historical subject under the operator override; it does not
transfer to the current correction. QF passed the Webchat Role Fabric Jest scope (30 passed, 4 declared skips, 0 failed;
execution 591b3317-56e9-4653-894d-53757b491fea) and full MCP service scope (88/88; execution
7d7f689f-e703-4a1f-b07b-6094706f8231). QF also passed the corrected Symposium image-context
parity check 1/1 as execution bc1095e9-ea6a-4ea1-9289-e252cb0585c1, but its Playwright request
collected zero tests. That Quality Fabric MCP/browser limitation remains a separate CON-4964
finding and does not block Role Fabric. No coverage, image supply, registry, deployment or new public
effectiveness pass is claimed by this document.

Separately, the ambient public read projection was repaired and freshly observed: the page and
Webchat control health return 200, while /api/role-fabric/runs returns 200 AVAILABLE with six
retained runs. conduir-webchat-cndk is healthy on loopback 48011, and the prior container is
preserved stopped as conduir-webchat-cndk-pre-role-fabric-20260828. The existing Role Fabric
backend was attached additively to conduir-net under alias role-fabric-runtime. This is not a
deployment of the follow-on: the deployed d15 backend's authenticated HTTP MCP route remains 404,
so a newer backend image is still pending.

1. Outcome

Role Fabric turns an admitted work graph into a visible factory floor. A requirement becomes typed
work; role-numbered agents take custody through their own queues; validators and independent
reviewers return typed outcomes; a certifier closes the exact subject; Temporal durably starts and
observes the run; and the Webchat console projects the current floor without gaining mutation
authority.

The current candidate productizes the backend process boundary that was previously launched only
from source. It does not claim that the target production architecture is complete.

2. Five-component end picture

1. Role Fabric Console
   public/operator factory-floor projection
                     |
                     | fixed same-origin GET bridge
                     v
2. Role Fabric Runtime
   role registry + queues + custody + receipts + bounded read model
        |                         |
        | observation             | role-workflow MCP
        v                         v
3. Temporal                 4. Role agents
   durable wait/retry          Designer-N, Builder-N, Validator-N,
   and run observation         Reviewer-N, Certifier-N, Overseer-N
        |                         |
        +------------+------------+
                     v
5. Evidence and evolution loop
   exact subjects -> checks -> findings -> remediation -> certification
   -> observed outcome -> separately admitted workflow improvement

Component 2 is the Phase 0 work/custody truth. Component 3 is not a chat store and is not the
custody truth. Component 4 has no implicit role or effect authority. Component 5 can propose and
test changes but cannot merge or deploy without a separately admitted effect path.

3. Current implementation

Supplied now

• standalone process entry point python -m symposium.team_execution.runtime_service;
• dedicated Docker target role-fabric-runtime, running as uid/gid 10001 with a read-only root,

dropped capabilities, a persistent /app/data volume and deep readiness healthcheck;

• service-only Compose profile on registered loopback port 48119;
• discovery, immutable version/build identity, liveness, readiness and Prometheus metrics;
• required SQLite store and canonical API instance identity readiness components;
• optional service-only and required-ready integrated Temporal compositions;
• instance-scoped workflow and administrative Temporal task queues, preventing one Role Fabric

store from consuming another runtime's observations;

• a store-owned random API instance identity that survives restart and scopes both Temporal queues

and workflow IDs without accepting an operator-selected identity;

• authenticated POST /v2/team/admin/workflows/start, which starts only the external-agent

workflow and never registers role-execution activities;

• a fail-closed bootstrap that creates six numbered role bindings, exact-0600 context files, a

sanitized receipt and the durable Temporal workflow;

• replay-safe binding issue, workflow start and self-revoke mutations; ambiguous transport or

gateway outcomes retain custody and emit RECONCILIATION_REQUIRED rather than guessing rollback;

• replay-safe role credentials derived only when the administrative key satisfies the generated

32-byte lowercase-hex contract; weak or human-readable keys fail before network or filesystem
effects, and the same runtime/run/key tuple reproduces the exact credential after response loss;

• tools/run_productized_role_fabric_workflow.sh, the one-command six-agent read-only analysis

and lifecycle path against an already-ready integrated runtime; the public multi-seat runner
refuses workspace-write before bootstrap because it cannot yet bind distinct managed worktree
assignments to write-capable seats;

• internal-key administrative surface, server-bound per-role agent credentials and keyless gated

read projection for the fixed Webchat BFF;

• exact-run session supervisor with closed mode-0600 state and cleanup receipt;
• preflight of every deterministic tmux target before durable workflow acceptance, explicit admin

key removal from every agent/control/supervisor process, and terminal self-revocation of the exact
six role bindings; control-session refusal and supervisor exit-before-ready both create private
reconciliation evidence, stop only exact owned sessions and preserve nonterminal bindings;

• explicit Role Fabric server-only configuration in the Webchat env contract.

Still target work

• a worker process registry so the console can show proven process presence instead of UNKNOWN;
• a persistent supervisor/allocation store and bounded run-event/evidence APIs;
• PostgreSQL/multi-host fencing (considered, not required for Phase 0);
• a default overseer role with a durable escalation queue;
• admission and effect controllers for merge/deploy operations;
• observed-outcome and workflow-optimization records;
• deployment to dev and same-digest browser/cold-restart evidence.
• retain an accepted QF execution of the authenticated browser denominator against the exact final

subject; local r11 validates the terminal recomposition harness diagnostically;

• preserve r11's terminal kernel/Temporal evidence when binding the eventual main diagnostic and

any future tested image digest;

• retain the push-main-only local-runner boundary and gating cleanup residue receipt; prove runner

capacity and obtain owner review through the external admission process;

• design signed same-digest supply separately if delivery is required; it is absent here;
• merge PR #3442 or rebase the follow-on onto an equivalent reviewed MCP-edge commit before the

follow-on can become mainline source;

• an admitted generation/time/cost budget so an adversarially useful correction loop cannot run

without a bounded escalation point;

• a digest-bound prevalidated bootstrap envelope to reduce the measured cold role-start cost while

retaining fail-closed source verification.

• distinct managed worktree allocation and assignment envelopes for each write-capable role before

either public multi-seat runner can support workspace-write; a shared assignment is prohibited.

4. Dependency modes

The service-only Compose profile deliberately leaves Temporal optional. The integrated overlay
joins the existing Temporal laboratory's declared Docker network, requires temporal:7233, and
will not report ready until both the Temporal connection and the scoped control workers are ready.
It does not start or own the Temporal cluster.

5. Authority and security boundary

• Public health/discovery/version/metrics endpoints grant no authority.
• Console reads are available only behind the explicit lab-console gate and same-origin policy.
• Browser traffic uses the Webchat fixed GET-only BFF; it receives no internal or role credential.
• Admin mutations require X-Internal-Key.
• Agent operations derive identity from X-Role-Binding; tool bodies cannot select a role, run or

principal outside the supplied session context.

• The Phase 0 workflow remains authority_effect: NONE.
• CORS is denied by default and, if configured, exposes only GET and read headers.
• Bootstrap failures before Temporal acceptance revoke every binding in reverse issue order.

Failures after Temporal acceptance retain the private contexts and bindings and write a
RECONCILIATION_REQUIRED receipt; Phase 0 has no run-cancellation contract, so it never hides a
still-running workflow behind a false rollback claim.

• A mutation-side redirect, timeout, rate limit or HTTP 5xx is treated as an unknown outcome, not a

definite rejection. The paired request token makes a retry safe, and unresolved custody remains
explicit. HTTP 400/401/403/404/405/409/415/422 remains a definite refusal.

• Credential recovery requires the same runtime identity, run identity and stable generated

administrative key. Rotation while an issue result is unresolved is an explicit reconciliation
event, not a condition under which the launcher invents a new credential.

6. Lifecycle behavior

tools/run_productized_role_fabric_workflow.sh calls the bootstrap, creates the control session,
starts one read-only Codex, Claude or packet-bound session for each of the six fixed Phase-0 roles,
and starts the same lifecycle supervisor used by tools/run_phase0_self_evolution.sh. This public
path is analysis-only until distinct per-role write assignments exist. A workspace-write request
fails before bootstrap, control-session, or role-session effects. The supervisor:

1. validates the closed mode-0600 state;
2. recomputes every owned tmux session name from run ID and role instance;
3. watches the exact run and control session;
4. allows a bounded grace period after terminal state;
5. stops only exact owned sessions after terminal state, control loss or deadline;
6. self-revokes each exact binding with its own credential after terminal state; and
7. writes a mode-0600 cleanup-receipt.json, reporting CLEAN only when the run is terminal,
owned sessions are absent and all binding revocations are proven.

This closes the observed stale-worker class in which a failed control plane left role MCP clients
polling a loopback port later reused by an unrelated process.

7. Current maturity

The table above describes the exact 2026-08-22 d15f0d10d evidence. It must not be silently
transferred to the committed 2026-08-28 feature-branch candidate. For the newer candidate, source
is exact at 3ac2a1dc..., integrated execution is PASS_LOCAL_DIAGNOSTIC for that historical
subject, diagnostic
CI is SOURCE_READY / NOT_RUN, image delivery is absent, and public deployment remains NOT_AUTHORIZED and
NOT_DEPLOYED.

8. R6 effectiveness result

role-fabric-productized-r6 ran six independent Codex role sessions against the integrated local
runtime and completed at generation 4. The role kernel recorded 18 exact work rows: 12 completed
and six failed review rows. Both review lanes returned NEEDS_CHANGES for generations 1 through 3;
generation 4 passed validation, architecture review, adversarial review and independent evidence
certification over subject
fb3dece7351deafb679a953d8c05926bf7cab6922b2b22ef46e187f4a924695f.

Temporal closed the workflow with all four path-neutral checks true, 63 retained observation
changes, zero dropped observations and authority_effect: NONE. Its history contains 3,365 events
and 560 activity completions, all using the instance-scoped administrative queue. The historical
lifecycle supervisor then stopped only the remaining R6-owned role/control sessions and wrote a
mode-0600 CLEAN receipt with no remaining sessions. That older supervisor did not revoke the six
bindings. During migration to the corrected runtime, those six terminal R6 bindings were explicitly
self-revoked; the unrelated active Designer-91 binding for a separate running canary was preserved.
The corrected supervisor now includes that exact revocation denominator before it can emit CLEAN.

The corrected exact runtime image was force-recreated three times and exposed matching commit, tree
and image identities through /version and role_fabric_build_info. Its generated API instance ID
was identical across every recreation. The named volume retained R6, and the factory-floor page continued
to render its terminal state through the fixed no-store BFF. A disposable live canary proved exact
binding-issue replay and exact self-revoke replay while disclosing no credential.

This is local candidate evidence, not a deployment claim. The R6 store intentionally retained one
earlier disposable persistence-test run/binding, so R6 proves run isolation and correct projection
in a non-empty store; it is not an empty-database bootstrap proof. Cold pinned-source verification
also took roughly two to three minutes per role turn. That cost is acceptable for Phase 0 evidence,
but should be reduced before increasing queue throughput.

9. Related sources

• delivery/team-role-queue-temporal-execution/ROLE-FABRIC-SHARED-ARCHITECTURE-AND-INTERFACE-SPEC-2026-08-21.md
• delivery/team-role-queue-temporal-execution/RF-LIVE-SHIFT-AND-SELF-EVOLUTION-HANDOFF-2026-08-22.md
• services/symposium/src/symposium/team_execution/README.md
• services/webchat/src/features/role-fabric/RoleFabricConsole.tsx
• tools/run_phase0_self_evolution.sh
• tools/team_role_session_launcher.py
• infra/compose/role-fabric/compose.e2e.yaml
• infra/scripts/role-fabric-compose-e2e.sh
• .github/workflows/role-fabric-integrated-cicd.yml
• delivery/team-role-queue-temporal-execution/ROLE-FABRIC-INTEGRATED-STACK-CICD-2026-08-28.md