chore: re-trigger CI (push/ci infra flake on prior SHA)

generateAgentEnv now emits MOSAIC_AGENT_CLASS (shell-escaped, right after
MOSAIC_AGENT_NAME) so a launching agent knows its class and the companion
A3b goal can inject the matching persona contract. Defaults to `worker`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

docs/fleet/north-star.md

@@ -353,25 +353,6 @@ re-evaluate if isolation or write-volume demands it.
 - **Docs as projections:** `docs/TASKS.md` and `MISSION-MANIFEST.md` become generated exports of the DB, not hand-maintained.
 - **Sub-decision pending:** dedicated schema in existing PG instance (recommended) vs. dedicated PG instance. Revisit if isolation or write-volume demands it.
 
-## Decisions of record (2026-06-24, with Jason)
-
-- **Per-agent model switch (operator-configurable, NOT a global lock):** model selection is
-  **per-agent**, never a host-global pin. Claude sessions MUST NOT be locked to a single model in
-  `~/.claude/settings.json`; each agent chooses its model independently. The plumbing already exists —
-  roster `model_hint` → `MOSAIC_AGENT_MODEL` → `start-agent-session.sh` appends `--model <hint>` to that
-  agent's harness (claude or pi); settable today via `mosaic fleet add|edit <agent> --model <hint>`.
-  **North-star target:** surface this as a **per-agent model switch in the webUI** (with CLI/TUI parity
-  per MVP-X1) — read the roster, expose a per-agent model dropdown, write `model_hint` back, and restart
-  that one agent to apply. Unset = inherit the harness default. This **composes with** the budget
-  downgrade ladder (opus → sonnet → haiku, then Claude → Codex): the operator sets the per-agent model
-  _intent/ceiling_; budget pacing may downgrade within policy. Tracked as a Fleet `TASKS.md` entry under
-  the Phase-5 webUI surface.
-- **Orchestrator runtime (confirmed live):** the **orchestrator and enhancer run Claude Opus 4.8 in the
-  Claude Code harness**; only workers (coder/reviewer) run pi/gpt-5.5. Consistent with the 2026-06-20
-  "Claude reserved for Claude Code only" decision (the orchestrator runs _in_ Claude Code, not an
-  alternate Claude harness). Pi/gpt-5.5 as the orchestrator is permitted **only if proven** at least as
-  satisfactory; absent that proof, the orchestrator stays on Claude Opus 4.8.
-
 ## Future enhancements (north-star, post-MVP — not on the MVP track)
 
 - **Mosaic Claude Discord Plugin** — a first-party Mosaic Discord connector that properly

