fix(#1264 ): preserve portable standalone launch

fix(#1264 ): harden unattended identity bootstrap
fix(#1264 ): bootstrap fleet identity without a TTY
2026-08-16 19:01:26 -05:00 · 2026-08-16 18:33:39 -05:00 · 2026-08-16 17:37:32 -05:00
33 changed files with 1537 additions and 976 deletions
@@ -9,19 +9,19 @@ This book is the canonical home for installation, configuration, deployment, rou
 - [Documentation atlas](../README.md) — placement rules and source-of-truth boundaries.
 - [Documentation sitemap](../SITEMAP.md) — resolvable current navigation and authority-gated migration summary.
 - [Product requirements](../PRD.md) — normative requirements, currently marked draft.
- [Operations index](operations/README.md) — current local procedures and explicitly held operational outlines.
+- [Operations index](operations/README.md) — current local procedures, unattended fleet first-start handling, and explicitly held operational outlines.
 - [Security index](security/README.md) — current SSO provider configuration.

 ## Chapter map

-| Chapter                               | Scope                                                               | Status                                                                  |
-| ------------------------------------- | ------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| `installation/`                       | Prerequisites, installation, and first deployment.                  | Scaffold only.                                                          |
-| `configuration/`                      | Environment, provider, tier, and runtime configuration.             | Scaffold only.                                                          |
-| `deployment/`                         | Topologies, rollout, migration, and upgrade procedures.             | Scaffold only.                                                          |
-| [`operations/`](operations/README.md) | Health, observability, routine operation, and maintenance.          | Local upgrade/recovery is current; connector lease operations are held. |
-| [`security/`](security/README.md)     | Authentication, authorization, SSO, secrets, and security controls. | SSO provider guide is current; other pages are planned.                 |
-| `recovery/`                           | Incident response, backup, rollback, and recovery.                  | Scaffold only.                                                          |
+| Chapter                               | Scope                                                               | Status                                                                                         |
+| ------------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| `installation/`                       | Prerequisites, installation, and first deployment.                  | Scaffold only.                                                                                 |
+| `configuration/`                      | Environment, provider, tier, and runtime configuration.             | Scaffold only.                                                                                 |
+| `deployment/`                         | Topologies, rollout, migration, and upgrade procedures.             | Scaffold only.                                                                                 |
+| [`operations/`](operations/README.md) | Health, observability, routine operation, and maintenance.          | Local upgrade/recovery and fleet first start are current; connector lease operations are held. |
+| [`security/`](security/README.md)     | Authentication, authorization, SSO, secrets, and security controls. | SSO provider guide is current; other pages are planned.                                        |
+| `recovery/`                           | Incident response, backup, rollback, and recovery.                  | Scaffold only.                                                                                 |

 Every promoted page must be added to this index and to [`SITEMAP.md`](../SITEMAP.md) in the same migration slice.

@@ -5,6 +5,7 @@
 ## Current procedures

 - [Upgrade safety and recovery](upgrade-safety-and-recovery.md) — installed-CLI and local-PGlite upgrade, rollback, and framework-configuration recovery.
+- [Fleet unattended first start](fleet-unattended-first-start.md) — systemd/no-TTY identity initialization, failure handling, and isolated verification.

 ## Held procedures

@@ -0,0 +1,70 @@
+# Fleet Unattended First-Start Operations
+
+> **Status:** Current after issue #1264 lands. This runbook covers only Mosaic's first-run identity
+> gate; it does not install runtimes or credentials.
+
+## Operational contract
+
+A systemd fleet unit launches under a sanitized environment with no TTY. The generated environment
+sets `MOSAIC_AGENT_NAME`; Mosaic resolves that exact value against the canonical installed roster
+before writing identity files.
+
+If top-level identity contracts are missing, Mosaic atomically seeds them from the shipped generic
+sources:
+
+| Destination            | Source                          | New-file mode |
+| ---------------------- | ------------------------------- | ------------- |
+| `$MOSAIC_HOME/SOUL.md` | `$MOSAIC_HOME/defaults/SOUL.md` | `0600`        |
+| `$MOSAIC_HOME/USER.md` | `$MOSAIC_HOME/defaults/USER.md` | `0600`        |
+
+Creation is no-clobber and safe under concurrent seat starts. Existing regular files remain
+byte-for-byte and mode-for-mode unchanged. The runtime composer then injects the exact roster name
+and class; the generic source files grant no seat authority.
+
+## Failure handling
+
+The fleet path never falls back to an interactive wizard. It exits nonzero before runtime execution
+when:
+
+- `MOSAIC_AGENT_NAME` is not an exact roster member;
+- a defined ambient `MOSAIC_AGENT_CLASS` is blank/whitespace or disagrees with that member's
+  canonical class;
+- a missing destination has no safe regular default source;
+- a source or existing destination is a symlink (including dangling), directory, unavailable, or over the bounded size;
+- the fleet communications helper/roster cannot be validated; or
+- `USER.md` cannot be securely re-read at the point where its content is composed.
+
+Diagnostics begin with:
+
+```text
+[mosaic] ERROR: unattended fleet identity initialization failed: ...
+```
+
+Repair the exact named source, destination, roster, or helper and retry only that roster member. Do
+not delete or replace an existing personalized `SOUL.md`/`USER.md` merely to clear the check.
+
+## Verification without a live seat
+
+The source gate is:
+
+```bash
+pnpm --filter @mosaicstack/mosaic... build && \
+  pnpm --filter @mosaicstack/mosaic exec vitest run \
+    src/commands/launch-first-start.spec.ts
+```
+
+The build leg is load-bearing: `dist/` is ignored, so a direct Vitest invocation could otherwise run
+absent or stale CLI output. The gate runs the exact-source built CLI in subprocesses with piped stdin,
+temporary homes, a canonical fixture roster, fake runtime/broker executables, and no provider call. It
+covers no-TTY launch, exact identity,
+private modes, no-clobber, missing/symlink defaults, unknown members, blank/mismatched class,
+portable standalone composition/wizard preservation, and concurrent first start.
+
+Do not use this fixture as proof that a real provider credential is present or that a package has
+been deployed. Those require separate environment-specific evidence.
+
+## Related
+
+- [User workflow](../../USER-GUIDE/workflows/fleet-unattended-first-start.md)
+- [Developer architecture](../../DEVELOPER-GUIDE/architecture/fleet-first-start-identity.md)
+- [Verification report](../../reports/qa/2026-08-16-1264-unattended-first-start.md)
@@ -26,6 +26,7 @@ This book is the canonical home for architecture, package and application guides

 - [Lease-broker operations and verification](testing/lease-broker-operations.md) — safe static/test commands plus explicitly held live operations.
 - [Channel adapters](integrations/channel-adapters.md) — current shared contracts and Discord reference boundary; future adapter parity is draft.
+- [Fleet first-start identity](architecture/fleet-first-start-identity.md) — no-TTY launch boundary, roster authority, and no-clobber filesystem design.

 Every promoted page must be added to this index and to [`SITEMAP.md`](../SITEMAP.md) in the same migration slice.

@@ -11,6 +11,7 @@ This chapter is the canonical home for Mosaic Stack's system model, component bo
 - [`mutator-class-gate.md`](mutator-class-gate.md) — default-deny tool authorization, runtime adapters, launch choke point, and parser assurance boundary.
 - [`compaction-revocation.md`](compaction-revocation.md) — Claude/Pi observer lifecycle, runtime generations, revocation, and the bounded residual stale window.
 - [`channel-protocol.md`](channel-protocol.md) — current shared channel DTOs and Discord compatibility baseline, with unimplemented adapter work explicitly marked draft.
+- [`fleet-first-start-identity.md`](fleet-first-start-identity.md) — roster-owned identity bootstrap for concurrent no-TTY fleet launches.
 - [`decisions/mos-runtime-portability-m1.md`](decisions/mos-runtime-portability-m1.md) — current logical identity, connector lease, grant, audit, and fencing decision; connector activation remains held.

 These pages are current security-contract references and are consumed by the lease-broker acceptance suites. Their live deployment gaps remain explicitly labeled in the pages; this migration does not change runtime behavior.
@@ -0,0 +1,81 @@
+# Fleet First-Start Identity Boundary
+
+> **Status:** Implemented by issue #1264. Requirements: `FCM-REQ-12`, `AC-FCM-10`.
+
+## Problem
+
+`launchRuntime()` called `checkSoul()` before runtime execution. A missing top-level `SOUL.md`
+caused `checkSoul()` to spawn a child `mosaic wizard` with inherited stdio. Under a systemd-created
+fleet pane with no TTY, that child blocked or failed before the runtime boundary even though generic
+`defaults/SOUL.md` and `defaults/USER.md` already shipped in the same `MOSAIC_HOME`.
+
+## Chosen boundary
+
+The fix remains at `checkSoul()` and does not add flags to `yolo`, fleet commands, systemd units, or
+`start-agent-session.sh`:
+
+1. A present, nonblank, whitespace-exact `MOSAIC_AGENT_NAME` selects the fleet path.
+2. `resolveFleetIdentity()` must resolve that exact member through the existing roster/helper
+   boundary, and any defined `MOSAIC_AGENT_CLASS` (including blank/whitespace) must canonicalize to
+   the roster class, before any identity seed. Only undefined means absent.
+3. `lstatSync()` preflights every destination directory entry without following links, so a dangling
+   link is rejected before its counterpart can be published.
+4. Safe bounded snapshots are read from only the missing contracts under `defaults/`.
+5. Each snapshot is written to a random owner-private temporary file in `MOSAIC_HOME`.
+6. `linkSync()` publishes the complete file without overwriting an existing path. `EEXIST` means a
+   concurrent seat or operator won; the existing path is preserved and revalidated.
+7. Temporary files are removed, and both installed contracts are re-opened through the no-symlink
+   secure-file reader before launch continues.
+8. `composeContract()` independently re-resolves the roster, securely reads fleet `USER.md` through
+   a Linux descriptor at the point of use, and injects exact member identity and communications data.
+
+A standalone launch with no `MOSAIC_AGENT_NAME` retains the portable tolerant USER read and the
+interactive wizard. Fleet-only no-follow enforcement must not make supported standalone macOS
+composition depend on Linux `/proc` descriptor traversal.
+
+## Identity and authority
+
+The copied defaults deliberately say “Mosaic agent”; they are a generic behavioral base. They are
+not the source of a fleet seat's identity. The canonical roster controls:
+
+- exact agent/session name;
+- canonical role/class and persona;
+- peer rows and point of contact;
+- tmux socket and helper target; and
+- communications generation.
+
+An unknown/padded ambient name, mismatched class, or explicitly blank/whitespace class fails before
+any file is seeded. This avoids replacing the interactive wall with a fleet of indistinguishable or
+ambiently invented identities.
+
+## Concurrency and filesystem properties
+
+- Sources and final destinations are bounded regular files beneath `MOSAIC_HOME`; target and dangling
+  symlinks are not followed.
+- New files have mode `0600`.
+- Hard-link publication is same-filesystem, atomic, and no-clobber.
+- A temporary path is removed only when this process successfully created it.
+- All required source snapshots are validated before the first destination is published, preventing
+  a missing second default from leaving a partial seed.
+- Existing operator files are never chmodded or rewritten.
+
+## Verification
+
+`src/commands/launch-first-start.spec.ts` uses the production-kind boundary: the real built CLI in a
+no-TTY subprocess, not a direct wizard test. The package `test:vitest` gate builds Mosaic before
+Vitest, while the clean-checkout command builds its workspace dependencies first, so ignored
+`dist/cli.js` cannot be absent or stale. A fake lease launcher records whether execution reached the
+runtime boundary and captures the composed prompt.
+Positive and negative cases prove the check can both proceed and refuse. Fleet composition coverage
+replaces a previously validated `USER.md` with an external symlink and proves point-of-use refusal;
+a standalone unreadable-optional-USER case proves the portable tolerant branch remains separate.
+
+Real Pi authentication and provider task execution remain environment tests, not claims of this
+fixture.
+
+## Non-goals
+
+- Runtime installation or pane-PATH resolution (#1256/#1258).
+- The held `~/.mosaic` launch-composition layer in PR #1213.
+- Personalizing the operator's standalone identity without a wizard.
+- Changing fleet systemd or shell launcher code.
@@ -146,6 +146,29 @@ lands. M0 consists only of these normative requirements, the complete task DAG,
 documentation IA checklist, and the legacy example/profile disposition inventory. Subsequent cards
 are defined in [docs/TASKS.md](./TASKS.md) and must remain one card/one PR.

+### Unattended fleet first-start amendment (#1264)
+
+`FCM-REQ-11` is reserved by #1256's concurrent runtime-preflight delivery. This amendment therefore
+uses the next non-colliding identifiers.
+
+1. `FCM-REQ-12`: A roster-owned fleet launch SHALL NOT invoke an interactive identity wizard when
+   top-level `SOUL.md` or `USER.md` is absent. It SHALL initialize only missing top-level identity
+   contracts from the shipped generic `defaults/` contracts without overwriting operator-owned
+   bytes. The canonical roster member remains the sole source of the seat's exact name and class;
+   generic defaults grant no fleet identity or authority. Missing or unsafe defaults SHALL fail
+   closed with actionable diagnostics before runtime execution. Non-fleet launches retain the
+   interactive identity flow.
+2. `AC-FCM-10`: A systemd-equivalent no-TTY test with a clean temporary Mosaic home SHALL prove a
+   named fleet seat reaches the runtime boundary without starting `mosaic wizard`, creates
+   byte-equal owner-private `SOUL.md` and `USER.md` seeds, and receives its exact roster name/class in
+   composed context. Tests SHALL also prove no-clobber behavior, concurrent/idempotent first start,
+   fail-closed invalid defaults, and preservation of the standalone interactive path.
+
+`ASSUMPTION:` `MOSAIC_AGENT_NAME` is the existing launch discriminator for roster-owned fleet
+processes. This amendment does not add a second fleet flag because generated fleet environments
+already set that value and the runtime composer independently resolves it against the canonical
+roster before execution.
+
 ---

 ## Exact Cross-Harness Fleet Communications Contract (#766)
@@ -38,11 +38,13 @@ These paths remain canonical because current source/tests consume them or becaus
 - [Quickstart](USER-GUIDE/getting-started/quickstart.md) — installed-CLI first-use route with local PGlite safety boundaries.
 - [Web dashboard](USER-GUIDE/product/web-dashboard.md) — current routes, views, chat persistence, settings, and admin behavior.
 - [Discord conversations](USER-GUIDE/workflows/discord-conversations.md) — current authorized parent-channel, thread, attachment, and control workflow.
+- [Fleet unattended first start](USER-GUIDE/workflows/fleet-unattended-first-start.md) — no-TTY identity bootstrap and exact roster identity.

 ## Administrator documentation

 - [Administrator operations](ADMIN-GUIDE/operations/README.md) — current local procedures and explicitly held outlines.
 - [Upgrade safety and recovery](ADMIN-GUIDE/operations/upgrade-safety-and-recovery.md) — installed-CLI/local-PGlite upgrade and framework recovery.
+- [Fleet unattended first-start operations](ADMIN-GUIDE/operations/fleet-unattended-first-start.md) — systemd identity initialization, refusal paths, and isolated verification.
 - [Mos connector lease operations](ADMIN-GUIDE/operations/mos-connector-lease-operations.md) — held/non-operative M1 outline while policy remains deny-all.
 - [Administrator security](ADMIN-GUIDE/security/README.md) — current security chapter index.
 - [SSO providers](ADMIN-GUIDE/security/sso-providers.md) — Authentik, WorkOS, and Keycloak configuration and discovery.
@@ -56,6 +58,7 @@ These paths remain canonical because current source/tests consume them or becaus
 - [Lease-broker security](DEVELOPER-GUIDE/architecture/lease-broker-security.md) — identity, ancestry, filesystem, observer, and residual boundaries.
 - [Whole mutator-class gate](DEVELOPER-GUIDE/architecture/mutator-class-gate.md) — default-deny tool authorization and launch choke point.
 - [Compaction revocation](DEVELOPER-GUIDE/architecture/compaction-revocation.md) — lifecycle observers, generation fencing, and residual stale window.
+- [Fleet first-start identity](DEVELOPER-GUIDE/architecture/fleet-first-start-identity.md) — roster authority and atomic no-clobber identity seeding.
 - [Architecture decisions](DEVELOPER-GUIDE/architecture/decisions/README.md) — implemented and accepted boundaries.
 - [Mos runtime portability M1](DEVELOPER-GUIDE/architecture/decisions/mos-runtime-portability-m1.md) — logical identity, connector lease, grants, audit, and fencing.
 - [Architecture RFCs](DEVELOPER-GUIDE/architecture/rfcs/README.md) — draft proposals without operational authority.
@@ -75,6 +78,7 @@ These paths remain canonical because current source/tests consume them or becaus
 - [Archived planning](archive/planning/README.md) — historical briefs, board reviews, and work-package specifications.
 - [Archived work records](archive/work-records/README.md) — historical task scratchpads without live consumers.
 - [P8-003 performance report](reports/qa/p8-003-performance-optimization.md) — historical implementation evidence, not a current SLO.
+- [Issue #1264 unattended fleet first-start verification](reports/qa/2026-08-16-1264-unattended-first-start.md) — RED/GREEN no-TTY CLI evidence and explicit untested bounds.
 - [Plans index](plans/README.md) — approved intent and implementation/audit plans.
 - [Documentation information-architecture design](plans/2026-08-10-docs-information-architecture-design.md) — approved documentation structure decision.
 - [Documentation catalog-audit plan](plans/2026-08-10-docs-catalog-audit.md) — evidence method and migration acceptance criteria.
@@ -11,6 +11,7 @@ This book is the canonical home for end-user workflows, user-visible behavior, p
 - [Quickstart](getting-started/quickstart.md) — install Mosaic, complete setup, and launch a session.
 - [Web dashboard](product/web-dashboard.md) — current routes, navigation, chat persistence, projects/tasks views, settings, and admin behavior.
 - [Discord conversations](workflows/discord-conversations.md) — current authorized parent-channel, thread, attachment, and control workflow.
+- [Fleet unattended first start](workflows/fleet-unattended-first-start.md) — no-TTY identity bootstrap, exact roster identity, and separate runtime prerequisites.

 ## Chapter map

@@ -18,7 +19,7 @@ This book is the canonical home for end-user workflows, user-visible behavior, p
 | ------------------ | ------------------------------------------------------------- | ---------------------------------------------------- |
 | `getting-started/` | First-use setup, orientation, and quickstarts.                | Quickstart is current; additional pages are planned. |
 | `concepts/`        | User-facing terminology, product concepts, and mental models. | Scaffold only.                                       |
-| `workflows/`       | Task-oriented procedures for using Mosaic Stack.              | Discord conversation workflow is current.            |
+| `workflows/`       | Task-oriented procedures for using Mosaic Stack.              | Discord and fleet first-start workflows are current. |
 | `product/`         | Current product surfaces and visible behavior.                | Web dashboard reference is current.                  |
 | `troubleshooting/` | User-visible failures, diagnostics, and fixes.                | Scaffold only.                                       |

@@ -27,6 +28,7 @@ This book is the canonical home for end-user workflows, user-visible behavior, p
 - [Quickstart](getting-started/quickstart.md) — the verified installed-CLI first-use path.
 - [Web dashboard](product/web-dashboard.md) — verified current Next.js dashboard behavior and limitations.
 - [Discord conversations](workflows/discord-conversations.md) — verified current Discord user workflow.
+- [Fleet unattended first start](workflows/fleet-unattended-first-start.md) — verified no-TTY first-start behavior and prerequisite boundaries.

 Every promoted page must be added to this index and to [`SITEMAP.md`](../SITEMAP.md) in the same migration slice.

@@ -0,0 +1,61 @@
+# Fleet Unattended First Start
+
+> **Status:** Current for roster-owned local fleet launches after issue #1264 lands. Runtime
+> installation and provider authentication remain separate prerequisites.
+
+A fleet seat started by systemd has no operator at its pane. On its first launch, Mosaic must not
+stop at the interactive identity wizard.
+
+## What happens on first start
+
+When `MOSAIC_AGENT_NAME` names an exact member of the installed fleet roster and top-level identity
+contracts are absent, the launcher:
+
+1. validates the exact roster member, its canonical class, and the installed fleet communications
+   helper;
+2. reads the shipped generic contracts from
+   `~/.config/mosaic/defaults/SOUL.md` and `defaults/USER.md`;
+3. creates only the missing top-level `SOUL.md` and `USER.md` as owner-private files;
+4. preserves any existing top-level identity file byte-for-byte; and
+5. launches the runtime with the roster member's exact agent/session name and role/class in composed
+   context.
+
+The generic defaults do **not** make every seat the same identity. They provide a shared behavioral
+base. The canonical roster row supplies each seat's exact name, class, peers, socket, and authority.
+
+## Operator behavior
+
+A normal standalone launch without a fleet identity retains its portable configuration path and still
+uses the interactive wizard when `SOUL.md` is absent:
+
+```bash
+mosaic pi
+```
+
+A roster-owned seat may be started without attaching to its pane:
+
+```bash
+mosaic fleet start <exact-roster-name>
+```
+
+Mosaic refuses before runtime execution if the requested member is absent, its explicitly supplied
+ambient class is blank or conflicts with the roster, a required default is missing or unsafe, or an existing identity contract
+is not a safe regular file. Repair the named component and retry the same exact roster member; do not
+copy another seat's personalized identity.
+
+## Separate prerequisites
+
+This behavior clears the Mosaic identity-wizard wall only. A clean host still needs:
+
+- the declared runtime installed on the pane PATH;
+- the fleet transport and generated unit assets; and
+- runtime/provider authentication appropriate to that seat.
+
+Those checks are separate so a successful identity bootstrap is not reported as a fully authenticated
+agent session.
+
+## Related
+
+- [Administrator runbook](../../ADMIN-GUIDE/operations/fleet-unattended-first-start.md)
+- [Developer architecture](../../DEVELOPER-GUIDE/architecture/fleet-first-start-identity.md)
+- [Verification report](../../reports/qa/2026-08-16-1264-unattended-first-start.md)
@@ -12,11 +12,13 @@ Use the canonical guide, API contract, source, and tests to determine current be
 - [Issue #756 documentation checklist](documentation/756-discord-plugin-checklist.md) — historical completion checklist for the official Discord plugin workstream.
 - [Framework consistency audit — 2026-02-17](documentation/AUDIT-2026-02-17-framework-consistency.md) — historical framework consistency and remediation snapshot.
 - [Compaction-refresh #830 checklist](compaction-refresh/830-documentation-checklist.md) — historical incomplete-at-snapshot documentation checklist.
+- [Issue #1264 documentation checklist](documentation/1264-documentation-checklist.md) — current in-repo user/admin/developer/report coverage and review gate.

 ## Code-review evidence

 - [Issue #756 independent code review](code-review/756-code-review.md) — historical exact-scope review of the official Discord plugin workstream.
 - [Gateway security-hardening code review — 2026-03-13](code-review/gateway-security-20260313.md) — historical no-blocker review snapshot.
+- [Issue #1264 independent code and security review](code-review/1264-code-review.md) — initial finding, remediation, clean re-review, and remaining formal PR-review gate.

 ## Security evidence

@@ -26,6 +28,7 @@ Use the canonical guide, API contract, source, and tests to determine current be

 - [P8-003 performance optimization report](qa/p8-003-performance-optimization.md) — historical implementation evidence; not a current SLO or production benchmark.
 - [Gateway security-hardening QA report — 2026-03-13](qa/gateway-security-20260313.md) — historical test report with its original live-smoke-test limitation.
+- [Issue #1264 unattended fleet first-start verification](qa/2026-08-16-1264-unattended-first-start.md) — RED/GREEN no-TTY CLI evidence, baseline gates, and explicit real-provider limitation.

 ## Native Kanban/SOT evidence

@@ -0,0 +1,97 @@
+# Issue #1264 Code and Security Review
+
+> Branch: `fix/1264-fleet-unattended-first-start` | Base:
+> `origin/next@476db12b92971634b67fd2057b7577ee5894e449`
+
+## Initial automated review
+
+Codex reviewed the pre-PR uncommitted delta with:
+
+```bash
+~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted \
+  -o /tmp/1264-codex-code-review.json
+```
+
+Result: `request-changes`, confidence `0.93`, 20 files, one should-fix. `checkSoul()` trimmed
+`MOSAIC_AGENT_NAME` for pre-seed resolution while composition used the original value, so a padded
+name could seed files before later refusal.
+
+Remediation rejected blank/leading/trailing-whitespace values before roster lookup or writes and
+added three built-CLI no-side-effect regressions. Automated re-review approved that delta with no
+findings (confidence `0.86`). Initial security review reported risk `none` (confidence `0.91`).
+
+## Formal exact-head review
+
+Daphne reviewed PR #1268 at exact head `43fa0477877e0d0f110da8d11c3033b40ddeb191` and filed Gitea
+review ID 168 as `REQUEST_CHANGES`. The review was source/PR-only; the canary remained untouched.
+
+Blocking groups:
+
+1. class mismatch was validated after first-start mutation;
+2. secure `USER.md` validation was discarded before ordinary path-following composition;
+3. `existsSync()` treated a dangling destination symlink as missing, allowing counterpart partial
+   publication; and
+4. the built-CLI/evidence chain allowed stale ignored `dist/`, cited an unshipped canary object, and
+   carried conflicting test totals/pane wording.
+
+The diagnostic's defaults-only repair advice was also inaccurate for roster/class/destination
+failures.
+
+## Formal-review remediation
+
+All four blocking groups received regressions before production changes. The RED run produced four
+failures while 1,568 existing tests passed. Remediation then:
+
+- validates canonical name and class before seeding;
+- preflights destination directory entries with `lstatSync()` so target and dangling symlinks fail
+  before publication;
+- securely reads `USER.md` through an `O_NOFOLLOW` descriptor at composition time;
+- adds a Mosaic build before package Vitest and a dependency build in the clean-checkout command;
+- replaces defaults-only advice with neutral named-component repair guidance; and
+- reconciles shipping canary provenance, pane chronology, commands, and totals.
+
+Remediation code review:
+
+```bash
+~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted \
+  -o /tmp/1264-remediation-code-review.json
+```
+
+Result: `approve`, confidence `0.88`, 6 files, no findings. Summary: the fail-closed destination
+checks, class-validation order, secure composition, and build-before-Vitest path are coherent.
+
+Remediation security review:
+
+```bash
+~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted \
+  -o /tmp/1264-remediation-security-review.json
+```
+
+Result: risk `none`, confidence `0.93`, 9 files, no critical/high/medium/low findings. The sandbox
+could not run Vitest because Vite attempted to create a temporary config artifact on its read-only
+mount (`EROFS`); executor-owned focused and full results are recorded in the QA report.
+
+## Second exact-head review
+
+Daphne reviewed exact head `9dc90be7e13b1cd609f6df97d43d890ef5392ca0` and filed Gitea review
+ID 169 as `REQUEST_CHANGES`. Review 169 confirmed all review-168 closures, then found:
+
+1. the new point-of-use reader was Linux-only but had been applied to every standalone USER read,
+   breaking supported non-fleet macOS composition; and
+2. explicit blank/whitespace `MOSAIC_AGENT_CLASS` was treated as absent and could seed before
+   runtime, while only undefined should mean absent.
+
+Red-first remediation preserves legacy `readOptional()` for standalone composition, keeps descriptor
+no-follow consumption fleet-only, moves the replacement-symlink case under a valid fleet identity,
+and rejects defined blank/whitespace classes before seeding. Three blank-class CLI cases and one
+tolerant standalone composition case failed before the source change and pass after it.
+
+Review-169 remediation code review approved at confidence `0.90` (4 files, no findings). Security
+review reported risk `none` at confidence `0.90` (4 files, no findings). The review sandbox retained
+its known Vite `EROFS` limitation; executor-owned tests are in the QA report.
+
+## Remaining review gate
+
+Daphne must re-review the next exact pushed head. This report cannot record that future verdict
+without changing the reviewed head, so the authoritative terminal verdict belongs to PR #1268's
+Gitea review record. Fred and goals are excluded as reviewers.
@@ -0,0 +1,32 @@
+# #1264 Documentation Completion Checklist
+
+## Required artifacts
+
+- [x] `docs/PRD.md` updated with `FCM-REQ-12` and `AC-FCM-10`.
+- [x] User workflow documents unattended fleet first start and separate prerequisites.
+- [x] Administrator operations page documents source/destination ownership, failure handling, and an
+      exact-source build-before-Vitest verification gate.
+- [x] Developer architecture page documents control flow, identity authority, concurrency, and non-goals.
+- [x] `docs/SITEMAP.md` and book indexes updated.
+- [x] QA evidence is under `docs/reports/qa/`; working notes are under `docs/scratchpads/`.
+- [x] Framework defaults README reflects fleet-versus-standalone behavior.
+
+## API coverage
+
+- [x] No HTTP/API endpoint or DTO changed; OpenAPI and endpoint indexes are not applicable.
+
+## Structural standards
+
+- [x] User, administrator, developer, report, and sitemap indexes link the new pages.
+- [x] No noncanonical file was added at the `docs/` root.
+- [x] Canonical documentation remains in-repo; no external publication was requested or performed.
+
+## Review gate
+
+- [x] Initial padded-name finding remediated and automated re-review approved.
+- [x] Daphne formal review ID 168 completed on exact first head `43fa0477` and requested changes.
+- [x] Four review-168 groups reproduced red and remediated; automated reviews are clean.
+- [x] Daphne review ID 169 completed on exact head `9dc90be7` and confirmed review-168 closures.
+- [x] Review-169 standalone-portability and blank-class blockers reproduced red and remediated;
+      automated reviews are clean.
+- [ ] Daphne exact-second-remediation-head re-review completed after push (Fred/goals excluded).
@@ -0,0 +1,220 @@
+# #1264 Unattended Fleet First-Start Verification
+
+> Status: **IN PROGRESS — review-169 remediation complete locally; push/re-review pending** |
+> Executor: goals | Date: 2026-08-16 | Target: isolated local fixtures only
+
+## Objective
+
+Verify that a named fleet seat launched through a systemd-equivalent, no-TTY environment on a clean
+host reaches its runtime boundary without an interactive Mosaic identity wizard. Preserve standalone
+wizard behavior and canonical-roster ownership of exact seat identity.
+
+## Source evidence accepted for local verification
+
+Daphne's canary Run-7 report is reachable from jarvis-brain `origin/main` at
+`8bf94afeb8c7d5df96cdd4a4508e75a1d2999710`,
+`docs/reports/2026-08-16_sbx-canary-greenfield-e2e.md`. The earlier local object
+`6c0b6fc70ae6a179a1b7ff9dedfc54e9adccd19a` is not reachable from an origin ref and is not used as
+shipping provenance. Run 7 measured:
+
+```text
+systemd -> start-agent-session.sh -> mosaic yolo pi (PID 3726)
+                                  -> child mosaic wizard (PID 3762)
+```
+
+The pane was preserved when Run 7 was captured. Formal review ID 168 records that an authorized
+rollback occurred later. This task never accessed or altered the canary VM, pane, snapshot, or
+rollback state. Product behavior is independently tested here with temporary roots and fake runtime
+executables.
+
+## Controls
+
+- Original base: `origin/next@476db12b92971634b67fd2057b7577ee5894e449`.
+- PR: #1268, first pushed head `43fa0477877e0d0f110da8d11c3033b40ddeb191`.
+- `DATABASE_URL` remains unset for local tests.
+- No runtime/provider credential or token value, VM, installed Mosaic tree, unit, timer, PATH profile,
+  or live tmux session is read or mutated. Standard Gitea/Woodpecker wrappers authenticate metadata
+  reads/writes without exposing credential values.
+- Tiny's runtime-preflight and `start-agent-session.sh` PATH work remain out of scope.
+- Held PR #1213 is not a dependency.
+
+## Requirements-to-evidence map
+
+| Acceptance criterion                                                   | Method                                                          | Evidence                      |
+| ---------------------------------------------------------------------- | --------------------------------------------------------------- | ----------------------------- |
+| No-TTY fleet first start avoids wizard and reaches runtime             | Exact-source built CLI with piped stdin                         | CLI GREEN                     |
+| Missing top-level identity files are initialized from shipped defaults | Exact-byte and `0600` assertions                                | CLI + filesystem GREEN        |
+| Exact seat identity remains roster-owned                               | Captured argv; mismatched/blank class no-side-effect refusals   | CLI GREEN                     |
+| Existing operator identity is never overwritten                        | Custom bytes/mode with defaults removed                         | CLI + filesystem GREEN        |
+| Concurrent/repeated first start is safe                                | Four parallel CLIs plus repeated launch                         | CLI GREEN                     |
+| Missing/unsafe defaults and destinations fail before partial mutation  | Missing, target/dangling symlink, oversized, invalid-root cases | Filesystem/CLI GREEN          |
+| Validated `USER.md` cannot be replaced by an external symlink          | Seed, replace, compose at point of use                          | Composition GREEN             |
+| Standalone launch retains wizard                                       | Same built CLI without fleet identity                           | CLI GREEN                     |
+| Built-CLI evidence cannot use stale ignored `dist/`                    | Build-with-dependencies gate before Vitest                      | Package script + command gate |
+
+## Initial RED
+
+Production source remained unchanged after adding the first reproducer. The CLI was built from
+`origin/next@476db12` before the test.
+
+```bash
+env -u DATABASE_URL pnpm --filter @mosaicstack/mosaic exec vitest run \
+  src/commands/launch-first-start.spec.ts
+```
+
+Exit `1`; one file and one test failed. Output included:
+
+```text
+[mosaic] SOUL.md not found. Running setup wizard...
+◆  What would you like to do?
+[mosaic] Setup failed. Run: mosaic wizard
+AssertionError: expected 1 to be +0
+```
+
+The fake runtime-boundary capture was not created. Complete stdout/stderr was retained at
+`/tmp/1264-red.out` during that work session.
+
+## Formal-review remediation RED
+
+Daphne's exact-head review ID 168 requested changes at `43fa0477`. Before changing production code,
+new regressions were run against an exact-source build. Four tests failed while the existing 1,568
+passed:
+
+1. valid roster name plus mismatched ambient class seeded both files before refusal;
+2. dangling `SOUL.md` allowed `USER.md` to be published before refusal;
+3. dangling `USER.md` allowed `SOUL.md` to be published before refusal; and
+4. replacing a securely validated `USER.md` with an external symlink was followed by composition.
+
+This establishes that all four review-168 findings were observable on the pushed implementation.
+
+Daphne's review ID 169 then found two more exact-head failures at `9dc90be7`. Before production
+changes, four new assertions failed:
+
+1. standalone composition routed an unreadable optional `USER.md` through the Linux-only descriptor
+   reader instead of the legacy portable tolerant path; and
+2. explicit `MOSAIC_AGENT_CLASS` values `""`, `" "`, and tab were treated as absent, seeded both
+   identity files, and reached runtime.
+
+The replacement-symlink case was also moved under a valid roster identity so it tests the fleet-only
+security boundary rather than standalone behavior.
+
+## Final GREEN
+
+The production-kind command builds Mosaic and all workspace dependencies before invoking Vitest,
+because `dist/` is ignored and may otherwise be absent or stale:
+
+```bash
+env -u DATABASE_URL sh -c '
+  pnpm --filter @mosaicstack/mosaic... build &&
+  pnpm --filter @mosaicstack/mosaic exec vitest run \
+    src/commands/fleet-first-start-identity.spec.ts \
+    src/commands/launch-first-start.spec.ts \
+    src/commands/launch.spec.ts \
+    src/commands/compose-contract.spec.ts \
+    src/config/file-adapter.test.ts \
+    src/cli-smoke.spec.ts
+'
+```
+
+Exit `0`: `6/6` files, `128/128` tests.
+
+- 15 real-CLI/no-TTY tests cover exact roster name/class, byte-equal `0600` seeds, no-clobber,
+  partial seed, missing/symlink defaults, unknown/padded/blank name, mismatched or explicitly blank
+  class, standalone wizard preservation, and four concurrent starts.
+- 12 direct filesystem tests cover complete publication, existing operators, idempotence, source
+  prevalidation, target and dangling destination links, invalid roots, oversized input, and
+  unexpected link errors.
+- Composition coverage deterministically replaces a valid fleet seat's validated `USER.md` with an
+  external symlink and requires refusal at point of use. A separate standalone case proves tolerant
+  optional composition remains outside the Linux-only fleet reader.
+
+Full package gate (which rebuilds Mosaic itself after the clean-checkout dependency build):
+
+```bash
+env -u DATABASE_URL pnpm --filter @mosaicstack/mosaic run test:vitest
+```
+
+Exit `0`: `88/88` files, `1,577/1,577` tests.
+
+Focused helper + point-of-use coverage:
+
+```text
+2 files, 53/53 tests
+Statements 97.84% | Branches 91.66% | Functions 100% | Lines 97.84%
+Exit 0
+```
+
+Final repository gates after remediation:
+
+```text
+pnpm preflight    exit 0
+pnpm typecheck    45/45 tasks, exit 0
+pnpm lint         25/25 tasks, exit 0
+pnpm build        25/25 tasks, exit 0
+pnpm format:check exit 0
+git diff --check  exit 0
+```
+
+Pre-PR targeted shell runs on the unchanged shell surfaces also passed:
+
+```text
+bash framework/tools/fleet/test-start-agent-session.sh                 exit 0 locally
+bash framework/tools/quality/scripts/test-install-migration.sh         21 passed, 0 failed
+bash framework/tools/_scripts/test-mosaic-init-rce.sh                   PASS
+```
+
+The aggregate local `test:framework-shell` run stopped at `invariant_r_unittest.py`: installed
+operator-global Pi is `0.84.2`, while the invariant is measured for `0.84.1`. Later aggregate stages
+remain unmeasured except the targeted suites above. Root `pnpm test` remains locally **UNTESTED**
+because this checkout prohibits the PostgreSQL-dependent gateway isolation path.
+
+## Review and security evidence
+
+- Initial Codex review found padded-name mutation-before-refusal; it was fixed with three
+  no-side-effect regressions.
+- Codex review of the formal-review remediation: `approve`, confidence `0.88`, 6 files, no findings.
+- Codex security review of the remediation: risk `none`, confidence `0.93`, 9 files, no findings.
+  Its sandbox could not execute Vitest because Vite attempted a write on a read-only mount; the
+  executor-owned results above are the test evidence.
+- Daphne formal review ID 168 at exact head `43fa0477`: `REQUEST_CHANGES`, four blocking groups; all
+  closed by review 169.
+- Daphne formal review ID 169 at exact head `9dc90be7`: `REQUEST_CHANGES`, two blocking groups
+  (standalone portability and explicit blank class). Both now have red-first regressions and local
+  green remediation.
+- Codex review of review-169 remediation: `approve`, confidence `0.90`, 4 files, no findings.
+- Codex security review of review-169 remediation: risk `none`, confidence `0.90`, 4 files, no
+  findings. Exact-new-head Daphne re-review is pending until that head is pushed.
+
+## CI evidence and external blocker
+
+Pipeline 2445 ran against exact first head `43fa0477`:
+
+- install, sanitization, upgrade guard, typecheck, lint, and format passed;
+- Mosaic Vitest passed `88/88`, `1,568/1,568`; and
+- the test step emitted exactly one `FAIL:` line:
+
+```text
+FAIL: host provides 'pi' in the system path; missing-binary cases are not measurable here
+```
+
+That line comes from the inherited `test-start-agent-session.sh` CI-fit guard, not #1264. Fred filed
+the correction as PR #1270. Its pipeline 2448 is terminal green and proves the four formerly masked
+suites execute, but #1270 is not merged, so `next` still carries the failing chain. A new #1268
+pipeline 2449 at `9dc90be7` reproduced the same single inherited `FAIL:` after Mosaic passed
+`1,573/1,573`. A new pipeline is pending the review-169 remediation push. Terminal-green #1268 CI is
+not claimed.
+
+PR #1268's envelope was read back as `user.login=mos-dt-0`; its commit is explicitly authored and
+committed by `goals <[email protected]>`. No goals Gitea login exists on this host, and no
+other principal was borrowed. The cross-wrapper principal defect is tracked in #1272.
+
+## Explicitly untested
+
+- Canary VM remediation/restart: **UNTESTED and prohibited**.
+- Real Pi authentication/provider prompt and task execution: **UNTESTED**.
+- PR #1213 composition layer: **UNTESTED and not required**.
+- Deployment/published npm behavior: **UNTESTED until merge/release**.
+- Local PostgreSQL execution/migration: **UNTESTED and prohibited**.
+
+The local gate proves Mosaic crosses its identity boundary and reaches a fake lease-runtime boundary;
+it does not claim provider readiness, deployment, or a currently running canary seat.
@@ -0,0 +1,104 @@
+# #1264 — Unattended fleet first start
+
+## Tracking
+
+- Issue: `mosaicstack/stack#1264`
+- PR: `mosaicstack/stack#1268`
+- Branch: `fix/1264-fleet-unattended-first-start`
+- Base: `origin/next@476db12b92971634b67fd2057b7577ee5894e449`
+- First pushed head: `43fa0477877e0d0f110da8d11c3033b40ddeb191`
+- Current remediation worktree: `/var/home/jason.woltje/agent-work/1264-review2-remediation`
+- Coordinator: Fred; reviewer must be neither Fred nor this implementation seat.
+- `docs/TASKS.md` is orchestrator-owned and is not modified by this worker.
+
+The original `/var/home/jason.woltje/agent-work/1264-unattended-first-start` and first remediation
+worktrees were removed without force after each pushed head and clean state were verified. The
+Fred-authorized plain-Git worktree exception was reused for exact-head review remediation because
+`/src` remains unavailable.
+
+## Objective
+
+A roster-owned fleet seat launched from systemd on a clean host must cross Mosaic's first-run identity
+gate without a human or TTY, while retaining exact name/class from the canonical roster and
+preserving the standalone interactive wizard.
+
+## Intake and boundaries
+
+- Shipping canary provenance is jarvis-brain `origin/main` commit
+  `8bf94afeb8c7d5df96cdd4a4508e75a1d2999710`. The earlier local `6c0b6fc...` object is not used.
+- The Run-7 pane was preserved when evidence was captured; formal review records a later authorized
+  rollback. This task never accessed or altered the canary.
+- Tiny's concurrent runtime-preflight, `start-agent-session.sh`, and #1258 PATH seam remain untouched.
+- Held PR #1213 is not a dependency.
+- No runtime/provider credential values or provider calls, installed-host changes, PostgreSQL, unit,
+  timer, or profile mutation. Tests use temporary roots and fake executables only; Gitea/Woodpecker
+  metadata operations use standard wrappers without exposing credentials.
+
+## Requirements and design
+
+- PRD IDs: `FCM-REQ-12`, `AC-FCM-10`; `FCM-REQ-11` is reserved by #1256.
+- A present fleet name must be nonblank, whitespace-exact, and resolve through the canonical roster.
+- Any defined ambient class, including blank/whitespace, must canonicalize to the roster class before
+  mutation; only undefined means absent.
+- Preflight all destination directory entries with no-follow existence semantics so dangling links
+  fail before counterpart publication.
+- Seed only missing top-level files from bounded regular defaults with owner-private, atomic,
+  no-clobber hard links.
+- Generic defaults are behavior, not identity or authority.
+- Securely consume fleet `USER.md` through a Linux descriptor at composition time.
+- Standalone composition retains the portable tolerant USER read and missing identity retains the
+  wizard.
+
+## Progress
+
+- [x] Issue, canary report, Tiny collision state, and PRD read/amended.
+- [x] Initial production-kind RED captured with a real built CLI and no TTY.
+- [x] Implementation, tests, user/admin/developer docs, QA, and indexes delivered.
+- [x] Initial automated review finding (padded name before write) remediated.
+- [x] Commit `43fa0477` pushed; PR #1268 opened against `next`; original worktree removed cleanly.
+- [x] Daphne formal review ID 168 completed on exact first head: `REQUEST_CHANGES` with four groups.
+- [x] All four review-168 groups reproduced red before remediation and passed at `9dc90be7`.
+- [x] Daphne review ID 169 completed on `9dc90be7`: review-168 closures confirmed; two new blockers.
+- [x] Review-169 portability and blank-class blockers reproduced red and now pass locally.
+- [x] Review-169 Codex review approved; security review risk `none`.
+- [ ] Commit/push second remediation with explicit goals author/committer; verify remote object/content.
+- [ ] Daphne exact-new-head re-review.
+- [ ] Terminal #1268 CI. Pipeline 2445's only `FAIL:` was the inherited Pi-PATH CI-fit guard; PR
+  #1270's pipeline 2448 is green, but #1270 is not merged.
+- [ ] Remove the clean remediation worktree after push.
+
+## Test evidence
+
+### Initial RED
+
+The built `origin/next` CLI entered `mosaic wizard`, rendered `What would you like to do?`, exited 1,
+and never created the fake runtime-boundary capture.
+
+### Formal-review RED
+
+Against exact first-head production code, four new tests failed while 1,568 existing tests passed:
+class mismatch mutated before refusal; each dangling destination left its counterpart; and a
+replacement `USER.md` symlink was consumed by composition. Review-169 RED then proved standalone
+composition hit the Linux-only reader and three explicit blank/whitespace class cases seeded and
+launched.
+
+### Final local GREEN
+
+- Exact-source focused gate: `6/6` files, `128/128` tests.
+- Full exact-source Mosaic Vitest: `88/88` files, `1,577/1,577` tests.
+- Helper + point-of-use coverage: `53/53`; 97.84% statements/lines, 91.66% branches, 100% functions.
+- Root preflight passed; typecheck `45/45`, lint `25/25`, build `25/25`.
+- Initial targeted shell gates passed: start-agent-session, install migration `21/21`, init-RCE.
+- Local aggregate framework shell stops at operator-global Pi `0.84.2` versus measured `0.84.1`.
+- Local root `pnpm test` remains unrun because the checkout prohibits its PostgreSQL-dependent path.
+
+The full evidence and command boundaries are in
+`docs/reports/qa/2026-08-16-1264-unattended-first-start.md`.
+
+## Review / delivery notes
+
+- Review-168 remediation Codex review: approve `0.88`; security risk `none` `0.93`.
+- Review-169 remediation Codex review: approve `0.90`; security risk `none` `0.90`.
+- PR envelope reads `mos-dt-0`; the commit reads goals/goals. No goals Gitea principal exists on this
+  host, so no other principal will be borrowed. Tracked in #1272.
+- PR #1270 is pushed, not merged. Do not represent `next` or #1268 CI as green until measured.
@@ -7,6 +7,10 @@
 - [DOCS-IA-001 — information architecture](DOCS-IA-001.md) — completed structure-design and documentation-contract record.
 - [DOCS-IA-002 — catalog audit and migration](DOCS-IA-002-catalog-audit.md) — active coordinator progress, autonomous lane state, verification evidence, and authority blockers.

+## Active implementation records
+
+- [Issue #1264 — unattended fleet first start](1264-unattended-first-start.md) — plan, RED/GREEN evidence, collision boundaries, and PR lifecycle state.
+
 Completed scratchpads may remain here when they provide useful delivery provenance. Their conclusions must be reflected in the owning canonical page before the scratchpad is treated as complete.

 ## Related
@@ -102,7 +102,7 @@ mosaic yolo pi             # Launch Pi in yolo mode
 The launcher:

 1. Verifies `~/.config/mosaic` exists
-2. Verifies `SOUL.md` exists (auto-runs `mosaic init` if missing)
+2. Resolves identity: standalone launches auto-run `mosaic init` when `SOUL.md` is missing; exact roster-owned fleet launches validate name/class, atomically seed only missing `SOUL.md`/`USER.md` from generic `defaults/`, securely consume `USER.md`, and never prompt
 3. Injects `AGENTS.md` into the runtime
 4. Forwards all arguments to the runtime CLI

@@ -233,36 +233,8 @@ assert_owned_tmux_server() {
    fail "tmux server ownership or environment validation failed"
 }

-# Lease-broker socket preflight (#1292). The gated runtime (`mosaic yolo …` →
-# launch-runtime.py) registers with the broker or dies ~4 seconds in, with the
-# diagnostic invisible because tmux destroys the dead pane. This check runs
-# BEFORE any tmux effect — including the ownership probe below — so a host
-# without a broker produces a named, surviving refusal instead of a doomed
-# pane. Exit 75 (EX_TEMPFAIL), distinct from 64 (bad projection) and 69 (host
-# not ready for other reasons); the agent@ unit is Type=oneshot with no
-# Restart=, so the failed unit keeps its message instead of looping. Socket
-# resolution matches launch.ts's defaultLeaseBrokerSocket precedence exactly.
-# This preflight DETECTS and REFUSES — it never starts the broker (activation
-# belongs to the fleet control plane; a component that both detects and fixes
-# cannot be used to measure whether the fix worked).
-broker_socket_path() {
-  if [ -n "${MOSAIC_LEASE_BROKER_SOCKET:-}" ]; then
-    printf '%s\n' "$MOSAIC_LEASE_BROKER_SOCKET"
-    return 0
-  fi
-  local runtime_dir="${XDG_RUNTIME_DIR:-/run/user/$(id -u)}"
-  printf '%s\n' "${runtime_dir}/mosaic-lease/broker.sock"
-}
-
-if [ "$MODE" = "launch" ]; then
-  _broker_socket=$(broker_socket_path)
-  if [ ! -S "$_broker_socket" ]; then
-    echo "[fleet] FAIL_LAUNCH broker-absent: lease broker socket ${_broker_socket} missing; runtime launch denied (#1292)." >&2
-    echo "[fleet] remedy: systemctl --user enable --now mosaic-lease-broker.service  (or reinstall via: mosaic fleet install)" >&2
-    exit 75
-  fi
-fi
-
+# Validate exact server ownership before querying, cleaning, or creating any
+# managed session. An unmanaged or contaminated named socket is never repaired.
 assert_owned_tmux_server

 if [ "$MODE" = interaction ]; then
@@ -1,216 +0,0 @@
-#!/usr/bin/env bash
-# CI-fit regression suite for the #1292 lease-broker socket preflight in
-# start-agent-session.sh.
-#
-# WHY THIS SUITE IS CI-FIT WHERE test-start-agent-session.sh IS NOT (#1017/#1270
-# context): that older suite's precondition is "the host does not have the pi
-# binary", which a CI image that ships pi violates — its guard correctly
-# refuses to report a pass there, so it is excluded from the chain. THIS suite
-# controls its own preconditions instead of inheriting them from the host: a
-# fake tmux on PATH, a fake mosaic on PATH, a real unix socket created in a
-# tmpdir, a hermetic env (env -i, fake HOME, GIT_CONFIG_GLOBAL severed). It
-# never depends on what the host has installed, so a green here means the same
-# thing on every host. Anyone adding cases: keep that property — no case may
-# depend on host state.
-#
-# The failure this suite is written down to catch (#1292): a seat launched on a
-# host with no lease broker dies ~4 seconds in at registration, with the
-# diagnostic invisible because tmux destroys the dead pane. The preflight runs
-# BEFORE any tmux effect and refuses with a NAMED code (exit 75, EX_TEMPFAIL)
-# so the message survives. The agent@ unit is Type=oneshot with no Restart=,
-# so a failed unit keeps its output instead of looping.
-#
-# Cases:
-#   1. absent socket -> exit 75, message names broker-absent + socket path +
-#      remedy, and NO tmux session was ever created (the doomed-pane half).
-#   2. present socket (real unix socket in tmpdir) -> proceeds PAST the
-#      preflight (the suite then stops at the next precondition, proving the
-#      preflight was not the refusal).
-#   3. explicit MOSAIC_LEASE_BROKER_SOCKET wins over XDG_RUNTIME_DIR default.
-#   4. --stop mode does NOT require the broker (teardown must not be fenced on
-#      a component whose absence is exactly what teardown may follow).
-#
-# Sabotage control, run by the developer (not in-suite): remove the preflight
-# block from start-agent-session.sh, re-run — case 1 fails (a tmux session is
-# created / exit is not 75), cases 2-4 still pass; restore byte-identically.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/agent-session-broker-preflight}"
-FAKE_HOME="$WORK_DIR/home"
-BIN_DIR="$WORK_DIR/bin"
-ENV_DIR="$WORK_DIR/env"
-SOCK_DIR="$WORK_DIR/sockets"
-LOG_FILE="$WORK_DIR/tmux-calls.log"
-
-rm -rf "$WORK_DIR"
-# The script asserts a managed directory tree under MOSAIC_HOME: mosaic/,
-# mosaic/fleet/, mosaic/fleet/agents/ — private (0700/0750-style) modes, no
-# symlinks — plus a per-agent env projection. Build the full tree the launcher
-# expects so the suite reaches the BROKER preflight rather than dying at
-# environment validation.
-mkdir -p "$FAKE_HOME/.config/mosaic/fleet/agents" "$BIN_DIR" "$SOCK_DIR"
-chmod 700 "$FAKE_HOME/.config/mosaic" "$FAKE_HOME/.config/mosaic/fleet/agents"
-chmod 750 "$FAKE_HOME/.config/mosaic/fleet"
-cat > "$FAKE_HOME/.config/mosaic/fleet/agents/preflight-test.env.generated" <<'ENVEOF'
-MOSAIC_AGENT_NAME=preflight-test
-MOSAIC_AGENT_CLASS=worker
-MOSAIC_AGENT_RUNTIME=pi
-MOSAIC_AGENT_MODEL=
-MOSAIC_AGENT_REASONING=
-MOSAIC_AGENT_TOOL_POLICY=code
-MOSAIC_AGENT_WORKDIR=/tmp
-MOSAIC_TMUX_SOCKET=mosaic-fleet
-ENVEOF
-chmod 600 "$FAKE_HOME/.config/mosaic/fleet/agents/preflight-test.env.generated"
-
-# ─── Fake tmux: records every invocation; new-session marks the marker. ────
-: > "$LOG_FILE"
-cat > "$BIN_DIR/tmux" <<SH
-#!/usr/bin/env bash
-printf 'tmux %s\n' "\$*" >> "$LOG_FILE"
-if [[ "\$*" == *new-session* ]]; then
-  echo "TMUX-NEW-SESSION-INVOKED" >> "$LOG_FILE"
-fi
-exit 0
-SH
-chmod +x "$BIN_DIR/tmux"
-
-# ─── Fake mosaic/pi binaries so the script proceeds past its own lookups. ───
-for bin in mosaic pi claude; do
-  printf '#!/usr/bin/env bash\nexit 0\n' > "$BIN_DIR/$bin"
-  chmod +x "$BIN_DIR/$bin"
-done
-
-# ─── Minimal launch environment the script expects. ────────────────────────
-# (Enough for the preflight to be reached; later stages will still fail in
-# case 2 — that is expected and asserted.)
-run_session_script() {
-  local mode="$1"; shift
-  (
-    cd "$WORK_DIR"
-    env -i HOME="$FAKE_HOME" PATH="$BIN_DIR:/usr/bin:/bin" \
-      GIT_CONFIG_GLOBAL=/dev/null GIT_CONFIG_SYSTEM=/dev/null \
-      MOSAIC_HOME="$FAKE_HOME/.config/mosaic" \
-      AGENT_NAME=preflight-test \
-      "$@" \
-      bash "$SCRIPT_DIR/start-agent-session.sh" $mode preflight-test
-  )
-}
-
-fail=0
-assert() {
-  local desc="$1" expected="$2" actual="$3"
-  if [[ "$expected" != "$actual" ]]; then
-    echo "FAIL: $desc — expected '$expected', got '$actual'" >&2
-    fail=1
-  fi
-}
-assert_contains() {
-  local desc="$1" haystack="$2" needle="$3"
-  [[ "$haystack" == *"$needle"* ]] || { echo "FAIL: $desc — missing '$needle' in: $haystack" >&2; fail=1; }
-}
-assert_not_contains() {
-  local desc="$1" haystack="$2" needle="$3"
-  if [[ "$haystack" == *"$needle"* ]]; then
-    echo "FAIL: $desc — must not contain '$needle'" >&2
-    fail=1
-  fi
-  return 0
-}
-
-# ─── 1. Absent socket → named refusal, NO tmux session. ────────────────────
-: > "$LOG_FILE"
-stderr_file="$WORK_DIR/stderr-1.tmp"
-set +e
-out=$(run_session_script "" MOSAIC_LEASE_BROKER_SOCKET="$SOCK_DIR/absent.sock" 2>"$stderr_file")
-rc=$?
-set -e
-assert "absent socket exit code" "75" "$rc"
-err=$(cat "$stderr_file")
-assert_contains "absent socket names the failure" "$err" "FAIL_LAUNCH broker-absent"
-assert_contains "absent socket names the socket path" "$err" "$SOCK_DIR/absent.sock"
-assert_contains "absent socket names a remedy" "$err" "mosaic fleet install"
-log1=$(cat "$LOG_FILE")
-assert_not_contains "absent socket must not create a tmux session" "$log1" "TMUX-NEW-SESSION-INVOKED"
-
-# ─── 2. Present socket → passes the preflight. ─────────────────────────────
-# Expected: ownership/env checks AFTER the preflight may refuse (fixture is
-# minimal by design); the assertion is only that the refusal is NOT
-# broker-absent and the exit is NOT 75.
-# Create a REAL unix socket: a detached python holder binds it and stays alive
-# for the duration (bash cannot create sockets; a foreground python would
-# close the socket on exit and -S on a closed-but-unlinked path fails). Written
-# as a script file + setsid nohup so no job-control/heredoc interaction with
-# set -e can silently kill the suite.
-# AF_UNIX binds cap at 108 path bytes; the suite's workdir exceeds that, so
-# the live socket lives at a SHORT path under /tmp (unique per run, cleaned
-# with the suite). The preflight takes its socket path explicitly, so this
-# stays fully controlled.
-LIVE_SOCK=$(mktemp -u /tmp/mosaic-preflight-XXXXXX.sock)
-trap 'rm -f "$LIVE_SOCK"' EXIT
-rm -f "$SOCK_DIR/live.sock" "$LIVE_SOCK"
-cat > "$SOCK_DIR/holder.py" <<'PY'
-import socket, sys, time
-path = sys.argv[1]
-s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-s.bind(path)
-s.listen(1)
-time.sleep(120)
-PY
-python3 "$SOCK_DIR/holder.py" "$LIVE_SOCK" >/dev/null 2>"$SOCK_DIR/holder.err" &
-HOLDER_PID=$!
-# Wait for the socket object to exist (bind is near-instant, but do not race it).
-for _ in $(seq 1 50); do
-  [ -S "$LIVE_SOCK" ] && break
-  sleep 0.1
-done
-if [ ! -S "$LIVE_SOCK" ]; then
-  echo "FAIL: could not create live socket fixture (holder pid $HOLDER_PID)" >&2
-  ps -p "$HOLDER_PID" -o pid,stat,cmd --no-headers >&2 || echo "(holder exited)" >&2
-  cat "$SOCK_DIR/holder.err" >&2 || true
-  exit 1
-fi
-: > "$LOG_FILE"
-set +e
-out=$(run_session_script "" MOSAIC_LEASE_BROKER_SOCKET="$LIVE_SOCK" 2>"$WORK_DIR/stderr-2.tmp")
-rc=$?
-set -e
-# The preflight PASSED if the failure (whatever later stage refused) is NOT
-# the broker refusal, and tmux was reached or a later precondition named
-# something else.
-err2=$(cat "$WORK_DIR/stderr-2.tmp")
-assert_not_contains "live socket must not refuse broker-absent" "$err2" "broker-absent"
-if [[ "$rc" == "75" ]]; then
-  echo "FAIL: live socket — preflight still refused (exit 75) with a live socket" >&2
-  fail=1
-fi
-
-# ─── 3. Explicit socket env wins over XDG default. ─────────────────────────
-set +e
-out=$(run_session_script "" XDG_RUNTIME_DIR="$SOCK_DIR/no-runtime-here" MOSAIC_LEASE_BROKER_SOCKET="$SOCK_DIR/absent2.sock" 2>"$WORK_DIR/stderr-3.tmp")
-rc=$?
-set -e
-assert "explicit env wins (exit 75)" "75" "$rc"
-assert_contains "explicit env path named" "$(cat "$WORK_DIR/stderr-3.tmp")" "$SOCK_DIR/absent2.sock"
-
-# ─── 4. --stop is not fenced on the broker. ────────────────────────────────
-: > "$LOG_FILE"
-set +e
-out=$(run_session_script "--stop" MOSAIC_LEASE_BROKER_SOCKET="$SOCK_DIR/absent3.sock" 2>"$WORK_DIR/stderr-4.tmp")
-rc=$?
-set -e
-err4=$(cat "$WORK_DIR/stderr-4.tmp")
-assert_not_contains "--stop must not refuse broker-absent" "$err4" "broker-absent"
-if [[ "$rc" == "75" ]]; then
-  echo "FAIL: --stop — exit 75 means teardown was fenced on the broker" >&2
-  fail=1
-fi
-
-kill "$HOLDER_PID" 2>/dev/null || true
-
-if [[ "$fail" -eq 0 ]]; then
-  echo "start-agent-session lease-broker preflight regression passed"
-fi
-exit "$fail"
@@ -39,20 +39,3 @@ packages/mosaic/framework/tools/tmux/test-send-message-verdict.sh | requires rea
 # recorded judgement. These lines ARE that judgement, signed.)
 packages/mosaic/framework/tools/orchestrator/smoke-test.sh | behavior smoke checks for coord continue/run workflows, run manually by orchestrator seats; unmeasured in CI; #1017 burndown
 packages/mosaic/framework/tools/wake/validate-973/microtest-wake-assert.sh | #973 instrument self-test, run as a precondition of the validate-973 evidence procedure rather than as a standing CI suite; #1017 burndown candidate
-
-# --- tools/fleet: precondition is unsatisfiable in the CI image (#1271) ---
-# Signed by fred (sb-it-1-dt, 2026-08-16) at origin/next 476db12.
-# This suite asserts the launcher's behaviour when `mosaic` and `pi` are MISSING.
-# It shims fakes into $FAKE_BIN, but the constructed PANE_PATH always ends in the
-# real system path, so on a host that installs those binaries the missing-binary
-# cases cannot be measured at all. The suite's own guard (line 103) says so and
-# fails rather than reporting a pass it cannot back. That guard is correct.
-# The error was wiring the suite into CI: #1017 (c56483eb) enumerated it and
-# dropped this exclusion, and the CI image provides `pi` in the system path, so
-# it has failed on every pipeline since. Measured 2026-08-16 across pipelines
-# 2444 (#1256), 2438 (#1240) and 2441 (#1017-quality): exactly one FAIL line in
-# each full log, identical, this assertion; control `zzz-not-present-zzz` -> 0.
-# Burn-down and the full measurement are tracked in #1271; unwired by PR #1270.
-# Because test:framework-shell is one && chain and this sat at position 44 of 48,
-# the four suites after it had not run at all since the merge.
-packages/mosaic/framework/tools/fleet/test-start-agent-session.sh | precondition unsatisfiable in the CI image: asserts missing-binary behaviour, but PANE_PATH always ends in the system path and the image provides `pi` there; guard at line 103 fails by design rather than passing unmeasured. Burn down by controlling the tail of PANE_PATH inside the test. NOT by removing `pi` from the image: the CI image installs @earendil-works/[email protected] deliberately (measured in pipeline 2444's test-step log), and other suites depend on that pin. Burn-down tracked in #1271
@@ -24,8 +24,9 @@
    "build": "tsc",
    "lint": "eslint src",
    "typecheck": "tsc --noEmit",
-    "test": "vitest run --passWithNoTests && pnpm run test:framework-shell",
-    "test:framework-shell": "bash framework/tools/quality/scripts/check-test-enumeration.sh && bash framework/tools/quality/scripts/test-check-test-enumeration.sh && python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/promotion_binding_unittest.py && python3 src/lease-broker/promotion_trigger_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/receipt_observer_client_unittest.py && python3 src/lease-broker/invariant_r_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 src/mutator-gate/version_coupling_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-pr-review-repo-host-override.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh && bash framework/tools/git/test-ci-queue-wait-tristate.sh && bash framework/tools/git/test-ci-queue-wait-github-checks.sh && bash framework/tools/git/test-pr-merge-queue-branch.sh && bash framework/tools/git/test-pr-merge-head-pin.sh && bash framework/tools/git/test-pr-merge-message-field.sh && bash framework/tools/git/test-git-credential-mosaic.sh && bash framework/tools/git/test-gitea-token-identity.sh && bash framework/tools/woodpecker/test-terminal-green-contract.sh && bash framework/tools/_scripts/test-install-ordering-guard.sh && bash framework/tools/_scripts/test-mosaic-init-rce.sh && bash framework/tools/tmux/agent-send.test.sh && bash framework/tools/wake/test-wake-store-ack.sh && bash framework/tools/wake/test-wake-store-enqueue-race.sh && bash framework/tools/wake/test-wake-digest-hmac.sh && bash framework/tools/wake/test-wake-digest-quarantine.sh && bash framework/tools/wake/test-wake-detector.sh && bash framework/tools/wake/test-wake-fn-oracle.sh && bash framework/tools/wake/test-wake-reconcile.sh && bash framework/tools/wake/test-wake-beacon.sh && bash framework/tools/wake/test-wake-preimage.sh && bash framework/tools/wake/test-wake-install.sh && bash framework/tools/glpi/test-list-http-status.sh && bash framework/tools/orchestrator/test-board-roll.sh && bash framework/tools/woodpecker/test-ci-wait-exit-matrix.sh && bash framework/tools/_scripts/test-fleet-transport-check.sh"
+    "test": "pnpm run test:vitest && pnpm run test:framework-shell",
+    "test:vitest": "pnpm run build && vitest run --passWithNoTests",
+    "test:framework-shell": "bash framework/tools/quality/scripts/check-test-enumeration.sh && bash framework/tools/quality/scripts/test-check-test-enumeration.sh && python3 src/lease-broker/daemon_deadline_unittest.py && python3 src/lease-broker/normative_fragments_unittest.py && python3 src/lease-broker/promotion_binding_unittest.py && python3 src/lease-broker/promotion_trigger_unittest.py && python3 src/lease-broker/receipt_challenge_unittest.py && python3 src/lease-broker/context_recovery_unittest.py && python3 src/lease-broker/recovery_runtime_unittest.py && python3 src/lease-broker/recovery_b1_adversarial_unittest.py && python3 src/lease-broker/receipt_observer_client_unittest.py && python3 src/lease-broker/invariant_r_unittest.py && python3 src/lease-broker/framework_skill_portability_unittest.py && python3 src/mutator-gate/runtime_tools_unittest.py && python3 src/mutator-gate/runtime_launch_guard_unittest.py && python3 src/mutator-gate/version_coupling_unittest.py && python3 framework/tools/lease-broker/check-runtime-launches.py --root ../.. && bash framework/tools/codex/test-pr-diff-context.sh && bash framework/tools/qa/test-deps-preflight.sh && bash framework/tools/git/test-pr-review-gitea-comment.sh && bash framework/tools/git/test-pr-review-repo-host-override.sh && bash framework/tools/git/test-ci-queue-wait-branch-absent.sh && bash framework/tools/git/test-ci-queue-wait-tristate.sh && bash framework/tools/git/test-ci-queue-wait-github-checks.sh && bash framework/tools/git/test-pr-merge-queue-branch.sh && bash framework/tools/git/test-pr-merge-head-pin.sh && bash framework/tools/git/test-pr-merge-message-field.sh && bash framework/tools/git/test-git-credential-mosaic.sh && bash framework/tools/git/test-gitea-token-identity.sh && bash framework/tools/woodpecker/test-terminal-green-contract.sh && bash framework/tools/_scripts/test-install-ordering-guard.sh && bash framework/tools/_scripts/test-mosaic-init-rce.sh && bash framework/tools/tmux/agent-send.test.sh && bash framework/tools/wake/test-wake-store-ack.sh && bash framework/tools/wake/test-wake-store-enqueue-race.sh && bash framework/tools/wake/test-wake-digest-hmac.sh && bash framework/tools/wake/test-wake-digest-quarantine.sh && bash framework/tools/wake/test-wake-detector.sh && bash framework/tools/wake/test-wake-fn-oracle.sh && bash framework/tools/wake/test-wake-reconcile.sh && bash framework/tools/wake/test-wake-beacon.sh && bash framework/tools/wake/test-wake-preimage.sh && bash framework/tools/wake/test-wake-install.sh && bash framework/tools/fleet/test-start-agent-session.sh && bash framework/tools/glpi/test-list-http-status.sh && bash framework/tools/orchestrator/test-board-roll.sh && bash framework/tools/woodpecker/test-ci-wait-exit-matrix.sh && bash framework/tools/_scripts/test-fleet-transport-check.sh"
  },
  "dependencies": {
    "@mosaicstack/brain": "workspace:*",
@@ -15,6 +15,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { FileConfigAdapter } from '../config/file-adapter.js';
+import { seedFleetIdentityDefaults } from './fleet-first-start-identity.js';
 import { composeContract } from './launch.js';

 /**
@@ -319,6 +320,7 @@ describe('composeContract — overlay composer', () => {
        ].join('\n'),
      );
      process.env['MOSAIC_AGENT_NAME'] = 'exact-self';
+      expect(seedFleetIdentityDefaults(installedHome)).toEqual(['SOUL.md', 'USER.md']);

      const composed = composeContract('pi', installedHome);
      expect(composed).toContain(sourceTools);
@@ -332,6 +334,49 @@ describe('composeContract — overlay composer', () => {
    }
  });

+  it('refuses a fleet USER.md replacement symlink at the point of composition', () => {
+    mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
+    writeFileSync(
+      join(fixture.home, 'fleet', 'roster.yaml'),
+      [
+        'version: 1',
+        'transport: tmux',
+        'agents:',
+        '  - name: exact-user-seat',
+        '    runtime: pi',
+        '    class: worker',
+        '',
+      ].join('\n'),
+    );
+    process.env['MOSAIC_AGENT_NAME'] = 'exact-user-seat';
+    process.env['MOSAIC_AGENT_CLASS'] = 'worker';
+    writeFileSync(join(fixture.home, 'defaults', 'SOUL.md'), '# Generic soul\n');
+    writeFileSync(join(fixture.home, 'defaults', 'USER.md'), '# Generic user\n');
+    expect(seedFleetIdentityDefaults(fixture.home)).toEqual(['SOUL.md']);
+
+    const userPath = join(fixture.home, 'USER.md');
+    const external = join(fixture.root, 'attacker-user.md');
+    writeFileSync(external, 'UNSAFE-REPLACEMENT-USER-CONTENT\n');
+    rmSync(userPath);
+    symlinkSync(external, userPath);
+
+    expect(() => composeContract('pi', fixture.home)).toThrow(
+      `fleet identity installed is unavailable or unsafe: ${userPath}`,
+    );
+    expect(readFileSync(external, 'utf8')).toBe('UNSAFE-REPLACEMENT-USER-CONTENT\n');
+  });
+
+  it('preserves tolerant standalone composition when optional USER.md is unreadable', () => {
+    const userPath = join(fixture.home, 'USER.md');
+    rmSync(userPath);
+    mkdirSync(userPath);
+
+    const out = composeContract('pi', fixture.home);
+
+    expect(out).toContain(AGENTS);
+    expect(out).not.toContain('# User Profile');
+  });
+
  it.each(['claude', 'codex', 'opencode', 'pi'] as const)(
    'never injects installed TOOLS.md through a target symlink for %s',
    (runtime) => {
@@ -0,0 +1,182 @@
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  lstatSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  linkIdentityContractNoClobber,
+  seedFleetIdentityDefaults,
+} from './fleet-first-start-identity.js';
+
+const roots: string[] = [];
+const DEFAULT_SOUL = '# Generic soul\n';
+const DEFAULT_USER = '# Generic user\n';
+
+function writeFixture(path: string, content: string | Buffer, mode: number = 0o600): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, content, { mode });
+  chmodSync(path, mode);
+}
+
+function createMosaicHome(): string {
+  const root = mkdtempSync(join(tmpdir(), 'mosaic-identity-seed-'));
+  roots.push(root);
+  const mosaicHome = join(root, 'home', '.config', 'mosaic');
+  writeFixture(join(mosaicHome, 'defaults', 'SOUL.md'), DEFAULT_SOUL);
+  writeFixture(join(mosaicHome, 'defaults', 'USER.md'), DEFAULT_USER);
+  return mosaicHome;
+}
+
+function temporarySeeds(mosaicHome: string): string[] {
+  return readdirSync(mosaicHome).filter((entry) => entry.includes('.fleet-seed-'));
+}
+
+afterEach((): void => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+describe('linkIdentityContractNoClobber', () => {
+  it('returns false and preserves a destination that already exists', () => {
+    const mosaicHome = createMosaicHome();
+    const source = join(mosaicHome, 'source.tmp');
+    const destination = join(mosaicHome, 'destination.md');
+    writeFixture(source, 'candidate\n');
+    writeFixture(destination, 'operator\n');
+
+    expect(linkIdentityContractNoClobber(source, destination)).toBe(false);
+    expect(readFileSync(destination, 'utf8')).toBe('operator\n');
+  });
+
+  it('does not misclassify an unexpected link failure as a concurrent winner', () => {
+    const mosaicHome = createMosaicHome();
+    const missingSource = join(mosaicHome, 'missing.tmp');
+
+    expect(() =>
+      linkIdentityContractNoClobber(missingSource, join(mosaicHome, 'destination.md')),
+    ).toThrow();
+  });
+});
+
+describe('seedFleetIdentityDefaults', () => {
+  it('publishes complete owner-private default snapshots', () => {
+    const mosaicHome = createMosaicHome();
+
+    expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['SOUL.md', 'USER.md']);
+
+    for (const [entry, expected] of [
+      ['SOUL.md', DEFAULT_SOUL],
+      ['USER.md', DEFAULT_USER],
+    ] as const) {
+      const path = join(mosaicHome, entry);
+      expect(readFileSync(path, 'utf8')).toBe(expected);
+      expect(statSync(path).mode & 0o777).toBe(0o600);
+    }
+    expect(temporarySeeds(mosaicHome)).toEqual([]);
+  });
+
+  it('preserves an existing regular contract byte-for-byte and mode-for-mode', () => {
+    const mosaicHome = createMosaicHome();
+    const customSoul = '# Operator-owned soul\n';
+    writeFixture(join(mosaicHome, 'SOUL.md'), customSoul, 0o640);
+
+    expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['USER.md']);
+    expect(readFileSync(join(mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
+    expect(statSync(join(mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
+  });
+
+  it('is idempotent after both installed contracts exist', () => {
+    const mosaicHome = createMosaicHome();
+
+    expect(seedFleetIdentityDefaults(mosaicHome)).toEqual(['SOUL.md', 'USER.md']);
+    expect(seedFleetIdentityDefaults(mosaicHome)).toEqual([]);
+    expect(temporarySeeds(mosaicHome)).toEqual([]);
+  });
+
+  it('validates every required source before publishing any destination', () => {
+    const mosaicHome = createMosaicHome();
+    const missing = join(mosaicHome, 'defaults', 'USER.md');
+    rmSync(missing);
+
+    expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+      `fleet identity default is unavailable or unsafe: ${missing}`,
+    );
+    expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
+    expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
+  });
+
+  it('fails closed when the configured Mosaic home is not a directory', () => {
+    const root = mkdtempSync(join(tmpdir(), 'mosaic-identity-invalid-home-'));
+    roots.push(root);
+    const mosaicHome = join(root, 'mosaic-home');
+    writeFixture(mosaicHome, 'not a directory\n');
+
+    expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+      `fleet identity installed is unavailable or unsafe: ${join(mosaicHome, 'SOUL.md')}`,
+    );
+  });
+
+  it('refuses a symlinked default instead of following it', () => {
+    const mosaicHome = createMosaicHome();
+    const source = join(mosaicHome, 'defaults', 'SOUL.md');
+    rmSync(source);
+    symlinkSync(join(mosaicHome, 'defaults', 'USER.md'), source);
+
+    expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+      `fleet identity default is unavailable or unsafe: ${source}`,
+    );
+    expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
+  });
+
+  it('refuses an existing symlinked destination without replacing it', () => {
+    const mosaicHome = createMosaicHome();
+    const destination = join(mosaicHome, 'SOUL.md');
+    symlinkSync(join(mosaicHome, 'defaults', 'SOUL.md'), destination);
+
+    expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+      `fleet identity installed is unavailable or unsafe: ${destination}`,
+    );
+    expect(lstatSync(destination).isSymbolicLink()).toBe(true);
+    expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
+  });
+
+  it.each(['SOUL.md', 'USER.md'] as const)(
+    'rejects a dangling %s destination before publishing its counterpart',
+    (entry) => {
+      const mosaicHome = createMosaicHome();
+      const destination = join(mosaicHome, entry);
+      const counterpart = join(mosaicHome, entry === 'SOUL.md' ? 'USER.md' : 'SOUL.md');
+      symlinkSync(join(mosaicHome, 'missing-identity-target'), destination);
+
+      expect(existsSync(destination)).toBe(false);
+      expect(lstatSync(destination).isSymbolicLink()).toBe(true);
+      expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+        `fleet identity installed is unavailable or unsafe: ${destination}`,
+      );
+      expect(lstatSync(destination).isSymbolicLink()).toBe(true);
+      expect(existsSync(counterpart)).toBe(false);
+    },
+  );
+
+  it('rejects an oversized source before publishing a partial identity', () => {
+    const mosaicHome = createMosaicHome();
+    const source = join(mosaicHome, 'defaults', 'USER.md');
+    writeFixture(source, Buffer.alloc(256 * 1024 + 1, 0x61));
+
+    expect(() => seedFleetIdentityDefaults(mosaicHome)).toThrow(
+      `fleet identity default is unavailable or unsafe: ${source}`,
+    );
+    expect(existsSync(join(mosaicHome, 'SOUL.md'))).toBe(false);
+    expect(existsSync(join(mosaicHome, 'USER.md'))).toBe(false);
+  });
+});
@@ -0,0 +1,120 @@
+import { randomBytes } from 'node:crypto';
+import { linkSync, lstatSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { readRegularFileSecure } from '../fleet/secure-file.js';
+
+const MAX_IDENTITY_CONTRACT_BYTES = 256 * 1024;
+export const FLEET_IDENTITY_DEFAULTS = ['SOUL.md', 'USER.md'] as const;
+
+function isFilesystemError(error: unknown, code: string): boolean {
+  return error instanceof Error && 'code' in error && error.code === code;
+}
+
+/** @internal Publish a complete temporary file without replacing any path. */
+export function linkIdentityContractNoClobber(source: string, destination: string): boolean {
+  try {
+    linkSync(source, destination);
+    return true;
+  } catch (error: unknown) {
+    if (isFilesystemError(error, 'EEXIST')) return false;
+    throw error;
+  }
+}
+
+function unsafeIdentityError(kind: 'default' | 'installed', path: string, error: unknown): Error {
+  const reason = error instanceof Error ? error.message : String(error);
+  return new Error(`fleet identity ${kind} is unavailable or unsafe: ${path} (${reason})`);
+}
+
+function readIdentityContract(
+  mosaicHome: string,
+  path: string,
+  kind: 'default' | 'installed',
+): Buffer {
+  try {
+    return readRegularFileSecure(path, {
+      root: mosaicHome,
+      maxBytes: MAX_IDENTITY_CONTRACT_BYTES,
+    }).content;
+  } catch (error: unknown) {
+    throw unsafeIdentityError(kind, path, error);
+  }
+}
+
+function installedEntryExists(path: string): boolean {
+  try {
+    lstatSync(path);
+    return true;
+  } catch (error: unknown) {
+    if (isFilesystemError(error, 'ENOENT')) return false;
+    throw unsafeIdentityError('installed', path, error);
+  }
+}
+
+/** Secure fleet point-of-use read for a top-level identity contract. */
+export function readInstalledIdentityContractAtPointOfUse(
+  mosaicHome: string,
+  entry: (typeof FLEET_IDENTITY_DEFAULTS)[number],
+): Buffer {
+  const configuredPath = join(mosaicHome, entry);
+  try {
+    // Preserve the launcher's established support for a symlinked Mosaic home,
+    // while pinning this read to the resolved directory. O_NOFOLLOW still
+    // rejects replacement of the identity file itself (or any child ancestor).
+    const canonicalHome = realpathSync(mosaicHome);
+    return readRegularFileSecure(join(canonicalHome, entry), {
+      root: canonicalHome,
+      maxBytes: MAX_IDENTITY_CONTRACT_BYTES,
+    }).content;
+  } catch (error: unknown) {
+    throw unsafeIdentityError('installed', configuredPath, error);
+  }
+}
+
+/**
+ * Seed the generic identity base required by unattended fleet launches.
+ *
+ * Exact seat identity remains roster-owned and is injected later by the
+ * runtime composer. Each destination appears atomically through a hard link to
+ * a complete owner-private temporary file; a concurrent first seat may win the
+ * link without allowing either process to overwrite operator content.
+ */
+export function seedFleetIdentityDefaults(mosaicHome: string): string[] {
+  const snapshots = new Map<(typeof FLEET_IDENTITY_DEFAULTS)[number], Buffer>();
+
+  for (const entry of FLEET_IDENTITY_DEFAULTS) {
+    const destination = join(mosaicHome, entry);
+    if (installedEntryExists(destination)) {
+      readIdentityContract(mosaicHome, destination, 'installed');
+      continue;
+    }
+    const source = join(mosaicHome, 'defaults', entry);
+    snapshots.set(entry, readIdentityContract(mosaicHome, source, 'default'));
+  }
+
+  const seeded: string[] = [];
+  for (const [entry, content] of snapshots) {
+    const destination = join(mosaicHome, entry);
+    const temporary = join(
+      mosaicHome,
+      `.${entry}.fleet-seed-${process.pid.toString()}-${randomBytes(6).toString('hex')}`,
+    );
+    let temporaryCreated = false;
+    try {
+      writeFileSync(temporary, content, { flag: 'wx', mode: 0o600 });
+      temporaryCreated = true;
+      if (linkIdentityContractNoClobber(temporary, destination)) {
+        seeded.push(entry);
+      } else {
+        readIdentityContract(mosaicHome, destination, 'installed');
+      }
+    } finally {
+      if (temporaryCreated) rmSync(temporary, { force: true });
+    }
+  }
+
+  for (const entry of FLEET_IDENTITY_DEFAULTS) {
+    readIdentityContract(mosaicHome, join(mosaicHome, entry), 'installed');
+  }
+  return seeded;
+}
@@ -1,177 +0,0 @@
-import { lstat, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { placeUnitFile, resolveLeaseBrokerSocketForPreflight } from './fleet.js';
-
-/**
- * Unit-placement regression harness for #1292.
- *
- * The two measured defects this suite pins:
- *  1. `systemctl enable <name>` does NOT rewrite an existing by-path
- *     wants-symlink — so placement must remove stale residue explicitly, and
- *     acceptance asserts on the RESULTING SYMLINK TARGET, never on the enable
- *     call's argument (asserting the call cannot see where the link ended up).
- *  2. Node's copyFile FOLLOWS a by-path symlink at the destination and
- *     overwrites the SEED template. Acceptance asserts on the SEED's bytes
- *     AND mtime — unchanged — which is the only check that can redden for
- *     finding 2. The symlink-target assertion catches finding 1; these are
- *     different defects with different failure modes.
- *
- * Fixtures are entirely inside tmpdirs (source template, active systemd dir,
- * wants dir) — no real host paths are touched by this suite.
- */
-
-describe('placeUnitFile (#1292 unit placement)', () => {
-  const cleanup: string[] = [];
-  afterEach(async () => {
-    while (cleanup.length > 0) {
-      await rm(cleanup.pop()!, { recursive: true, force: true });
-    }
-  });
-
-  async function fixture() {
-    const root = await mkdtemp(join(tmpdir(), 'place-unit-'));
-    cleanup.push(root);
-    const seedDir = join(root, 'seed');
-    const activeDir = join(root, 'active');
-    await mkdir(seedDir, { recursive: true });
-    await mkdir(activeDir, { recursive: true });
-    const seedTemplate = join(seedDir, 'unit-under-test.service');
-    await writeFile(
-      seedTemplate,
-      '[Unit]\nDescription=seed template\n[Service]\nType=oneshot\nExecStart=/bin/true\n[Install]\nWantedBy=default.target\n',
-    );
-    const activeSource = join(root, 'active-source.service');
-    await writeFile(
-      activeSource,
-      '[Unit]\nDescription=active copy v2\n[Service]\nType=oneshot\nExecStart=/bin/true\n[Install]\nWantedBy=default.target\n',
-    );
-    return { root, seedDir, activeDir, seedTemplate, activeSource };
-  }
-
-  it('places a regular file on a clean host (negative control: no residue anywhere)', async () => {
-    const f = await fixture();
-    const result = await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-    expect(result.unlinkedDestinationSymlink).toBe(false);
-    expect(result.removedStaleWantsSymlink).toBe(false);
-    const info = await lstat(join(f.activeDir, 'unit-under-test.service'));
-    expect(info.isSymbolicLink()).toBe(false);
-    expect(await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8')).toContain(
-      'active copy v2',
-    );
-    // Seed untouched by construction — but assert it, so the clean-host case
-    // cannot silently regress into seed-mutation.
-    expect(await readFile(f.seedTemplate, 'utf8')).toContain('seed template');
-  });
-
-  it('by-path residue: unlinks destination symlink, places the file, seed bytes AND mtime unchanged (finding 2)', async () => {
-    const f = await fixture();
-    const seedBefore = await readFile(f.seedTemplate, 'utf8');
-    const mtimeBefore = (await lstat(f.seedTemplate)).mtimeMs;
-    // The fomo-lin convention: by-path enable left a symlink AT the unit name
-    // pointing at the seed template, plus a wants-symlink doing the same.
-    await symlink(f.seedTemplate, join(f.activeDir, 'unit-under-test.service'));
-    const wantsDir = join(f.activeDir, 'default.target.wants');
-    await mkdir(wantsDir, { recursive: true });
-    await symlink(f.seedTemplate, join(wantsDir, 'unit-under-test.service'));
-
-    const result = await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-    expect(result.unlinkedDestinationSymlink).toBe(true);
-    expect(result.removedStaleWantsSymlink).toBe(true);
-
-    // FINDING 2's check: the seed is byte-identical and its mtime did not move.
-    expect(await readFile(f.seedTemplate, 'utf8')).toBe(seedBefore);
-    expect((await lstat(f.seedTemplate)).mtimeMs).toBe(mtimeBefore);
-
-    // The destination is now a regular file carrying the ACTIVE content.
-    const destInfo = await lstat(join(f.activeDir, 'unit-under-test.service'));
-    expect(destInfo.isSymbolicLink()).toBe(false);
-    expect(await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8')).toContain(
-      'active copy v2',
-    );
-  });
-
-  it('by-path residue: no wants-symlink remains pointing at the seed (finding 1 residue cleared)', async () => {
-    const f = await fixture();
-    await symlink(f.seedTemplate, join(f.activeDir, 'unit-under-test.service'));
-    const wantsDir = join(f.activeDir, 'default.target.wants');
-    await mkdir(wantsDir, { recursive: true });
-    await symlink(f.seedTemplate, join(wantsDir, 'unit-under-test.service'));
-
-    await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-
-    // After placement the stale wants link is GONE (enable-by-name recreates
-    // it correctly). A link still present must not point at the seed.
-    try {
-      const link = await lstat(join(wantsDir, 'unit-under-test.service'));
-      if (link.isSymbolicLink()) {
-        const target = await readFile(join(wantsDir, 'unit-under-test.service'), 'utf8').catch(
-          async () => '',
-        );
-        expect(target).not.toContain('seed template');
-      }
-    } catch {
-      // absent wants link — the expected post-placement state
-    }
-  });
-
-  it('idempotence: second placement on a reconciled host is a no-op producing the identical final state', async () => {
-    const f = await fixture();
-    // Reconciled starting state: regular file at the name, wants link to the active copy.
-    await writeFile(
-      join(f.activeDir, 'unit-under-test.service'),
-      await readFile(f.activeSource, 'utf8'),
-    );
-    const wantsDir = join(f.activeDir, 'default.target.wants');
-    await mkdir(wantsDir, { recursive: true });
-    await symlink(
-      join(f.activeDir, 'unit-under-test.service'),
-      join(wantsDir, 'unit-under-test.service'),
-    );
-    const before = await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8');
-
-    const result = await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-    // No destructive step fired: no unlink, no wants removal.
-    expect(result.unlinkedDestinationSymlink).toBe(false);
-    expect(result.removedStaleWantsSymlink).toBe(false);
-    // Identical final state.
-    expect(await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8')).toBe(before);
-    const link = await lstat(join(wantsDir, 'unit-under-test.service'));
-    expect(link.isSymbolicLink()).toBe(true);
-  });
-
-  it('double install on by-path residue converges to the identical reconciled state', async () => {
-    const f = await fixture();
-    await symlink(f.seedTemplate, join(f.activeDir, 'unit-under-test.service'));
-    const wantsDir = join(f.activeDir, 'default.target.wants');
-    await mkdir(wantsDir, { recursive: true });
-    await symlink(f.seedTemplate, join(wantsDir, 'unit-under-test.service'));
-
-    await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-    const first = await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8');
-    const secondRun = await placeUnitFile(f.activeSource, f.activeDir, 'unit-under-test.service');
-    const second = await readFile(join(f.activeDir, 'unit-under-test.service'), 'utf8');
-    expect(secondRun.unlinkedDestinationSymlink).toBe(false);
-    expect(second).toBe(first);
-  });
-});
-
-describe('resolveLeaseBrokerSocketForPreflight (#1292 preflight resolution)', () => {
-  it('explicit MOSAIC_LEASE_BROKER_SOCKET wins', () => {
-    expect(
-      resolveLeaseBrokerSocketForPreflight({ MOSAIC_LEASE_BROKER_SOCKET: '/custom/sock' }, 1000),
-    ).toBe('/custom/sock');
-  });
-  it('XDG_RUNTIME_DIR next', () => {
-    expect(resolveLeaseBrokerSocketForPreflight({ XDG_RUNTIME_DIR: '/run/user/1001' }, 1000)).toBe(
-      '/run/user/1001/mosaic-lease/broker.sock',
-    );
-  });
-  it('falls back to /run/user/<uid>', () => {
-    expect(resolveLeaseBrokerSocketForPreflight({}, 1002)).toBe(
-      '/run/user/1002/mosaic-lease/broker.sock',
-    );
-  });
-});
@@ -835,25 +835,13 @@ describe('fleet command construction', () => {
    };
    const program = new Command();
    program.exitOverride();
-    // #1292: inject a present broker socket so the preflight passes and this
-    // spec keeps testing its ORIGINAL property (holder-before-agent ordering).
-    // The preflight's own refusal behavior has dedicated specs below.
-    registerFleetCommand(program, {
-      runner,
-      mosaicHome: home,
-      checkBrokerSocket: async () => true,
-    });
+    registerFleetCommand(program, { runner, mosaicHome: home });

    try {
      await program.parseAsync(['node', 'mosaic', 'fleet', 'start']);
      await program.parseAsync(['node', 'mosaic', 'fleet', 'stop']);

      expect(calls).toEqual([
-        // #1292: fleet start enables + starts the broker FIRST (enable is
-        // idempotent; the unit exists after install), re-checking the socket
-        // before any holder/agent lifecycle effect.
-        ['systemctl', '--user', 'enable', 'mosaic-lease-broker.service'],
-        ['systemctl', '--user', 'start', 'mosaic-lease-broker.service'],
        ['systemctl', '--user', 'start', 'mosaic-tmux-holder.service'],
        ['systemctl', '--user', 'start', '[email protected]'],
        ['systemctl', '--user', 'stop', '[email protected]'],
@@ -864,92 +852,6 @@ describe('fleet command construction', () => {
    }
  });

-  it('fleet start refuses with a named error when the broker socket does not appear (#1292)', async () => {
-    const home = await tempDir();
-    const rosterPath = join(home, 'fleet', 'roster.yaml');
-    await mkdir(join(home, 'fleet'), { recursive: true });
-    await writeFile(
-      rosterPath,
-      ['version: 1', 'transport: tmux', 'agents:', '  - name: coder0', '    runtime: codex'].join(
-        '\n',
-      ),
-    );
-    const calls: string[][] = [];
-    const runner: CommandRunner = async (command, args) => {
-      calls.push([command, ...args]);
-      return { stdout: '', stderr: '', exitCode: 0 };
-    };
-    const program = new Command();
-    program.exitOverride();
-    const errors: string[] = [];
-    const origError = console.error;
-    console.error = (...args: unknown[]) => {
-      errors.push(args.join(' '));
-    };
-    registerFleetCommand(program, {
-      runner,
-      mosaicHome: home,
-      checkBrokerSocket: async () => false,
-    });
-    try {
-      await program.parseAsync(['node', 'mosaic', 'fleet', 'start']);
-      // Refused: no holder/agent starts were issued after the broker attempt.
-      expect(calls).toEqual([
-        ['systemctl', '--user', 'enable', 'mosaic-lease-broker.service'],
-        ['systemctl', '--user', 'start', 'mosaic-lease-broker.service'],
-      ]);
-      expect(errors.join('\n')).toContain('broker-absent');
-      expect(errors.join('\n')).toContain('mosaic fleet install');
-    } finally {
-      console.error = origError;
-      await rm(home, { recursive: true, force: true });
-    }
-  });
-
-  it('fleet start re-probes the broker on the SECOND invocation — no ActiveState trust (#1292 sticky half)', async () => {
-    const home = await tempDir();
-    const rosterPath = join(home, 'fleet', 'roster.yaml');
-    await mkdir(join(home, 'fleet'), { recursive: true });
-    await writeFile(
-      rosterPath,
-      ['version: 1', 'transport: tmux', 'agents:', '  - name: coder0', '    runtime: codex'].join(
-        '\n',
-      ),
-    );
-    const calls: string[][] = [];
-    const runner: CommandRunner = async (command, args) => {
-      calls.push([command, ...args]);
-      return { stdout: '', stderr: '', exitCode: 0 };
-    };
-    const program = new Command();
-    program.exitOverride();
-    // Broker socket NEVER appears — the second start must refuse exactly like
-    // the first; RemainAfterExit-style stale unit state changes nothing
-    // because the check is the socket, not systemctl.
-    registerFleetCommand(program, {
-      runner,
-      mosaicHome: home,
-      checkBrokerSocket: async () => false,
-    });
-    const errors: string[] = [];
-    const origError = console.error;
-    console.error = (...args: unknown[]) => {
-      errors.push(args.join(' '));
-    };
-    try {
-      await program.parseAsync(['node', 'mosaic', 'fleet', 'start']);
-      await program.parseAsync(['node', 'mosaic', 'fleet', 'start']);
-      // Two invocations, each refusing after its own broker attempt:
-      expect(
-        calls.filter((c) => c.join(' ') === 'systemctl --user start [email protected]'),
-      ).toHaveLength(0);
-      expect(errors.filter((e) => e.includes('broker-absent')).length).toBeGreaterThanOrEqual(2);
-    } finally {
-      console.error = origError;
-      await rm(home, { recursive: true, force: true });
-    }
-  });
-
  it('waits for an in-flight restart to clear before relaunching (re-entry guard)', async () => {
    const home = await tempDir();
    const rosterPath = join(home, 'fleet', 'roster.yaml');
@@ -2163,19 +2065,8 @@ describe('fleet install — auto-enable units for boot-survival', () => {

    await enableFleetUnits(runner, minimalRoster, {});

-    expect(calls).toContainEqual(['systemctl', '--user', 'enable', 'mosaic-lease-broker.service']);
    expect(calls).toContainEqual(['systemctl', '--user', 'enable', 'mosaic-tmux-holder.service']);
    expect(calls).toContainEqual(['systemctl', '--user', 'enable', '[email protected]']);
-    // The broker must be enabled BEFORE the holder and agents: a start of any
-    // gated runtime without the broker is exactly the #1292 4-second death.
-    const brokerIndex = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user enable mosaic-lease-broker.service',
-    );
-    const holderIndex = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user enable mosaic-tmux-holder.service',
-    );
-    expect(brokerIndex).toBeGreaterThanOrEqual(0);
-    expect(brokerIndex).toBeLessThan(holderIndex);
  });

  it('install still succeeds when systemctl enable returns non-zero (non-fatal)', async () => {
@@ -3,11 +3,9 @@ import {
  access,
  chmod,
  copyFile,
-  lstat,
  mkdir,
  open,
  readFile,
-  readlink,
  stat,
  unlink,
  writeFile,
@@ -91,8 +89,6 @@ export type SleepFn = (ms: number) => Promise<void>;

 export interface FleetCommandDeps {
  runner?: CommandRunner;
-  /** Test seam for the #1292 fleet-start broker preflight (socket presence). */
-  checkBrokerSocket?: (path: string) => Promise<boolean> | boolean;
  /** Injectable interactive runner for commands needing inherited TTY (e.g., `tmux attach`). */
  interactiveRunner?: InteractiveRunner;
  /**
@@ -801,96 +797,6 @@ export function buildSystemdEnableCommand(unit: string): string[] {
  return ['systemctl', '--user', 'enable', unit];
 }

-/**
- * Place a unit file into the ACTIVE systemd user directory, never through a
- * symlink (#1292, measured 2026-08-17).
- *
- * ⚠ SET-INDEPENDENCE (fomo-lin, 2026-08-17): the set of unit names carrying
- * by-path residue and the set of unit names this install copies are
- * INDEPENDENT. Until 0.0.50 they were disjoint only by accident of which
- * units the install happened to name — fomo-lin survived copy-through solely
- * because its one by-path symlink (the broker) was the one unit the install
- * did NOT copy. Adding the broker to the copy set made the intersection
- * non-empty on the first run. Whoever adds a fifth unit to the placement
- * list inherits this helper and its unlink step; do not place units with a
- * bare copyFile.
- *
- * A host provisioned by the enable-by-path convention carries a symlink AT
- * the unit-name path in ~/.config/systemd/user/ pointing at the shipped
- * template under ~/.config/mosaic/systemd/user/. Node's copyFile FOLLOWS
- * that link and overwrites the SEED template instead of placing the active
- * unit (verified with fs.copyFile on a throwaway systemd user instance) —
- * silent, rc=0, and it mutates the directory every later reseed reads from.
- * The same measurement showed `systemctl enable <name>` does NOT rewrite an
- * existing by-path wants-symlink, so reconciliation must be explicit.
- *
- * Placement therefore: if the destination is a symlink, unlink it first
- * (unlink → copy — copy-then-unlink would mutate the seed and then destroy
- * the evidence that it did); then copy. Also removes a stale
- * `default.target.wants/<name>` symlink that points outside the active
- * directory (readlink — NOT readFile, which follows the link and returns the
- * target's CONTENT), so the subsequent enable-by-name recreates it against
- * the active copy. Idempotent: on a clean or already-reconciled destination
- * every step is a no-op (the copy rewrites identical bytes).
- *
- * Returns what was done, for assertions and install reporting.
- */
-export interface PlaceUnitResult {
-  readonly unit: string;
-  readonly destination: string;
-  /** A symlink at the unit-name path was unlinked (by-path residue). */
-  readonly unlinkedDestinationSymlink: boolean;
-  /** A stale wants-symlink pointing outside the active dir was removed. */
-  readonly removedStaleWantsSymlink: boolean;
-}
-
-export async function placeUnitFile(
-  source: string,
-  systemdUserDir: string,
-  unit: string,
-): Promise<PlaceUnitResult> {
-  const destination = join(systemdUserDir, unit);
-  let unlinkedDestinationSymlink = false;
-  try {
-    const destInfo = await lstat(destination);
-    if (destInfo.isSymbolicLink()) {
-      await unlink(destination);
-      unlinkedDestinationSymlink = true;
-    }
-  } catch {
-    // absent destination — nothing to unlink
-  }
-  await copyFile(source, destination);
-
-  let removedStaleWantsSymlink = false;
-  const wantsLink = join(systemdUserDir, 'default.target.wants', unit);
-  try {
-    const wantsInfo = await lstat(wantsLink);
-    if (wantsInfo.isSymbolicLink()) {
-      // readlink — NOT readFile: readFile FOLLOWS the link and returns the
-      // target file's CONTENT, which is not the question being asked.
-      let target: string | undefined;
-      try {
-        target = await readlink(wantsLink);
-      } catch {
-        target = undefined;
-      }
-      // Normalize (systemctl writes absolute targets; a relative one resolves
-      // against the wants dir). A wants-symlink pointing anywhere other than
-      // the active copy (the by-path convention points at the seed template)
-      // survives enable-by-name unchanged — remove it so enable recreates it.
-      if (target !== undefined && resolve(dirname(wantsLink), target) !== destination) {
-        await unlink(wantsLink);
-        removedStaleWantsSymlink = true;
-      }
-    }
-  } catch {
-    // absent wants link — nothing to reconcile
-  }
-
-  return { unit, destination, unlinkedDestinationSymlink, removedStaleWantsSymlink };
-}
-
 /**
 * Returns the systemctl --user disable command for a given unit.
 * Used by `fleet remove` so a removed agent's enabled unit cannot resurrect on
@@ -925,22 +831,6 @@ export async function enableFleetUnits(
    let succeeded = 0;
    let failed = 0;

-    // The lease broker ships with the fleet and every gated runtime needs it
-    // (#1292): seats die at lease registration without it, and no documented
-    // path ever enabled it. Enabled first — alongside the holder — and the
-    // unit must have been placed by installFleet's placeUnitFile step.
-    const brokerResult = await runner(
-      ...splitCommand(buildSystemdEnableCommand('mosaic-lease-broker.service')),
-    );
-    if (brokerResult.exitCode === 0) {
-      succeeded++;
-    } else {
-      failed++;
-      process.stderr.write(
-        `Warning: could not enable mosaic-lease-broker.service: ${brokerResult.stderr || brokerResult.stdout || 'non-zero exit'}\n`,
-      );
-    }
-
    const holderResult = await runner(
      ...splitCommand(buildSystemdEnableCommand('mosaic-tmux-holder.service')),
    );
@@ -1637,7 +1527,7 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
    .description('Install local fleet tools and user systemd units')
    .option('--no-enable', 'Skip enabling units for boot-survival')
    .action(async (opts: { enable?: boolean }) => {
-      await installFleet(cmd, frameworkRoot, runner);
+      await installFleet(cmd, frameworkRoot);
      // Unit enablement needs agent names only, so it reads either version.
      const roster = await loadRosterReadModel(cmd);
      await enableFleetUnits(runner, roster, opts);
@@ -1648,7 +1538,7 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
    .description('Install local fleet tools and user systemd units')
    .option('--no-enable', 'Skip enabling units for boot-survival')
    .action(async (opts: { enable?: boolean }) => {
-      await installFleet(cmd, frameworkRoot, runner);
+      await installFleet(cmd, frameworkRoot);
      // Unit enablement needs agent names only, so it reads either version.
      const roster = await loadRosterReadModel(cmd);
      await enableFleetUnits(runner, roster, opts);
@@ -1701,37 +1591,6 @@ export function registerFleetCommand(program: Command, deps: FleetCommandDeps =
            );
            return;
          }
-          if (action === 'start') {
-            // Broker preflight (#1292), re-probed on EVERY invocation: a
-            // gated runtime started without a live lease broker dies ~4s in
-            // while the unit reports active (RemainAfterExit) — enabling +
-            // starting here and then RE-CHECKING the socket refuses loudly
-            // instead of reporting rc0 over a doomed start. This is the
-            // second-start check as much as the first: it never trusts unit
-            // ActiveState.
-            await runChecked(runner, [
-              'systemctl',
-              '--user',
-              'enable',
-              'mosaic-lease-broker.service',
-            ]);
-            await runChecked(runner, [
-              'systemctl',
-              '--user',
-              'start',
-              'mosaic-lease-broker.service',
-            ]);
-            if (!(await brokerSocketPresent(deps))) {
-              console.error(
-                '[fleet] broker-absent: lease broker socket did not appear after enable+start (#1292).',
-              );
-              console.error(
-                '[fleet] remedy: mosaic fleet install (it reconciles either enable convention)',
-              );
-              process.exitCode = 1;
-              return;
-            }
-          }
          if (action === 'restart') {
            // Serialize the holder+agents teardown/relaunch behind the restart lock
            // so a re-entrant restart waits for clean shutdown before relaunching,
@@ -2490,11 +2349,7 @@ export function registerFleetAgentCommands(
    });
 }

-async function installFleet(
-  cmd: Command,
-  frameworkRoot: string,
-  runner: CommandRunner,
-): Promise<void> {
+async function installFleet(cmd: Command, frameworkRoot: string): Promise<void> {
  const activePaths = resolveFleetPaths(cmd.opts<{ mosaicHome: string }>().mosaicHome);
  assertDefaultMosaicHomeForSystemd(activePaths.mosaicHome);
  // Read model first: every file this function places is roster-independent, and
@@ -2546,40 +2401,18 @@ async function installFleet(
  for (const toolPath of executableToolPaths) {
    await chmod(toolPath, 0o755);
  }
-  // Unit placement (#1292): every unit goes through placeUnitFile — never a
-  // bare copyFile — so a by-path-enable symlink at the destination is
-  // unlinked rather than written through (copy-through would silently
-  // overwrite the SEED template, measured 2026-08-17). The lease broker unit
-  // is placed here too: previously the install named three units and omitted
-  // the broker entirely, which is why no documented path ever enabled it.
-  const placedUnits = await Promise.all(
-    [
-      'mosaic-tmux-holder.service',
-      '[email protected]',
-      '[email protected]',
-      'mosaic-lease-broker.service',
-    ].map((unit) =>
-      placeUnitFile(join(frameworkRoot, 'systemd', 'user', unit), activePaths.systemdUserDir, unit),
-    ),
+  await copyFile(
+    join(frameworkRoot, 'systemd', 'user', 'mosaic-tmux-holder.service'),
+    join(activePaths.systemdUserDir, 'mosaic-tmux-holder.service'),
  );
-  const reconciled = placedUnits.filter(
-    (result) => result.unlinkedDestinationSymlink || result.removedStaleWantsSymlink,
+  await copyFile(
+    join(frameworkRoot, 'systemd', 'user', '[email protected]'),
+    join(activePaths.systemdUserDir, '[email protected]'),
+  );
+  await copyFile(
+    join(frameworkRoot, 'systemd', 'user', '[email protected]'),
+    join(activePaths.systemdUserDir, '[email protected]'),
  );
-  if (reconciled.length > 0) {
-    console.log(
-      `Reconciled ${reconciled.length} unit placement(s) from by-path enable residue: ${reconciled.map((r) => r.unit).join(', ')}`,
-    );
-  }
-  // systemd will not see a replaced unit file without a reload; do it once
-  // after all placements, before any enable call below. runCommand never
-  // rejects (it resolves exitCode 127 on spawn error), so a plain await with
-  // an exitCode check matches the rest of this file's systemctl handling.
-  const reloadResult = await runner(...splitCommand(['systemctl', '--user', 'daemon-reload']));
-  if (reloadResult.exitCode !== 0) {
-    process.stderr.write(
-      `Warning: systemctl --user daemon-reload after unit placement failed (non-systemd host?): ${reloadResult.stderr || reloadResult.stdout || 'non-zero exit'}\n`,
-    );
-  }

  // On roster v2 the reconciler owns the generated env: `apply` writes it and
  // `regen` rebuilds it, both from projectRosterV2AgentGeneratedEnv. Writing it
@@ -2776,40 +2609,6 @@ function splitCommand(command: string[]): [string, string[]] {
  return [bin, args];
 }

-/**
- * Lease-broker socket presence for the fleet-start preflight (#1292).
- * Resolution precedence matches launch.ts's defaultLeaseBrokerSocket and
- * start-agent-session.sh's broker_socket_path: explicit
- * MOSAIC_LEASE_BROKER_SOCKET, else $XDG_RUNTIME_DIR/mosaic-lease/broker.sock,
- * else /run/user/<uid>/mosaic-lease/broker.sock. Pure filesystem check — this
- * deliberately does NOT consult systemd state: a unit can be active
- * (RemainAfterExit) with no live socket, and the socket is the thing the
- * gated runtime connects to. Injectable via deps for tests.
- */
-export function resolveLeaseBrokerSocketForPreflight(
-  env: NodeJS.ProcessEnv = process.env,
-  uid: number = typeof process.getuid === 'function' ? process.getuid() : 0,
-): string {
-  if (env['MOSAIC_LEASE_BROKER_SOCKET']) return env['MOSAIC_LEASE_BROKER_SOCKET'];
-  const runtimeDir = env['XDG_RUNTIME_DIR'] ?? `/run/user/${uid}`;
-  return join(runtimeDir, 'mosaic-lease', 'broker.sock');
-}
-
-async function brokerSocketPresent(
-  deps: FleetCommandDeps,
-  env: NodeJS.ProcessEnv = process.env,
-): Promise<boolean> {
-  const check = deps.checkBrokerSocket;
-  if (check) return check(resolveLeaseBrokerSocketForPreflight(env));
-  try {
-    const socketPath = resolveLeaseBrokerSocketForPreflight(env);
-    await access(socketPath, constants.S_IFSOCK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /** All supported fleet profile names. */
 export type FleetProfile =
  | 'general'
@@ -0,0 +1,393 @@
+import { spawn, spawnSync, type SpawnSyncReturns } from 'node:child_process';
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, describe, expect, it } from 'vitest';
+
+const CLI_PATH = fileURLToPath(new URL('../../dist/cli.js', import.meta.url));
+const DEFAULT_SOUL_PATH = fileURLToPath(
+  new URL('../../framework/defaults/SOUL.md', import.meta.url),
+);
+const DEFAULT_USER_PATH = fileURLToPath(
+  new URL('../../framework/defaults/USER.md', import.meta.url),
+);
+
+interface GreenfieldFixture {
+  readonly root: string;
+  readonly home: string;
+  readonly mosaicHome: string;
+  readonly binDir: string;
+  readonly capturePath: string;
+}
+
+interface AsyncLaunchResult {
+  readonly status: number | null;
+  readonly signal: NodeJS.Signals | null;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+
+const fixtures: string[] = [];
+
+function writeFixture(path: string, content: string, mode: number = 0o600): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, content, { encoding: 'utf8', mode });
+  chmodSync(path, mode);
+}
+
+function createGreenfieldFixture(): GreenfieldFixture {
+  const root = mkdtempSync(join(tmpdir(), 'mosaic-first-start-'));
+  fixtures.push(root);
+  const home = join(root, 'home');
+  const mosaicHome = join(home, '.config', 'mosaic');
+  const binDir = join(root, 'bin');
+  const capturePath = join(root, 'runtime-boundary.json');
+
+  mkdirSync(binDir, { recursive: true, mode: 0o700 });
+  writeFixture(join(mosaicHome, 'AGENTS.md'), '# Agent dispatcher\n');
+  writeFixture(join(mosaicHome, 'runtime', 'pi', 'RUNTIME.md'), '# Pi runtime\n');
+  writeFixture(join(mosaicHome, 'defaults', 'SOUL.md'), readFileSync(DEFAULT_SOUL_PATH, 'utf8'));
+  writeFixture(join(mosaicHome, 'defaults', 'USER.md'), readFileSync(DEFAULT_USER_PATH, 'utf8'));
+  writeFixture(
+    join(mosaicHome, 'fleet', 'roster.yaml'),
+    `version: 1
+transport: tmux
+tmux:
+  socket_name: mosaic-fleet
+  holder_session: _holder
+defaults:
+  working_directory: ~
+runtimes:
+  pi:
+    reset_command: /new
+agents:
+  - name: unattended-seat
+    runtime: pi
+    class: worker
+`,
+  );
+  writeFixture(
+    join(mosaicHome, 'tools', 'tmux', 'agent-send.sh'),
+    '#!/usr/bin/env bash\nexit 0\n',
+    0o755,
+  );
+  writeFixture(
+    join(mosaicHome, 'tools', 'lease-broker', 'launch-runtime.py'),
+    `#!/usr/bin/env python3
+import json
+import os
+import pathlib
+import sys
+pathlib.Path(os.environ["MOSAIC_TEST_RUNTIME_CAPTURE"]).write_text(
+    json.dumps({"argv": sys.argv[1:]}), encoding="utf-8"
+)
+`,
+    0o755,
+  );
+  // checkRuntime() must find Pi, while the fake broker boundary prevents this
+  // executable from running or making a provider call.
+  writeFixture(join(binDir, 'pi'), '#!/usr/bin/env bash\nexit 97\n', 0o755);
+
+  return { root, home, mosaicHome, binDir, capturePath };
+}
+
+function launchEnvironment(
+  fixture: GreenfieldFixture,
+  capturePath: string,
+  fleet: boolean = true,
+  agentName: string = 'unattended-seat',
+  agentClass: string = 'worker',
+): NodeJS.ProcessEnv {
+  return {
+    HOME: fixture.home,
+    MOSAIC_HOME: fixture.mosaicHome,
+    ...(fleet
+      ? {
+          MOSAIC_AGENT_NAME: agentName,
+          MOSAIC_AGENT_CLASS: agentClass,
+        }
+      : {}),
+    MOSAIC_TEST_RUNTIME_CAPTURE: capturePath,
+    PATH: `${fixture.binDir}:/usr/bin:/bin`,
+  };
+}
+
+function launchSync(
+  fixture: GreenfieldFixture,
+  options: {
+    readonly capturePath?: string;
+    readonly fleet?: boolean;
+    readonly agentName?: string;
+    readonly agentClass?: string;
+  } = {},
+): SpawnSyncReturns<string> {
+  const capturePath = options.capturePath ?? fixture.capturePath;
+  return spawnSync(process.execPath, [CLI_PATH, 'yolo', 'pi'], {
+    cwd: fixture.root,
+    encoding: 'utf8',
+    input: '',
+    timeout: 10_000,
+    env: launchEnvironment(
+      fixture,
+      capturePath,
+      options.fleet ?? true,
+      options.agentName ?? 'unattended-seat',
+      options.agentClass ?? 'worker',
+    ),
+  });
+}
+
+function launchAsync(fixture: GreenfieldFixture, capturePath: string): Promise<AsyncLaunchResult> {
+  return new Promise<AsyncLaunchResult>((resolve, reject): void => {
+    const child = spawn(process.execPath, [CLI_PATH, 'yolo', 'pi'], {
+      cwd: fixture.root,
+      env: launchEnvironment(fixture, capturePath),
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', (chunk: string): void => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', (chunk: string): void => {
+      stderr += chunk;
+    });
+    child.on('error', reject);
+    child.on('close', (status: number | null, signal: NodeJS.Signals | null): void => {
+      resolve({ status, signal, stdout, stderr });
+    });
+    child.stdin.end();
+  });
+}
+
+function outputOf(result: { readonly stdout: string; readonly stderr: string }): string {
+  return `${result.stdout}${result.stderr}`;
+}
+
+function assertPrivateDefaultSeeds(fixture: GreenfieldFixture): void {
+  const soul = join(fixture.mosaicHome, 'SOUL.md');
+  const user = join(fixture.mosaicHome, 'USER.md');
+  expect(readFileSync(soul, 'utf8')).toBe(readFileSync(DEFAULT_SOUL_PATH, 'utf8'));
+  expect(readFileSync(user, 'utf8')).toBe(readFileSync(DEFAULT_USER_PATH, 'utf8'));
+  expect(statSync(soul).mode & 0o777).toBe(0o600);
+  expect(statSync(user).mode & 0o777).toBe(0o600);
+}
+
+function capturedArguments(path: string): string[] {
+  const capture = JSON.parse(readFileSync(path, 'utf8')) as { argv: string[] };
+  return capture.argv;
+}
+
+afterEach((): void => {
+  for (const root of fixtures.splice(0)) {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+describe('fleet unattended first start (#1264)', () => {
+  it('reaches the runtime boundary without a TTY or identity wizard on a clean install', () => {
+    const fixture = createGreenfieldFixture();
+    const result = launchSync(fixture);
+    const output = outputOf(result);
+
+    expect(result.error, output).toBeUndefined();
+    expect(result.status, output).toBe(0);
+    expect(output).toContain('Initialized unattended fleet identity defaults: SOUL.md, USER.md');
+    expect(output).not.toContain('Running setup wizard');
+    expect(output).not.toContain('What would you like to do?');
+    expect(existsSync(fixture.capturePath), output).toBe(true);
+    assertPrivateDefaultSeeds(fixture);
+
+    const argv = capturedArguments(fixture.capturePath);
+    expect(argv).toContain('--runtime');
+    expect(argv.join('\n')).toContain('Agent/session: `unattended-seat`');
+    expect(argv.join('\n')).toContain('Role/class: `worker`');
+  });
+
+  it('preserves existing operator identity bytes without requiring defaults', () => {
+    const fixture = createGreenfieldFixture();
+    const customSoul = '# Operator soul\nNever replace this.\n';
+    const customUser = '# Operator user\nNever replace this either.\n';
+    writeFixture(join(fixture.mosaicHome, 'SOUL.md'), customSoul, 0o640);
+    writeFixture(join(fixture.mosaicHome, 'USER.md'), customUser, 0o600);
+    rmSync(join(fixture.mosaicHome, 'defaults'), { recursive: true, force: true });
+
+    const first = launchSync(fixture);
+    const secondCapture = join(fixture.root, 'runtime-boundary-second.json');
+    const second = launchSync(fixture, { capturePath: secondCapture });
+
+    expect(first.status, outputOf(first)).toBe(0);
+    expect(second.status, outputOf(second)).toBe(0);
+    expect(readFileSync(join(fixture.mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
+    expect(readFileSync(join(fixture.mosaicHome, 'USER.md'), 'utf8')).toBe(customUser);
+    expect(statSync(join(fixture.mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
+    expect(existsSync(fixture.capturePath)).toBe(true);
+    expect(existsSync(secondCapture)).toBe(true);
+  });
+
+  it('seeds only the missing identity contract and leaves a custom SOUL byte-exact', () => {
+    const fixture = createGreenfieldFixture();
+    const customSoul = '# Exact custom soul bytes\n';
+    writeFixture(join(fixture.mosaicHome, 'SOUL.md'), customSoul, 0o640);
+
+    const result = launchSync(fixture);
+
+    expect(result.status, outputOf(result)).toBe(0);
+    expect(outputOf(result)).toContain('Initialized unattended fleet identity defaults: USER.md');
+    expect(readFileSync(join(fixture.mosaicHome, 'SOUL.md'), 'utf8')).toBe(customSoul);
+    expect(statSync(join(fixture.mosaicHome, 'SOUL.md')).mode & 0o777).toBe(0o640);
+    expect(readFileSync(join(fixture.mosaicHome, 'USER.md'), 'utf8')).toBe(
+      readFileSync(DEFAULT_USER_PATH, 'utf8'),
+    );
+  });
+
+  it('fails closed without a wizard or partial seed when a required default is missing', () => {
+    const fixture = createGreenfieldFixture();
+    const missingDefault = join(fixture.mosaicHome, 'defaults', 'USER.md');
+    rmSync(missingDefault);
+
+    const result = launchSync(fixture);
+    const output = outputOf(result);
+
+    expect(result.status, output).toBe(1);
+    expect(output).toContain('unattended fleet identity initialization failed');
+    expect(output).toContain(missingDefault);
+    expect(output).not.toContain('Running setup wizard');
+    expect(output).not.toContain('What would you like to do?');
+    expect(existsSync(fixture.capturePath)).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
+  });
+
+  it('rejects a symlinked identity default without following it or prompting', () => {
+    const fixture = createGreenfieldFixture();
+    const soulDefault = join(fixture.mosaicHome, 'defaults', 'SOUL.md');
+    rmSync(soulDefault);
+    symlinkSync(DEFAULT_SOUL_PATH, soulDefault);
+
+    const result = launchSync(fixture);
+    const output = outputOf(result);
+
+    expect(result.status, output).toBe(1);
+    expect(output).toContain(`fleet identity default is unavailable or unsafe: ${soulDefault}`);
+    expect(output).not.toContain('Running setup wizard');
+    expect(existsSync(fixture.capturePath)).toBe(false);
+  });
+
+  it('refuses an unknown ambient fleet name before seeding or prompting', () => {
+    const fixture = createGreenfieldFixture();
+
+    const result = launchSync(fixture, { agentName: 'not-in-the-roster' });
+    const output = outputOf(result);
+
+    expect(result.status, output).toBe(1);
+    expect(output).toContain('canonical fleet identity is unavailable');
+    expect(output).toContain('Agent "not-in-the-roster" is not in the fleet roster');
+    expect(output).not.toContain('Running setup wizard');
+    expect(existsSync(fixture.capturePath)).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
+  });
+
+  it('refuses a mismatched ambient fleet class before seeding or prompting', () => {
+    const fixture = createGreenfieldFixture();
+
+    const result = launchSync(fixture, { agentClass: 'reviewer' });
+    const output = outputOf(result);
+
+    expect(result.status, output).toBe(1);
+    expect(output).toContain('Refusing split identity authority');
+    expect(output).not.toContain('Running setup wizard');
+    expect(existsSync(fixture.capturePath)).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
+  });
+
+  it.each(['', ' ', '\t'])(
+    'refuses explicit blank ambient fleet class %j before seeding',
+    (agentClass: string) => {
+      const fixture = createGreenfieldFixture();
+
+      const result = launchSync(fixture, { agentClass });
+      const output = outputOf(result);
+
+      expect(result.status, output).toBe(1);
+      expect(output).toContain('Refusing split identity authority');
+      expect(output).not.toContain('Running setup wizard');
+      expect(existsSync(fixture.capturePath)).toBe(false);
+      expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+      expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
+    },
+  );
+
+  it.each([' unattended-seat', 'unattended-seat ', ''])(
+    'refuses non-exact ambient fleet name %j before seeding',
+    (agentName: string) => {
+      const fixture = createGreenfieldFixture();
+
+      const result = launchSync(fixture, { agentName });
+      const output = outputOf(result);
+
+      expect(result.status, output).toBe(1);
+      expect(output).toContain(
+        'MOSAIC_AGENT_NAME must be a non-empty exact roster name with no surrounding whitespace',
+      );
+      expect(output).not.toContain('Running setup wizard');
+      expect(existsSync(fixture.capturePath)).toBe(false);
+      expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+      expect(existsSync(join(fixture.mosaicHome, 'USER.md'))).toBe(false);
+    },
+  );
+
+  it('keeps the interactive wizard path for a standalone launch', () => {
+    const fixture = createGreenfieldFixture();
+
+    const result = launchSync(fixture, { fleet: false });
+    const output = outputOf(result);
+
+    expect(result.status, output).toBe(1);
+    expect(output).toContain('[mosaic] SOUL.md not found. Running setup wizard...');
+    expect(output).toContain('What would you like to do?');
+    expect(output).toContain('[mosaic] Setup failed. Run: mosaic wizard');
+    expect(existsSync(fixture.capturePath)).toBe(false);
+    expect(existsSync(join(fixture.mosaicHome, 'SOUL.md'))).toBe(false);
+  });
+
+  it('allows concurrent no-TTY seats to initialize the same defaults without clobber or residue', async () => {
+    const fixture = createGreenfieldFixture();
+    const captures = Array.from({ length: 4 }, (_, index) =>
+      join(fixture.root, `runtime-boundary-${index.toString()}.json`),
+    );
+
+    const results = await Promise.all(
+      captures.map(
+        async (capturePath): Promise<AsyncLaunchResult> => launchAsync(fixture, capturePath),
+      ),
+    );
+
+    for (const result of results) {
+      expect(result.status, outputOf(result)).toBe(0);
+      expect(result.signal, outputOf(result)).toBeNull();
+      expect(outputOf(result)).not.toContain('Running setup wizard');
+    }
+    assertPrivateDefaultSeeds(fixture);
+    expect(captures.every((capturePath) => existsSync(capturePath))).toBe(true);
+    expect(
+      readdirSync(fixture.mosaicHome).filter((entry) => entry.includes('.fleet-seed-')),
+    ).toEqual([]);
+  });
+});
@@ -30,6 +30,10 @@ import { readRegularFileSecure } from '../fleet/secure-file.js';
 import { readPersonaContractBlock } from '../fleet/persona-contract.js';
 import { canonicalizeRoleClass } from './fleet-personas.js';
 import { launchClaudex, type ClaudexHarnessAdapter } from './claudex.js';
+import {
+  readInstalledIdentityContractAtPointOfUse,
+  seedFleetIdentityDefaults,
+} from './fleet-first-start-identity.js';
 import { runLeaseEnforcementDoctorCheck } from './lease-doctor-check.js';

 const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
@@ -230,8 +234,55 @@ function checkRuntime(cmd: string): void {
  }
 }

+function assertAmbientFleetClassMatches(canonicalName: string, canonicalClass: string): void {
+  const configuredClass = process.env['MOSAIC_AGENT_CLASS'];
+  if (configuredClass === undefined) return;
+
+  const ambientClass = canonicalizeRoleClass(configuredClass).canonicalClass;
+  if (ambientClass !== canonicalClass) {
+    throw new Error(
+      `Ambient MOSAIC_AGENT_CLASS resolves to "${ambientClass}" but canonical roster member "${canonicalName}" resolves to "${canonicalClass}". Refusing split identity authority.`,
+    );
+  }
+}
+
 function checkSoul(): void {
  const soulPath = join(MOSAIC_HOME, 'SOUL.md');
+  const fleetAgentName = process.env['MOSAIC_AGENT_NAME'];
+  if (fleetAgentName !== undefined) {
+    try {
+      if (fleetAgentName.length === 0 || fleetAgentName !== fleetAgentName.trim()) {
+        throw new Error(
+          'MOSAIC_AGENT_NAME must be a non-empty exact roster name with no surrounding whitespace',
+        );
+      }
+      const fleetIdentity = resolveFleetIdentity(MOSAIC_HOME, fleetAgentName);
+      if (!fleetIdentity.ok || !fleetIdentity.identity) {
+        throw new Error(
+          `canonical fleet identity is unavailable: ${fleetIdentity.error ?? 'exact roster member was not resolved'}`,
+        );
+      }
+      assertAmbientFleetClassMatches(
+        fleetIdentity.identity.member.name,
+        fleetIdentity.identity.member.className,
+      );
+      const seeded = seedFleetIdentityDefaults(MOSAIC_HOME);
+      if (seeded.length > 0) {
+        console.log(
+          `[mosaic] Initialized unattended fleet identity defaults: ${seeded.join(', ')}. Exact seat identity remains roster-owned.`,
+        );
+      }
+      return;
+    } catch (error: unknown) {
+      const reason = error instanceof Error ? error.message : String(error);
+      console.error(`[mosaic] ERROR: unattended fleet identity initialization failed: ${reason}`);
+      console.error(
+        '[mosaic] Repair the named fleet roster, launch identity, installed contract, or shipped default, then retry.',
+      );
+      process.exit(1);
+    }
+  }
+
  if (!existsSync(soulPath)) {
    console.log('[mosaic] SOUL.md not found. Running setup wizard...');

@@ -532,26 +583,27 @@ For required push/merge/issue-close/release actions, execute without routine con
  parts.push(readFileSync(join(mosaicHome, 'AGENTS.md'), 'utf-8'));

  // USER.md (+ USER.local.md operator overlay, appended directly under the
-  // profile its base owns).
-  const user = readOptional(join(mosaicHome, 'USER.md'));
+  // profile its base owns). Fleet first start is Linux/systemd-owned and uses
+  // the no-follow reader at point of use. Standalone launches retain the
+  // portable tolerant path used on macOS and other supported hosts.
+  const fleetAgentName = process.env['MOSAIC_AGENT_NAME'];
+  const user =
+    fleetAgentName === undefined
+      ? readOptional(join(mosaicHome, 'USER.md'))
+      : readInstalledIdentityContractAtPointOfUse(mosaicHome, 'USER.md').toString('utf8');
  if (user) parts.push('\n\n# User Profile\n\n' + user);
  const userLocal = readOptional(join(mosaicHome, 'USER.local.md'));
  if (userLocal.trim()) {
    parts.push('\n\n## Operator Overlay (USER.local.md)\n\n' + userLocal);
  }

-  const fleetIdentity = resolveFleetIdentity(mosaicHome, process.env['MOSAIC_AGENT_NAME']);
+  const fleetIdentity = resolveFleetIdentity(mosaicHome, fleetAgentName);
  if (!fleetIdentity.ok) {
    throw new Error(`Fleet communications contract unavailable: ${fleetIdentity.error}`);
  }
  const canonicalMember = fleetIdentity.identity?.member;
-  if (canonicalMember && process.env['MOSAIC_AGENT_CLASS']?.trim()) {
-    const ambientClass = canonicalizeRoleClass(process.env['MOSAIC_AGENT_CLASS']).canonicalClass;
-    if (ambientClass !== canonicalMember.className) {
-      throw new Error(
-        `Ambient MOSAIC_AGENT_CLASS resolves to "${ambientClass}" but canonical roster member "${canonicalMember.name}" resolves to "${canonicalMember.className}". Refusing split identity authority.`,
-      );
-    }
+  if (canonicalMember) {
+    assertAmbientFleetClassMatches(canonicalMember.name, canonicalMember.className);
  }

  // TOOLS.md
@@ -205,12 +205,6 @@ export async function runLeaseEnforcementDoctorCheck(
    message:
      `Lease-enforcement hooks (${matchedMarkers.join(', ')}) are wired in ~/.claude/settings.json, but ${reasons.join(' and ')}. ` +
      'Every gated tool call will fail closed and BRICK this agent (see #869). ' +
-      // #1292: one remedy, correct under BOTH enable conventions (by-path on
-      // the seed template, and copy-then-enable in the active dir). Written
-      // from the 2026-08-17 symlink measurement: `systemctl enable` by name
-      // does NOT rewrite an existing by-path wants-symlink, so teaching a
-      // manual systemctl line here could leave a host with two competing
-      // wants links. fleet install reconciles either shape.
-      'Remedy: run `mosaic fleet install` (it reconciles either enable convention), or remove the enforcement hooks from ~/.claude/settings.json.',
+      'Remediate by activating the lease-broker supervisor (systemd unit + socket) or by removing the enforcement hooks from ~/.claude/settings.json.',
  };
 }
@@ -459,7 +459,6 @@ describe('FCM-M3-002 reconciler lifecycle acceptance', (): void => {
      plan: {
        generation: 7,
        holder: 'owned',
-        broker: { unitInstalled: false, socketPresent: false },
        agents: [
          {
            name: 'coder0',
@@ -92,112 +92,6 @@ async function run(command: FleetReconcileCommand, overrides: Partial<FleetRecon
 }

 describe('fleet roster-owned reconciler', (): void => {
-  // ── #1292: broker as first-class plan member + broker-first start ordering ──
-
-  it('reports broker unit and socket state in the plan (socket is the signal, not unit state)', async (): Promise<void> => {
-    const result = await run('status', {
-      statPath: async () => true,
-      checkBrokerSocket: async () => true,
-    });
-    expect(result.plan.broker).toEqual({ unitInstalled: true, socketPresent: true });
-  });
-
-  it('reports a dead broker as socketPresent=false even when the unit is installed (enabled-but-dead is the #1292 shape)', async (): Promise<void> => {
-    const result = await run('status', {
-      statPath: async () => true,
-      checkBrokerSocket: async () => false,
-    });
-    expect(result.plan.broker).toEqual({ unitInstalled: true, socketPresent: false });
-  });
-
-  it('reports broker-absent when neither seam is present (defaults false, never guesses healthy)', async (): Promise<void> => {
-    const result = await run('status');
-    expect(result.plan.broker).toEqual({ unitInstalled: false, socketPresent: false });
-  });
-
-  it('command start enables and starts the broker BEFORE the holder and any agent unit', async (): Promise<void> => {
-    const calls: string[][] = [];
-    const result = await run('start', {
-      runner: async (command, args) => {
-        calls.push([command, ...args]);
-        if (command === 'tmux' && args.includes('list-sessions')) {
-          return { stdout: '_holder\ncoder0\n', stderr: '', exitCode: 0 };
-        }
-        if (command === 'tmux' && args.includes('show-environment')) {
-          return {
-            stdout:
-              'HOME=/home/mosaic\nMOSAIC_FLEET_OWNER=11111111-1111-4111-8111-111111111111\nMOSAIC_TMUX_HOLDER=_holder\nMOSAIC_TMUX_SOCKET=mosaic-fleet\nPATH=/usr/bin:/bin\nPWD=/home/mosaic\n',
-            stderr: '',
-            exitCode: 0,
-          };
-        }
-        return { stdout: '', stderr: '', exitCode: 0 };
-      },
-    });
-    expect(result.lifecycle).toBe('complete');
-    const brokerEnable = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user enable mosaic-lease-broker.service',
-    );
-    const brokerStart = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user start mosaic-lease-broker.service',
-    );
-    const holderStart = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user start mosaic-tmux-holder.service',
-    );
-    const agentStart = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user start [email protected]',
-    );
-    expect(brokerEnable).toBeGreaterThanOrEqual(0);
-    expect(brokerStart).toBeGreaterThan(brokerEnable);
-    // Holder start may be absent (holder 'owned' in this fixture); if present it must follow the broker.
-    if (holderStart >= 0) expect(holderStart).toBeGreaterThan(brokerStart);
-    expect(agentStart).toBeGreaterThan(brokerStart);
-  });
-
-  it('apply with a running desired agent also enables and starts the broker first', async (): Promise<void> => {
-    const calls: string[][] = [];
-    const runningRoster: FleetRosterV2 = {
-      ...roster,
-      agents: roster.agents.map((agent) =>
-        agent.name === 'coder0'
-          ? { ...agent, lifecycle: { enabled: true, desiredState: 'running' as const } }
-          : agent,
-      ),
-    };
-    const result = await executeFleetReconcile({
-      roster: runningRoster,
-      command: 'apply',
-      expectedGeneration: 7,
-      deps: deps({
-        readRoster: async () => runningRoster,
-        runner: async (command, args) => {
-          calls.push([command, ...args]);
-          if (command === 'tmux' && args.includes('list-sessions')) {
-            return { stdout: '_holder\n', stderr: '', exitCode: 0 };
-          }
-          if (command === 'tmux' && args.includes('show-environment')) {
-            return {
-              stdout:
-                'HOME=/home/mosaic\nMOSAIC_FLEET_OWNER=11111111-1111-4111-8111-111111111111\nMOSAIC_TMUX_HOLDER=_holder\nMOSAIC_TMUX_SOCKET=mosaic-fleet\nPATH=/usr/bin:/bin\nPWD=/home/mosaic\n',
-              stderr: '',
-              exitCode: 0,
-            };
-          }
-          return { stdout: '', stderr: '', exitCode: 0 };
-        },
-      }),
-    });
-    expect(result.applied).toBe(true);
-    const brokerStart = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user start mosaic-lease-broker.service',
-    );
-    const agentStart = calls.findIndex(
-      (c) => c.join(' ') === 'systemctl --user start [email protected]',
-    );
-    expect(brokerStart).toBeGreaterThanOrEqual(0);
-    expect(agentStart).toBeGreaterThan(brokerStart);
-  });
-
  it('fails closed on a symlinked fleet ancestor without touching its target', async (): Promise<void> => {
    const home = await lockHome();
    const fleet = join(home, 'fleet');
@@ -43,10 +43,6 @@ export interface FleetReconcileDeps {
  readonly overrideDir?: string;
  readonly homeDirectory?: string;
  readonly readHolderIdentity?: () => Promise<string>;
-  /** Test/observation seams for the lease-broker plan member (#1292). */
-  readonly statPath?: (path: string) => Promise<boolean> | boolean;
-  readonly checkBrokerSocket?: (path: string) => Promise<boolean> | boolean;
-  readonly brokerSocketEnv?: NodeJS.ProcessEnv;
  readonly validateRoster?: (roster: FleetRosterV2) => Promise<void>;
  readonly prepareProjections?: (roster: FleetRosterV2) => Promise<readonly unknown[]>;
  readonly applyProjection?: (prepared: unknown) => Promise<unknown>;
@@ -78,17 +74,6 @@ export interface FleetReconcileObservedAgent {
 export interface FleetReconcilePlan {
  readonly generation: number;
  readonly holder: 'owned' | 'missing' | 'ownership-mismatch';
-  /**
-   * Lease broker observation (#1292): every gated runtime registers with the
-   * broker or dies ~4s in — a broker not in the plan cannot be reported as
-   * drifted, which made "broker died an hour ago" and "broker fine"
-   * produce identical output. `unitInstalled` = unit file present in the
-   * active dir; `socketPresent` = live broker at the resolved socket path.
-   */
-  readonly broker: {
-    readonly unitInstalled: boolean;
-    readonly socketPresent: boolean;
-  };
  readonly agents: readonly FleetReconcileObservedAgent[];
  readonly unmanagedSessions: readonly string[];
 }
@@ -329,39 +314,6 @@ function isObservational(command: FleetReconcileCommand): boolean {
  return command === 'plan' || command === 'status' || command === 'verify' || command === 'doctor';
 }

-/**
- * Observe the lease broker for the plan (#1292). Unit presence via systemctl
- * is-system-running is NOT the signal — a unit can be enabled-but-dead. The
- * authoritative signal is the socket the gated runtimes connect to, matching
- * broker-supervisor.ts's `checkBrokerSupervisorHealth` (healthy ===
- * socketPresent). Injectable so tests drive every branch without a broker.
- */
-async function observeBroker(deps: FleetReconcileDeps): Promise<FleetReconcilePlan['broker']> {
-  const homeDirectory = deps.homeDirectory ?? homedir();
-  const env = (deps.brokerSocketEnv ?? process.env) as NodeJS.ProcessEnv;
-  const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
-  const runtimeDir = env['XDG_RUNTIME_DIR'] ?? `/run/user/${uid}`;
-  const socketPath =
-    env['MOSAIC_LEASE_BROKER_SOCKET'] ?? join(runtimeDir, 'mosaic-lease', 'broker.sock');
-  const configHome = env['XDG_CONFIG_HOME'] ?? join(homeDirectory, '.config');
-  const unitPath = join(configHome, 'systemd', 'user', 'mosaic-lease-broker.service');
-  const statPath = deps.statPath;
-  const checkBrokerSocket = deps.checkBrokerSocket;
-  let unitInstalled = false;
-  let socketPresent = false;
-  try {
-    unitInstalled = statPath ? await statPath(unitPath) : false;
-  } catch {
-    unitInstalled = false;
-  }
-  try {
-    socketPresent = checkBrokerSocket ? await checkBrokerSocket(socketPath) : false;
-  } catch {
-    socketPresent = false;
-  }
-  return { unitInstalled, socketPresent };
-}
-
 async function observeFleet(
  roster: FleetRosterV2,
  deps: FleetReconcileDeps,
@@ -372,12 +324,10 @@ async function observeFleet(
    '-F',
    '#{session_name}',
  ]);
-  const broker = await observeBroker(deps);
  if (sessionsResult.exitCode !== 0) {
    return {
      generation: roster.generation,
      holder: 'missing',
-      broker,
      agents: await observeAgents(roster, deps, new Set<string>()),
      unmanagedSessions: [],
    };
@@ -400,7 +350,6 @@ async function observeFleet(
  return {
    generation: roster.generation,
    holder,
-    broker,
    agents: await observeAgents(roster, deps, sessions),
    unmanagedSessions: Object.freeze(unmanagedSessions.sort()),
  };
@@ -568,24 +517,6 @@ async function executeExplicitLifecycle(
    }
  }
  try {
-    // Broker FIRST (#1292): a gated runtime started without a running lease
-    // broker dies ~4 seconds in at registration — enable the unit (install
-    // places it) and start it before any holder/agent lifecycle effect. The
-    // socket re-check after start is the same probe observeBroker uses, so a
-    // unit that starts but never produces a socket is caught here, not four
-    // seconds later inside a doomed seat.
-    if (request.command === 'start') {
-      await runChecked(request.deps, 'systemctl', [
-        '--user',
-        'enable',
-        'mosaic-lease-broker.service',
-      ]);
-      await runChecked(request.deps, 'systemctl', [
-        '--user',
-        'start',
-        'mosaic-lease-broker.service',
-      ]);
-    }
    if (request.command === 'start' && plan.holder === 'missing') {
      await runChecked(request.deps, 'systemctl', [
        '--user',
@@ -631,12 +562,6 @@ async function applyDesiredLifecycle(
    (agent: FleetRosterV2Agent): boolean =>
      agent.lifecycle.enabled && agent.lifecycle.desiredState === 'running',
  );
-  // Broker before any running agent, same ordering and reason as the
-  // command-driven path above (#1292).
-  if (needsRunningAgent) {
-    await runChecked(deps, 'systemctl', ['--user', 'enable', 'mosaic-lease-broker.service']);
-    await runChecked(deps, 'systemctl', ['--user', 'start', 'mosaic-lease-broker.service']);
-  }
  if (needsRunningAgent && plan.holder === 'missing') {
    await runChecked(deps, 'systemctl', ['--user', 'start', 'mosaic-tmux-holder.service']);
  }
Author	SHA1	Message	Date
goals	3af594590a	fix(#1264 ): preserve portable standalone launch ci/woodpecker/pr/ci Pipeline failed Details	2026-08-16 19:01:26 -05:00
goals	9dc90be7e1	fix(#1264 ): harden unattended identity bootstrap ci/woodpecker/pr/ci Pipeline failed Details	2026-08-16 18:33:39 -05:00
goals	43fa047787	fix(#1264 ): bootstrap fleet identity without a TTY ci/woodpecker/pr/ci Pipeline failed Details	2026-08-16 17:37:32 -05:00