packages/db/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaicstack/db",
-  "version": "0.0.4",
+  "version": "0.0.3",
   "repository": {
     "type": "git",
     "url": "https://git.mosaicstack.dev/mosaicstack/stack.git",

packages/mosaic/framework/tools/fleet/start-agent-session.sh

@@ -114,21 +114,10 @@ MOSAIC_RUNTIME_BIN_PREFIX=$(_build_runtime_bin_prefix)
 # safe single bash token regardless of the name's characters.
 AGENT_NAME_Q=$(printf '%q' "$AGENT_NAME")
 
-# MOSAIC_AGENT_CLASS must ALSO be exported INTO the pane, for the same reason as
-# MOSAIC_AGENT_NAME above: the pane inherits the tmux SERVER environment (not this
-# script's env, and not the systemd unit's EnvironmentFile), so the per-agent class
-# written to agents/<name>.env would otherwise be invisible in-pane. The launcher
-# composes the persona contract from process.env.MOSAIC_AGENT_CLASS at launch
-# (compose-contract -> readPersonaContractBlock); without this export it sees an
-# undefined class and silently injects NO persona contract. %q-quote it so it is a
-# safe single bash token; an empty/unset class %q-quotes to '' and is a harmless
-# no-op downstream (readPersonaContractBlock returns '' for an empty class).
-AGENT_CLASS_Q=$(printf '%q' "${MOSAIC_AGENT_CLASS:-}")
-
 if [ -n "$MOSAIC_RUNTIME_BIN_PREFIX" ]; then
-  PANE_SHELL_SNIPPET="export MOSAIC_AGENT_NAME=${AGENT_NAME_Q}; export MOSAIC_AGENT_CLASS=${AGENT_CLASS_Q}; export PATH=\"${MOSAIC_RUNTIME_BIN_PREFIX}:\${PATH}\"; exec ${MOSAIC_AGENT_COMMAND}"
+  PANE_SHELL_SNIPPET="export MOSAIC_AGENT_NAME=${AGENT_NAME_Q}; export PATH=\"${MOSAIC_RUNTIME_BIN_PREFIX}:\${PATH}\"; exec ${MOSAIC_AGENT_COMMAND}"
 else
-  PANE_SHELL_SNIPPET="export MOSAIC_AGENT_NAME=${AGENT_NAME_Q}; export MOSAIC_AGENT_CLASS=${AGENT_CLASS_Q}; exec ${MOSAIC_AGENT_COMMAND}"
+  PANE_SHELL_SNIPPET="export MOSAIC_AGENT_NAME=${AGENT_NAME_Q}; exec ${MOSAIC_AGENT_COMMAND}"
 fi
 
 mkdir -p "$MOSAIC_AGENT_WORKDIR"

packages/mosaic/framework/tools/fleet/test-start-agent-session.sh

@@ -104,7 +104,6 @@ PATH="$FAKE_BIN:$PATH" \
 MOSAIC_TMUX_SOCKET="$SOCKET3" \
 MOSAIC_AGENT_WORKDIR="$WORKDIR3" \
 MOSAIC_AGENT_RUNTIME="pi" \
-MOSAIC_AGENT_CLASS="code" \
 MOSAIC_RUNTIME_BIN="$FAKE_RUNTIME_BIN" \
 MOSAIC_AGENT_COMMAND="mosaic yolo pi --model openai-codex/gpt-5.5:high" \
 MOSAIC_HEARTBEAT_RUN_DIR="$HB_RUN_DIR3" \
@@ -128,18 +127,6 @@ echo "$all_args" | grep -qF "exec " || fail "pane command does not use exec"
 echo "$all_args" | grep -qF "mosaic yolo pi --model openai-codex/gpt-5.5:high" || \
   fail "pane command does not forward MOSAIC_AGENT_COMMAND with flags intact"
 
-# d) MOSAIC_AGENT_NAME and the per-agent MOSAIC_AGENT_CLASS must BOTH be exported
-#    INTO the pane. The pane inherits the tmux SERVER environment (not this
-#    script's env, nor the systemd unit's EnvironmentFile), so any per-agent var
-#    the launcher needs in-pane must be re-exported in the snippet. CLASS is
-#    load-bearing: the launcher composes the persona contract from
-#    process.env.MOSAIC_AGENT_CLASS, so a missing export silently drops the
-#    persona (regression guard for the A3a pane-propagation gap).
-echo "$all_args" | grep -qF "export MOSAIC_AGENT_NAME=" || \
-  fail "pane command does not export MOSAIC_AGENT_NAME into the pane"
-echo "$all_args" | grep -qF "export MOSAIC_AGENT_CLASS=code" || \
-  fail "pane command does not export MOSAIC_AGENT_CLASS into the pane (persona would silently drop)"
-
 # ── Test 4: when no extra runtime-bin dirs exist, exec still appears ───────────
 TMUX_ARGS_FILE2=$(mktemp)
 FAKE_BIN2=$(mktemp -d)

packages/mosaic/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosaicstack/mosaic",
-  "version": "0.0.47",
+  "version": "0.0.45",
   "repository": {
     "type": "git",
     "url": "https://git.mosaicstack.dev/mosaicstack/stack.git",

packages/mosaic/src/commands/compose-contract.spec.ts

@@ -164,89 +164,4 @@ describe('composeContract — overlay composer', () => {
     expect(composeContract('pi', fixture.home)).toContain('# pi runtime contract');
     expect(composeContract('codex', fixture.home)).not.toContain('# pi runtime contract');
   });
-
-  // ── Persona contract injection (A3b) ──────────────────────────────────────
-  // composeContract reads MOSAIC_AGENT_CLASS and injects the resolved persona
-  // (override-aware). Save/restore the env so these tests don't leak state.
-  describe('persona contract (A3b)', () => {
-    let prevClass: string | undefined;
-
-    beforeEach(() => {
-      prevClass = process.env['MOSAIC_AGENT_CLASS'];
-    });
-
-    afterEach(() => {
-      if (prevClass === undefined) delete process.env['MOSAIC_AGENT_CLASS'];
-      else process.env['MOSAIC_AGENT_CLASS'] = prevClass;
-    });
-
-    const seedBaseline = (klass: string, body: string): void => {
-      mkdirSync(join(fixture.home, 'fleet', 'roles'), { recursive: true });
-      writeFileSync(join(fixture.home, 'fleet', 'roles', `${klass}.md`), body);
-    };
-    const seedOverride = (klass: string, body: string): void => {
-      mkdirSync(join(fixture.home, 'fleet', 'roles.local'), { recursive: true });
-      writeFileSync(join(fixture.home, 'fleet', 'roles.local', `${klass}.md`), body);
-    };
-
-    it('injects the baseline persona when MOSAIC_AGENT_CLASS is set and a role file exists', () => {
-      seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE: ship the lane.\n');
-      process.env['MOSAIC_AGENT_CLASS'] = 'coder';
-      const out = composeContract('claude', fixture.home);
-      expect(out).toContain('# Persona Contract (coder)');
-      expect(out).toContain('BASELINE-MANDATE');
-    });
-
-    it('OVERRIDE WINS at launch: roles.local persona is injected over baseline (AC-NS-7)', () => {
-      seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
-      seedOverride('coder', '# Coder (override)\n\n(`class: coder`)\n\nOVERRIDE-MANDATE.\n');
-      process.env['MOSAIC_AGENT_CLASS'] = 'coder';
-      const out = composeContract('claude', fixture.home);
-      expect(out).toContain('# Persona Contract (coder)');
-      expect(out).toContain('OVERRIDE-MANDATE');
-      expect(out).not.toContain('BASELINE-MANDATE');
-    });
-
-    it('does NOT inject a persona when MOSAIC_AGENT_CLASS is unset', () => {
-      seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
-      delete process.env['MOSAIC_AGENT_CLASS'];
-      const out = composeContract('claude', fixture.home);
-      expect(out).not.toContain('# Persona Contract');
-    });
-
-    it('does NOT inject (no throw) when MOSAIC_AGENT_CLASS names an unknown class', () => {
-      seedBaseline('coder', '# Coder\n\n(`class: coder`)\n\nBASELINE-MANDATE.\n');
-      process.env['MOSAIC_AGENT_CLASS'] = 'nonexistent';
-      expect(() => composeContract('claude', fixture.home)).not.toThrow();
-      expect(composeContract('claude', fixture.home)).not.toContain('# Persona Contract');
-    });
-
-    it('places the persona contract BEFORE the fleet comms block (identity, then peers)', () => {
-      seedBaseline('enhancer', '# Enhancer\n\n(`class: enhancer`)\n\nIMPROVE.\n');
-      mkdirSync(join(fixture.home, 'fleet'), { recursive: true });
-      writeFileSync(
-        join(fixture.home, 'fleet', 'roster.yaml'),
-        [
-          'agents:',
-          '  - name: orchestrator',
-          '    class: orchestrator',
-          '  - name: enhancer',
-          '    class: enhancer',
-          '',
-        ].join('\n'),
-      );
-      const prevName = process.env['MOSAIC_AGENT_NAME'];
-      try {
-        process.env['MOSAIC_AGENT_CLASS'] = 'enhancer';
-        process.env['MOSAIC_AGENT_NAME'] = 'enhancer';
-        const out = composeContract('claude', fixture.home);
-        expect(out).toContain('# Persona Contract (enhancer)');
-        expect(out).toContain('# Fleet Comms');
-        expect(out.indexOf('# Persona Contract')).toBeLessThan(out.indexOf('# Fleet Comms'));
-      } finally {
-        if (prevName === undefined) delete process.env['MOSAIC_AGENT_NAME'];
-        else process.env['MOSAIC_AGENT_NAME'] = prevName;
-      }
-    });
-  });
 });

packages/mosaic/src/commands/fleet-personas.ts

@@ -25,7 +25,6 @@
  * can reference a customized or user-added persona.
  */
 
-import { readFileSync, readdirSync } from 'node:fs';
 import { readFile, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
@@ -89,12 +88,13 @@ export interface DirClasses {
  * classes still appear in `classes` for membership checks.
  */
 export async function extractClassesFromDir(dir: string): Promise<DirClasses> {
-  const acc: DirClasses = { classes: new Set<string>(), byClass: new Map<string, PersonaFile>() };
+  const classes = new Set<string>();
+  const byClass = new Map<string, PersonaFile>();
   let entries: string[];
   try {
     entries = await readdir(dir);
   } catch {
-    return acc;
+    return { classes, byClass };
   }
 
   for (const entry of entries) {
@@ -105,53 +105,12 @@ export async function extractClassesFromDir(dir: string): Promise<DirClasses> {
     } catch {
       continue;
     }
-    accumulateEntry(acc, dir, entry, text);
-  }
-  return acc;
-}
-
-/**
- * Synchronous twin of {@link extractClassesFromDir}. Identical extraction
- * semantics (same markers, same union of marker/filename/LIBRARY sources) on
- * sync fs, for the synchronous launch-time prompt path (composeContract) which
- * cannot await. Missing dir / unreadable files degrade gracefully.
- */
-export function extractClassesFromDirSync(dir: string): DirClasses {
-  const acc: DirClasses = { classes: new Set<string>(), byClass: new Map<string, PersonaFile>() };
-  let entries: string[];
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return acc;
-  }
-
-  for (const entry of entries) {
-    if (!entry.endsWith('.md')) continue;
-    let text: string;
-    try {
-      text = readFileSync(join(dir, entry), 'utf8');
-    } catch {
-      continue;
-    }
-    accumulateEntry(acc, dir, entry, text);
-  }
-  return acc;
-}
-
-/**
- * Apply the class-extraction rules for ONE role file's text into `acc`. Pure
- * over already-read content, so the async and sync directory scanners share a
- * single definition of "what classes a file contributes" (DRY — no semantic
- * drift between the launch-time and command-time paths).
- */
-function accumulateEntry(acc: DirClasses, dir: string, entry: string, text: string): void {
-  const { classes, byClass } = acc;
     if (entry === 'LIBRARY.md') {
       for (const m of text.matchAll(LIBRARY_ROW)) {
         const name = m[1];
         if (name && name !== 'persona') classes.add(name);
       }
-    return;
+      continue;
     }
     // The filename stem is itself a valid class (covers marker-less alias docs).
     const stem = basename(entry, '.md');
@@ -175,6 +134,8 @@ function accumulateEntry(acc: DirClasses, dir: string, entry: string, text: stri
       byClass.set(stem, { klass: stem, file: join(dir, entry) });
     }
   }
+  return { classes, byClass };
+}
 
 export interface PersonaDirs {
   /** Baseline roles dir. Defaults to <mosaicHome>/fleet/roles. */
@@ -268,51 +229,6 @@ export async function resolvePersona(
   );
 }
 
-/**
- * Synchronous twin of {@link resolvePersona} — same override-wins precedence
- * (roles.local/ beats roles/, by marker first then filename stem), returning
- * null if neither layer defines the class. Exists for the synchronous launch
- * prompt path (composeContract → readPersonaContractBlock) which cannot await.
- * Keeping it here, beside the async resolver, keeps the resolution semantics in
- * one module so the launch-time and command-time resolutions never diverge.
- */
-export function resolvePersonaSync(
-  klass: string,
-  opts: PersonaDirs = {},
-): PersonaResolution | null {
-  const { rolesDir, overrideDir } = resolveDirs(opts);
-  const base = extractClassesFromDirSync(rolesDir);
-  const over = extractClassesFromDirSync(overrideDir);
-
-  const fromLayer = (
-    dir: string,
-    extracted: DirClasses,
-    layer: PersonaLayer,
-  ): PersonaResolution | null => {
-    // Prefer the marker-defined file; fall back to the filename stem.
-    const pf = extracted.byClass.get(klass);
-    if (!pf) {
-      if (!extracted.classes.has(klass)) return null;
-      const byName = join(dir, `${klass}.md`);
-      try {
-        const content = readFileSync(byName, 'utf8');
-        const dm = DOMAIN_MARKER.exec(content);
-        return { klass, layer, file: byName, content, ...(dm?.[1] ? { domain: dm[1] } : {}) };
-      } catch {
-        return null;
-      }
-    }
-    try {
-      const content = readFileSync(pf.file, 'utf8');
-      return { klass, layer, file: pf.file, content, ...(pf.domain ? { domain: pf.domain } : {}) };
-    } catch {
-      return null;
-    }
-  };
-
-  return fromLayer(overrideDir, over, 'override') ?? fromLayer(rolesDir, base, 'baseline');
-}
-
 export interface PersonaStatusEntry {
   klass: string;
   status: PersonaStatus;

packages/mosaic/src/commands/launch.ts

@@ -20,7 +20,6 @@ import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import type { Command } from 'commander';
 import { readFleetCommsBlock } from '../fleet/comms-onboarding.js';
-import { readPersonaContractBlock } from '../fleet/persona-contract.js';
 
 const MOSAIC_HOME = process.env['MOSAIC_HOME'] ?? join(homedir(), '.config', 'mosaic');
 
@@ -385,16 +384,6 @@ For required push/merge/issue-close/release actions, execute without routine con
   // Runtime-specific contract
   parts.push('\n\n# Runtime-Specific Contract\n\n' + readFileSync(runtimeFile, 'utf-8'));
 
-  // Persona contract (A3b): when this agent was spawned with a class
-  // (MOSAIC_AGENT_CLASS, exported into the pane env by A3a), inject its resolved
-  // role contract so its identity (mandate + boundaries) is resident from the
-  // first turn. Override-aware via the persona resolver: a user-customized
-  // persona in fleet/roles.local/ wins over the baseline (AC-NS-7 launch proof).
-  // Placed BEFORE fleet comms: identity first, then how-to-reach-peers. No-ops
-  // silently when the class is unset/unknown (mirrors the comms block).
-  const persona = readPersonaContractBlock(mosaicHome, process.env['MOSAIC_AGENT_CLASS']);
-  if (persona) parts.push('\n\n' + persona);
-
   // Fleet onboarding: when this is a spawned fleet agent (MOSAIC_AGENT_NAME set
   // and present in the roster), inject a comms cheat-sheet + peer roster so it
   // knows how to reach the orchestrator and its peers from its first turn.

packages/mosaic/src/fleet/persona-contract.spec.ts

@@ -1,106 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readPersonaContractBlock } from './persona-contract.js';
-
-/**
- * Persona-contract launch injection (A3b). Asserts the override-aware resolver
- * is wired so a customized persona in roles.local/ wins at launch (AC-NS-7), and
- * that any miss (unset/empty/unknown class, missing file) no-ops silently —
- * never throws — mirroring readFleetCommsBlock's tolerant contract.
- */
-
-const BASELINE_CODER = `# Coder — fleet role definition
-
-The **coder** persona (\`class: coder\`, \`domain: engineering\`).
-
-## Mandate
-
-BASELINE-MANDATE: implement the assigned lane.
-`;
-
-const OVERRIDE_CODER = `# Coder — fleet role definition (override)
-
-The **coder** persona (\`class: coder\`).
-
-## Mandate
-
-OVERRIDE-MANDATE: implement the assigned lane, the user's way.
-`;
-
-function makeHome(): string {
-  const root = mkdtempSync(join(tmpdir(), 'mosaic-persona-'));
-  return join(root, 'mosaic-home');
-}
-
-function seedBaseline(home: string, klass: string, body: string): void {
-  const dir = join(home, 'fleet', 'roles');
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${klass}.md`), body);
-}
-
-function seedOverride(home: string, klass: string, body: string): void {
-  const dir = join(home, 'fleet', 'roles.local');
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${klass}.md`), body);
-}
-
-describe('readPersonaContractBlock — launch-time persona injection (A3b)', () => {
-  let home: string;
-
-  beforeEach(() => {
-    home = makeHome();
-  });
-
-  afterEach(() => {
-    // root is the parent of mosaic-home
-    rmSync(join(home, '..'), { recursive: true, force: true });
-  });
-
-  it('injects the baseline persona when the class has a fleet/roles/<class>.md', () => {
-    seedBaseline(home, 'coder', BASELINE_CODER);
-    const block = readPersonaContractBlock(home, 'coder');
-    expect(block).toContain('# Persona Contract (coder)');
-    expect(block).toContain('BASELINE-MANDATE');
-    expect(block).toContain('baseline `fleet/roles/` layer');
-  });
-
-  it('OVERRIDE WINS: roles.local/<class>.md content is injected over the baseline (AC-NS-7)', () => {
-    seedBaseline(home, 'coder', BASELINE_CODER);
-    seedOverride(home, 'coder', OVERRIDE_CODER);
-    const block = readPersonaContractBlock(home, 'coder');
-    expect(block).toContain('# Persona Contract (coder)');
-    expect(block).toContain('OVERRIDE-MANDATE'); // override body present
-    expect(block).not.toContain('BASELINE-MANDATE'); // baseline NOT used
-    expect(block).toContain('roles.local'); // layer note names the override layer
-  });
-
-  it('injects an override-only (user-added) persona with no baseline at all', () => {
-    seedOverride(home, 'reviewer', '# Reviewer\n\n(`class: reviewer`)\n\nCUSTOM-ROLE.\n');
-    const block = readPersonaContractBlock(home, 'reviewer');
-    expect(block).toContain('# Persona Contract (reviewer)');
-    expect(block).toContain('CUSTOM-ROLE');
-  });
-
-  it('no-ops (empty string) when the class is undefined', () => {
-    seedBaseline(home, 'coder', BASELINE_CODER);
-    expect(readPersonaContractBlock(home, undefined)).toBe('');
-  });
-
-  it('no-ops (empty string) when the class is empty/whitespace', () => {
-    seedBaseline(home, 'coder', BASELINE_CODER);
-    expect(readPersonaContractBlock(home, '')).toBe('');
-    expect(readPersonaContractBlock(home, '   ')).toBe('');
-  });
-
-  it('no-ops (empty string) for an unknown class with no role file', () => {
-    seedBaseline(home, 'coder', BASELINE_CODER);
-    expect(readPersonaContractBlock(home, 'nonexistent')).toBe('');
-  });
-
-  it('no-ops (empty string, no throw) when no roles directories exist at all', () => {
-    expect(() => readPersonaContractBlock(home, 'coder')).not.toThrow();
-    expect(readPersonaContractBlock(home, 'coder')).toBe('');
-  });
-});

packages/mosaic/src/fleet/persona-contract.ts

@@ -1,63 +0,0 @@
-/**
- * Persona-contract injection at launch (North Star A3b).
- *
- * A spawned fleet agent should boot already knowing WHO it is: its class's role
- * contract (mandate + boundaries). The companion goal A3a exports the agent's
- * resolved class into the pane env as `MOSAIC_AGENT_CLASS`; here we read that
- * class at launch (composeContract → system prompt) and inject the resolved
- * persona contract so the identity is resident from the agent's first turn.
- *
- * OVERRIDE-AWARE: resolution goes through fleet-personas' resolver, so a
- * user-customized persona in the PRESERVE-protected `fleet/roles.local/` layer
- * WINS over the baseline `fleet/roles/` of the same class. That is the
- * launch-time proof of AC-NS-7 — a customized persona actually reaches the model
- * when the agent boots, not just in `mosaic fleet persona show`.
- *
- * Tolerant by contract (mirrors readFleetCommsBlock): an empty/missing class, an
- * unknown class, or a missing role file all yield '' so the launcher no-ops
- * silently. This MUST never throw during launch.
- *
- * Standalone module (no fleet.ts import) to keep launch.ts's prompt path free of
- * the heavy fleet command module; it depends only on the lightweight persona
- * resolver.
- */
-
-import {
-  resolvePersonaSync,
-  defaultRolesDir,
-  defaultOverrideDir,
-} from '../commands/fleet-personas.js';
-
-/**
- * Resolve `klass`'s persona contract (override-aware) and render it as a
- * clearly-delimited launch block. Returns '' on any miss (falsy class, unknown
- * class, missing/unreadable file) so composeContract can push it unconditionally
- * and have it no-op silently. Never throws.
- */
-export function readPersonaContractBlock(mosaicHome: string, klass: string | undefined): string {
-  if (!klass || !klass.trim()) return '';
-  let resolved: ReturnType<typeof resolvePersonaSync>;
-  try {
-    resolved = resolvePersonaSync(klass.trim(), {
-      rolesDir: defaultRolesDir(mosaicHome),
-      overrideDir: defaultOverrideDir(mosaicHome),
-    });
-  } catch {
-    // Best-effort onboarding: a resolver hiccup must not abort the launch.
-    return '';
-  }
-  if (!resolved) return '';
-
-  const layerNote =
-    resolved.layer === 'override'
-      ? '_(resolved from the `fleet/roles.local/` override layer — wins over baseline)_'
-      : '_(resolved from the baseline `fleet/roles/` layer)_';
-
-  return `# Persona Contract (${resolved.klass})
-
-${layerNote}
-
-You are operating as the **${resolved.klass}** persona. The role contract below is your identity — its mandate and boundaries govern what you own and what you must not do for this assignment.
-
-${resolved.content.trim()}`;
-}