fix(git): review follow-ups for #1357 (S1, S2, indent)

S1: get_gitea_login_for_repo_override() now distinguishes "tea is not
installed" from "no tea login named X exists", mirroring the host path.
The old message diagnosed a cause that was never checked and pointed at
seat-logins.sh, which cannot run without tea. Branch 6 in
test-gitea-login-resolution.sh pins it (tea removed from PATH); reverting
the fix fails that branch.

S2: issue-list/pr-list/pr-view override-path error now points at the
lines above for the cause instead of suggesting a default tea login.

verify-release.mjs: indent of the #1356 test line fixed (cosmetic).

.mosaic/repo.json

@@ -1,11 +1,4 @@
 {
-  "schema_version": 2,
   "integration_trunk": "next",
-  "release_branch": "main",
+  "release_branch": "main"
-  "flow": "trunk-release",
-  "canonical_remote": "https://git.mosaicstack.dev/mosaicstack/stack",
-  "canonical_clone": "host:/src/mosaic-stack",
-  "worktree_root": "host:/src/mosaic-stack-worktrees",
-  "worktree_policy": "orchestrator-precreated",
-  "notes": "next=development/integration; main=production release. Never branch work off main. worktree_policy is TRANSITIONAL: the wrapper worktree consumer is BLOCKED on the J3/#1174 amendment (checked roots + capacity guard); pre-creation is the interim orchestration choice, not closed policy — it becomes a timing choice only after the wrapper can validate this root."
 }

.woodpecker/ci.yml

@@ -113,40 +113,6 @@ steps:
       # stub supplies the scale instead of the host's own checkout.
       - bash packages/mosaic/framework/tools/git/test-mosaic-worktree-large-repo.sh
 
-  # Canonical repo-structure declaration gate (T51 WP5c, spec §5.4 point 2):
-  # .mosaic/repo.json is the machine-readable structure SSOT consumed by git
-  # wrappers and the T32 gate seat; this is its repo-side CI enforcement.
-  # Path-conditional: runs when the declaration, the vendored validator, or this
-  # pipeline config changes (manual runs always include it). Fails the pipeline
-  # on any VALIDATION_ERROR and enforces the schema_version 2 authoring rule
-  # (--require-v2: edited/new declarations may not stay v1). The validator is
-  # vendored into the framework tree (spec §5.1 final home) — provenance in its
-  # header; the hostile-input suite (101 arms, hermetic) runs alongside so the
-  # gate's own instrument ships in the same commit as the gate.
-  structure-declaration:
-    image: *node_image
-    commands:
-      - apk add --no-cache bash git
-      # MOSAIC_HOST_ROOT is a runtime anchor (spec §1.2a: unset fails closed
-      # for managed validation). CI has no host, so the step provisions an
-      # EXPLICIT fixture root — honest configuration for the resolution path,
-      # never a guess about a real host; the per-host containment checks are
-      # runtime concerns and do not run against a fixture. Grammar, schema,
-      # refs, flow, remote normalization, and path grammar all prove here.
-      - mkdir -p /tmp/t51-ci-hostroot
-      - bash packages/mosaic/framework/tools/structure/validate-repo-json.sh .mosaic/repo.json --require-v2
-      - bash packages/mosaic/framework/tools/structure/test-validate-repo-json.sh
-    environment:
-      MOSAIC_HOST_ROOT: /tmp/t51-ci-hostroot
-    when:
-      - event: pull_request
-        path:
-          include:
-            - '.mosaic/repo.json'
-            - 'packages/mosaic/framework/tools/structure/**'
-            - '.woodpecker/ci.yml'
-      - event: manual
-
   # Canonical verify:release stage `upgrade-guard`.
   # Blocking gate (#791): a framework upgrade must never write or delete an
   # operator-owned path. The HARD GATE proves an unanticipated operator sentinel

.woodpecker/publish.yml

@@ -202,20 +202,6 @@ steps:
         echo "@mosaicstack:registry=https://git.mosaicstack.dev/api/packages/mosaicstack/npm/" >> ~/.npmrc
         DIST_TAGS_JSON="$(npm view @mosaicstack/mosaic dist-tags --registry https://git.mosaicstack.dev/api/packages/mosaicstack/npm/ --json)"
         DIST_TAGS_JSON="$DIST_TAGS_JSON" node -e 'const tags = JSON.parse(process.env.DIST_TAGS_JSON || "{}"); if (!tags || typeof tags !== "object" || !Object.hasOwn(tags, "latest")) { throw new Error("Gitea npm registry did not return a usable dist-tags object"); } console.log("[publish-next] registry dist-tags OK: latest=" + tags.latest);'
-        # #1404: snapshot every publishable manifest BEFORE the transform so the
-        # workspace can be restored byte-exact after publish. The transform
-        # rewrites package.json in place (needed: pnpm publish reads the
-        # workspace manifests); without restore, later steps in this pipeline
-        # (build-gateway kaniko COPY + pnpm install --frozen-lockfile) see
-        # manifests that no longer match pnpm-lock.yaml and fail
-        # ERR_PNPM_OUTDATED_LOCKFILE. Snapshot dir is step-local tmp.
-        SNAPSHOT_DIR="$(mktemp -d /tmp/publish-next-manifests.XXXXXX)"
-        export SNAPSHOT_DIR
-        find apps packages plugins -name package.json -not -path "*/node_modules/*" -not -path "*/dist/*" | while read -r mf; do
-          mkdir -p "$SNAPSHOT_DIR/$(dirname "$mf")"
-          cp -p "$mf" "$SNAPSHOT_DIR/$mf"
-        done
-        echo "[publish-next] snapshotted $(find "$SNAPSHOT_DIR" -name package.json | wc -l) manifests to $SNAPSHOT_DIR"
         node <<'NODE'
         const fs = require('node:fs');
         const path = require('node:path');
@@ -223,38 +209,23 @@ steps:
         const pipelineNumber = process.env.CI_PIPELINE_NUMBER;
         const roots = ['apps', 'packages', 'plugins'];
         const updated = [];
-        const exactVersions = new Map(); // name -> bumped next version
 
-        function walk(dir, visit) {
+        function walk(dir) {
           if (!fs.existsSync(dir)) return;
           for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
             if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.turbo') continue;
             const fullPath = path.join(dir, entry.name);
             if (entry.isDirectory()) {
               const packagePath = path.join(fullPath, 'package.json');
-              if (fs.existsSync(packagePath)) {
+              if (fs.existsSync(packagePath)) updatePackage(packagePath);
-                const manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+              walk(fullPath);
-                if (manifest.name?.startsWith('@mosaicstack/') && !manifest.private) {
-                  visit(manifest, packagePath);
-                }
-              }
-              walk(fullPath, visit);
             }
           }
         }
 
-        // #1389: two passes. Pass 1 bumps every publishable manifest to
+        function updatePackage(packagePath) {
-        // <stable+1>-next.<pipeline> exactly as before, recording name ->
+          const manifest = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-        // bumped version. Pass 2 rewrites every published manifest's
+          if (!manifest.name?.startsWith('@mosaicstack/') || manifest.private) return;
-        // @mosaicstack/* dependency entries (dependencies, devDependencies,
-        // peerDependencies, optionalDependencies) to the EXACT same-pipeline
-        // build. A caret range like ^0.0.3-next.2636 leaves the resolver free
-        // to pick any later build — and on a host with a stale cache, an
-        // installer-side scaffold pinned at stable, or a registry hiccup, that
-        // freedom is how a "next" install ends up executing stable-era code
-        // (web1 evidence: old tier validator, missing migrations). Exact pins
-        // make the defect class unrepresentable regardless of resolver path.
-        function bump(manifest, packagePath) {
           const stableMatch = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(manifest.version);
           if (!stableMatch) {
             throw new Error(manifest.name + " has unsupported semver version '" + manifest.version + "'");
@@ -263,40 +234,13 @@ steps:
           const oldVersion = manifest.version;
           manifest.version = major + '.' + minor + '.' + (Number(patch) + 1) + '-next.' + pipelineNumber;
           fs.writeFileSync(packagePath, JSON.stringify(manifest, null, 2) + '\n');
-          exactVersions.set(manifest.name, manifest.version);
           updated.push(manifest.name + ' ' + oldVersion + ' -> ' + manifest.version);
         }
 
-        const DEP_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+        for (const root of roots) walk(root);
-        let pinnedEntries = 0;
-        function pin(manifest, packagePath) {
-          let changed = false;
-          for (const field of DEP_FIELDS) {
-            const deps = manifest[field];
-            if (!deps || typeof deps !== 'object') continue;
-            for (const [name, range] of Object.entries(deps)) {
-              if (!name.startsWith('@mosaicstack/')) continue;
-              const exact = exactVersions.get(name);
-              if (!exact) {
-                throw new Error(
-                  manifest.name + ' depends on ' + name +
-                  ' which has no bumped version in this publish set — cannot pin');
-              }
-              if (range === exact) continue;
-              deps[name] = exact;
-              pinnedEntries++;
-              changed = true;
-            }
-          }
-          if (changed) fs.writeFileSync(packagePath, JSON.stringify(manifest, null, 2) + '\n');
-        }
-
-        for (const root of roots) walk(root, bump);
-        for (const root of roots) walk(root, pin);
         if (updated.length === 0) throw new Error('No publishable @mosaicstack/* packages found');
         console.log('[publish-next] computed prerelease versions for ' + updated.length + ' packages:');
         for (const line of updated) console.log('[publish-next] ' + line);
-        console.log('[publish-next] pinned ' + pinnedEntries + ' @mosaicstack/* dep entries to exact same-pipeline versions across ' + updated.length + ' manifests');
         NODE
         pnpm --filter "@mosaicstack/*" --filter "!@mosaicstack/web" --filter "!@mosaicstack/mosaic-as" publish --no-git-checks --access public --tag next
         EXPECTED_VERSION="$(node -p "require('./packages/mosaic/package.json').version")"
@@ -306,94 +250,6 @@ steps:
           exit 1
         fi
         echo "[publish-next] @mosaicstack/mosaic@next resolves to $RESOLVED_VERSION"
-        # #1389 post-publish guard: every freshly published manifest must carry
-        # EXACT same-pipeline @mosaicstack/* dep pins (no ranges, no stable
-        # fallback). A leak here fails the pipeline instead of shipping.
-        node <<'GUARD'
-        const { execFileSync } = require('node:child_process');
-        const fs = require('node:fs');
-        const path = require('node:path');
-        const pipelineNumber = process.env.CI_PIPELINE_NUMBER;
-        const registry = 'https://git.mosaicstack.dev/api/packages/mosaicstack/npm/';
-        const roots = ['apps', 'packages', 'plugins'];
-        const published = [];
-        function walk(dir) {
-          if (!fs.existsSync(dir)) return;
-          for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.turbo') continue;
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-              const packagePath = path.join(fullPath, 'package.json');
-              if (fs.existsSync(packagePath)) {
-                const m = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-                if (m.name?.startsWith('@mosaicstack/') && !m.private) published.push(m.name);
-              }
-              walk(fullPath);
-            }
-          }
-        }
-        for (const root of roots) walk(root);
-        let failures = 0;
-        for (const name of published) {
-          let manifest;
-          try {
-            const out = execFileSync('npm', ['view', name + '@next', '--json', '--registry', registry],
-                                     { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-            const arr = JSON.parse(out);
-            manifest = Array.isArray(arr) ? arr[arr.length - 1] : arr;
-          } catch (e) {
-            console.error('[publish-next-guard] FAIL ' + name + ': npm view failed: ' + e.message);
-            failures++;
-            continue;
-          }
-          const fields = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
-          for (const field of fields) {
-            const deps = manifest[field];
-            if (!deps || typeof deps !== 'object') continue;
-            for (const [dep, range] of Object.entries(deps)) {
-              if (!dep.startsWith('@mosaicstack/')) continue;
-              const expected = dep === name ? manifest.version : null;
-              const isExactPin = /^\d+\.\d+\.\d+-next\./.test(range);
-              const samePipeline = range.endsWith('-next.' + pipelineNumber);
-              if (!isExactPin) {
-                console.error('[publish-next-guard] FAIL ' + name + ' -> ' + dep + ' range "' + range + '" is not an exact -next pin (stable-leak class, #1389)');
-                failures++;
-              } else if (!samePipeline) {
-                console.error('[publish-next-guard] FAIL ' + name + ' -> ' + dep + ' pinned "' + range + '" but this pipeline published -next.' + pipelineNumber + ' (cross-pipeline pin)');
-                failures++;
-              }
-            }
-          }
-        }
-        if (failures > 0) {
-          console.error('[publish-next-guard] FATAL: ' + failures + ' dep-pin violation(s) — stable-dep leak into next publish (#1389)');
-          process.exit(1);
-        }
-        console.log('[publish-next-guard] OK: all ' + published.length + ' published manifests carry exact same-pipeline @mosaicstack/* dep pins');
-        GUARD
-        # #1404 restore: put the workspace manifests back byte-exact so later
-        # steps (build-gateway frozen-lockfile install) see the committed tree.
-        RESTORE_FAIL=0
-        while read -r mf; do
-          if [ -f "$SNAPSHOT_DIR/$mf" ]; then
-            cp -p "$SNAPSHOT_DIR/$mf" "$mf"
-          else
-            echo "[publish-next] FATAL: no snapshot for $mf — cannot restore (snapshot incomplete?)" >&2
-            RESTORE_FAIL=1
-          fi
-        done < <(find apps packages plugins -name package.json -not -path "*/node_modules/*" -not -path "*/dist/*")
-        # Pristine guard (#1404 red-first control): the publish step must leave
-        # the workspace byte-identical to the checkout for every manifest.
-        # git diff is the arbiter — any residual mutation fails THIS step
-        # instead of surfacing as ERR_PNPM_OUTDATED_LOCKFILE in build-gateway.
-        if ! git diff --exit-code -- '**/package.json' >/dev/null 2>&1; then
-          echo "[publish-next] FATAL: workspace package.json files still differ from HEAD after restore (#1404 class)" >&2
-          git diff --stat -- '**/package.json' >&2 || true
-          RESTORE_FAIL=1
-        fi
-        rm -rf "$SNAPSHOT_DIR"
-        if [ "$RESTORE_FAIL" -ne 0 ]; then exit 1; fi
-        echo "[publish-next] workspace manifests restored byte-exact (git diff clean); later steps see the committed tree"
     depends_on:
       - build
       - verify
@@ -449,14 +305,6 @@ steps:
     depends_on:
       - build
       - verify
-      # #1411: publish-next-npm mutates workspace manifests in place during
-      # its transform window and restores them at step end. Any step that
-      # reads the pipeline workspace (kaniko COPY of manifests, later
-      # installs) must run AFTER publish-next-npm, never concurrently —
-      # pipeline 2648 raced a COPY inside the window and failed
-      # ERR_PNPM_OUTDATED_LOCKFILE despite a clean restore. This edge is the
-      # serialization invariant; add it to every new workspace consumer.
-      - publish-next-npm
 
   build-appservice:
     image: gcr.io/kaniko-project/executor:debug
@@ -484,14 +332,6 @@ steps:
     depends_on:
       - build
       - verify
-      # #1411: publish-next-npm mutates workspace manifests in place during
-      # its transform window and restores them at step end. Any step that
-      # reads the pipeline workspace (kaniko COPY of manifests, later
-      # installs) must run AFTER publish-next-npm, never concurrently —
-      # pipeline 2648 raced a COPY inside the window and failed
-      # ERR_PNPM_OUTDATED_LOCKFILE despite a clean restore. This edge is the
-      # serialization invariant; add it to every new workspace consumer.
-      - publish-next-npm
 
   build-web:
     image: gcr.io/kaniko-project/executor:debug
@@ -519,11 +359,3 @@ steps:
     depends_on:
       - build
       - verify
-      # #1411: publish-next-npm mutates workspace manifests in place during
-      # its transform window and restores them at step end. Any step that
-      # reads the pipeline workspace (kaniko COPY of manifests, later
-      # installs) must run AFTER publish-next-npm, never concurrently —
-      # pipeline 2648 raced a COPY inside the window and failed
-      # ERR_PNPM_OUTDATED_LOCKFILE despite a clean restore. This edge is the
-      # serialization invariant; add it to every new workspace consumer.
-      - publish-next-npm

apps/gateway/src/database/database.module.1392.spec.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-
-// The module under test imports @mosaicstack/db at module scope; we replace only the
-// pieces DatabaseModule uses (partial mock — the real module also exports the
-// schema the storage adapter's import chain needs) so the test pins the #1392
-// contract (refuse to start on an incomplete schema) without a live database.
-vi.mock('@mosaicstack/db', async (importOriginal) => {
-  const actual: object = await importOriginal();
-  return {
-    ...actual,
-    createDb: vi.fn(),
-    createPgliteDb: vi.fn(),
-    getMigrationStatus: vi.fn(),
-    runPgliteMigrations: vi.fn(),
-  };
-});
-
-import { DatabaseModule } from './database.module.js';
-import { getMigrationStatus } from '@mosaicstack/db';
-import type { DbHandle } from '@mosaicstack/db';
-import type { StorageAdapter } from '@mosaicstack/storage';
-import type { MosaicConfig } from '@mosaicstack/config';
-
-function makeModule(storageType: 'postgres' | 'pglite', tier: string) {
-  const storageAdapter = {
-    name: storageType,
-    migrate: vi.fn(),
-    close: vi.fn(),
-  } as unknown as StorageAdapter;
-  const handle = { close: vi.fn() } as unknown as DbHandle;
-  const config = {
-    tier,
-    storage: { type: storageType, url: 'postgresql://x' },
-  } as unknown as MosaicConfig;
-  return {
-    mod: new DatabaseModule(handle, storageAdapter, config),
-    storageAdapter,
-  };
-}
-
-describe('DatabaseModule.onModuleInit — #1392 schema verification', () => {
-  it('refuses to start when the postgres schema is incomplete', async () => {
-    const { mod, storageAdapter } = makeModule('postgres', 'standalone');
-    vi.mocked(getMigrationStatus).mockResolvedValue({
-      appliedCount: 15,
-      expectedCount: 17,
-      expectedLastTag: '0016_salty_morlocks',
-      complete: false,
-    });
-    await expect(mod.onModuleInit()).rejects.toThrow('Database schema incomplete: 15/17');
-    expect(storageAdapter.migrate).toHaveBeenCalled(); // migrations attempted first
-  });
-
-  it('starts normally when the schema is complete', async () => {
-    const { mod } = makeModule('postgres', 'standalone');
-    vi.mocked(getMigrationStatus).mockResolvedValue({
-      appliedCount: 17,
-      expectedCount: 17,
-      expectedLastTag: '0016_salty_morlocks',
-      complete: true,
-    });
-    await expect(mod.onModuleInit()).resolves.toBeUndefined();
-  });
-
-  it('does not verify postgres status for the local tier (PGlite migrates itself)', async () => {
-    const { mod } = makeModule('pglite', 'local');
-    vi.mocked(getMigrationStatus).mockClear();
-    await expect(mod.onModuleInit()).resolves.toBeUndefined();
-    expect(getMigrationStatus).not.toHaveBeenCalled();
-  });
-});

apps/gateway/src/database/database.module.ts

@@ -12,7 +12,6 @@ import {
 import {
   createDb,
   createPgliteDb,
-  getMigrationStatus,
   runPgliteMigrations,
   type Db,
   type DbHandle,
@@ -75,11 +74,6 @@ export class DatabaseModule implements OnApplicationShutdown, OnModuleInit {
   // the same DATABASE_URL, so a single call covers both the gateway DB and
   // the storage tables. We deliberately do NOT call runMigrations() here to
   // avoid opening a second short-lived connection and doubling startup cost.
-  //
-  // #1392: we DO verify afterwards (getMigrationStatus opens one short-lived
-  // connection) and refuse to start on an incomplete schema. A gateway that
-  // boots "healthy" on an empty or partial database is precisely the failure
-  // that shipped in the T63 batch: silent at startup, catastrophic later.
   async onModuleInit(): Promise<void> {
     if (this.config.tier === 'local') {
       this.logger.log('Applying PGlite schema migrations...');
@@ -87,24 +81,6 @@ export class DatabaseModule implements OnApplicationShutdown, OnModuleInit {
     }
     this.logger.log(`Initializing storage adapter (${this.storageAdapter.name})...`);
     await this.storageAdapter.migrate();
-
-    if (this.config.storage.type === 'postgres') {
-      const status = await getMigrationStatus(this.config.storage.url);
-      if (!status.complete) {
-        this.logger.error(
-          `Database schema incomplete: ${status.appliedCount.toString()}/${status.expectedCount.toString()} migrations applied ` +
-            `(last expected: ${status.expectedLastTag}). ` +
-            'Refusing to start on a partial schema — see issues #1392/#1402. ' +
-            "Remediation: re-run 'mosaic gateway install' (it now verifies), or apply migrations manually.",
-        );
-        throw new Error(
-          `Database schema incomplete: ${status.appliedCount.toString()}/${status.expectedCount.toString()} migrations applied`,
-        );
-      }
-      this.logger.log(
-        `Database schema verified: ${status.appliedCount.toString()}/${status.expectedCount.toString()} migrations applied.`,
-      );
-    }
   }
 
   async onApplicationShutdown(): Promise<void> {

packages/db/src/index.ts

@@ -1,15 +1,6 @@
 export { createDb, type Db, type DbHandle } from './client.js';
 export { createPgliteDb } from './client-pglite.js';
-export {
+export { runMigrations, runPgliteMigrations } from './migrate.js';
-  runMigrations,
-  runPgliteMigrations,
-  getMigrationStatus,
-  readJournalTags,
-  applyMigrationsByHash,
-  type HashLedgerDeps,
-  type MigrationPlanEntry,
-  type MigrationStatus,
-} from './migrate.js';
 export * from './schema.js';
 export * from './federation.js';
 export {

packages/db/src/migrate.spec.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import {
-  applyMigrationsByHash,
-  readJournalTags,
-  type HashLedgerDeps,
-  type MigrationPlanEntry,
-} from './migrate.js';
-
-/* ------------------------------------------------------------------ */
-/*  In-memory hash-ledger harness                                      */
-/* ------------------------------------------------------------------ */
-
-interface LedgerHarness extends HashLedgerDeps {
-  ledger: Map<string, number>;
-  /** Recorded statement executions in order: `${hashPrefix}:${stmtIndex}`. */
-  executed: string[];
-  /** Optional: statements that should throw when executed. */
-  failOn?: (migrationHash: string, stmtIdx: number) => boolean;
-}
-
-function makeHarness(plan: MigrationPlanEntry[]): LedgerHarness {
-  const hashToEntry = new Map(plan.map((p) => [p.hash, p]));
-  const h: LedgerHarness = {
-    ledger: new Map(),
-    executed: [],
-    ensureLedger: async () => {},
-    appliedHashes: async () => [...h.ledger.keys()],
-    recordApplied: async (hash, folderMillis) => {
-      h.ledger.set(hash, folderMillis);
-    },
-    runStatement: async (statement) => {
-      void statement;
-      // runStatement does not know which migration it belongs to; the
-      // executed log is filled by the wrapper below.
-    },
-  };
-  // Wrap runStatement so the executed log records migration context. We
-  // reconstruct context by tracking a cursor the core advances per migration.
-  let cursor = 0;
-  const flat: Array<{ hash: string; idx: number }> = [];
-  for (const m of plan)
-    for (const [i] of m.statements.entries()) flat.push({ hash: m.hash, idx: i });
-  h.runStatement = async () => {
-    const at = flat[cursor] ?? { hash: '??', idx: -1 };
-    cursor += 1;
-    if (h.failOn && at.hash !== '??' && h.failOn(at.hash, at.idx)) {
-      throw new Error(`simulated failure in ${at.hash} #${at.idx.toString()}`);
-    }
-    h.executed.push(`${at.hash.slice(0, 6)}:${at.idx.toString()}`);
-  };
-  void hashToEntry;
-  return h;
-}
-
-/* ------------------------------------------------------------------ */
-/*  Fixtures                                                           */
-/* ------------------------------------------------------------------ */
-
-// Reproduces the REAL journal defect shape (#1402 D1): 0009/0010 carry
-// `when` timestamps BELOW 0008's. Under the old drizzle postgres-js
-// migrator these were silently skipped on any upgrade whose ledger was
-// last stamped in the 0008 era.
-const JOURNAL_FIXTURE: MigrationPlanEntry[] = [
-  { hash: 'aaaa0000', folderMillis: 1773368153122, statements: ['CREATE TABLE a (id int)'] },
-  { hash: 'bbbb0008', folderMillis: 1776822435828, statements: ['CREATE TABLE b (id int)'] },
-  // Backdated entries, exactly as shipped:
-  {
-    hash: 'cccc0009',
-    folderMillis: 1745280000000,
-    statements: ['ALTER TYPE t ADD VALUE', "CREATE TABLE c (s t DEFAULT 'pending')"],
-  },
-  { hash: 'dddd0010', folderMillis: 1745366400000, statements: ['CREATE TABLE d (id int)'] },
-];
-
-/** A ledger last stamped at the 0008 era: only pre-0009 hashes recorded. */
-const LEDGER_AT_0008_ERA = new Map<string, number>([
-  ['aaaa0000', 1773368153122],
-  ['bbbb0008', 1776822435828],
-]);
-
-/* ------------------------------------------------------------------ */
-/*  The core: apply-by-hash in journal order                           */
-/* ------------------------------------------------------------------ */
-
-describe('applyMigrationsByHash', () => {
-  it('applies backdated journal entries that a timestamp-based migrator would skip (#1402 D1)', async () => {
-    const h = makeHarness(JOURNAL_FIXTURE);
-    h.ledger = new Map(LEDGER_AT_0008_ERA);
-
-    const result = await applyMigrationsByHash(h, JOURNAL_FIXTURE);
-
-    // D1 in one sentence: 0009 and 0010 applied despite folderMillis < 0008.
-    expect(result).toEqual({ applied: 2, skipped: 2 });
-    expect(h.ledger.has('cccc0009')).toBe(true);
-    expect(h.ledger.has('dddd0010')).toBe(true);
-  });
-
-  it('executes statements individually (ALTER TYPE visibility, #1402 D2 shape)', async () => {
-    const h = makeHarness(JOURNAL_FIXTURE);
-    await applyMigrationsByHash(h, JOURNAL_FIXTURE);
-    // 0009's two statements recorded as separate executions, in order.
-    expect(h.executed).toContain('cccc00:0');
-    expect(h.executed).toContain('cccc00:1');
-    expect(h.executed.indexOf('cccc00:0')).toBeLessThan(h.executed.indexOf('cccc00:1'));
-  });
-
-  it('is idempotent: a fully-applied ledger applies nothing', async () => {
-    const h = makeHarness(JOURNAL_FIXTURE);
-    const first = await applyMigrationsByHash(h, JOURNAL_FIXTURE);
-    const second = await applyMigrationsByHash(h, JOURNAL_FIXTURE);
-    expect(first.applied).toBe(4);
-    expect(second).toEqual({ applied: 0, skipped: 4 });
-    expect(h.executed).toHaveLength(5); // 5 statements; second run executed NONE (not 10)
-  });
-
-  it('records no ledger row when a statement fails (crash prefix replays loudly)', async () => {
-    const h = makeHarness(JOURNAL_FIXTURE);
-    h.failOn = (hash, idx) => hash === 'cccc0009' && idx === 1;
-
-    await expect(applyMigrationsByHash(h, JOURNAL_FIXTURE)).rejects.toThrow(
-      /cccc0009 statement #1 failed: simulated failure/,
-    );
-    // Statement 0 of 0009 executed, but NO ledger row for 0009: the next run
-    // replays it and fails loudly on "already exists" instead of silently
-    // believing 0009 applied.
-    expect(h.ledger.has('cccc0009')).toBe(false);
-    expect(h.executed).toContain('cccc00:0');
-  });
-
-  it('applies in JOURNAL order, not timestamp order', async () => {
-    const h = makeHarness(JOURNAL_FIXTURE);
-    await applyMigrationsByHash(h, JOURNAL_FIXTURE);
-    // 5 statements total (0009 has two); prefix per migration: journal order,
-    // so 0009's pair sits between 0008 and 0010.
-    const order = h.executed.map((e) => e.slice(0, 4));
-    expect(order).toEqual(['aaaa', 'bbbb', 'cccc', 'cccc', 'dddd']);
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  Journal integrity against the shipped folder                       */
-/* ------------------------------------------------------------------ */
-
-describe('readJournalTags', () => {
-  it('reads the shipped journal in order and sees the known backdated pair', () => {
-    const folder = resolve(__dirname, '../drizzle');
-    const tags = readJournalTags(folder);
-    expect(tags.length).toBeGreaterThan(0);
-    // The shipped defect (#1402 D1): these two entries carry April-2025
-    // timestamps below 0008's June-2026 one. If this assertion ever fails
-    // because the journal was FIXED (timestamps corrected or drizzle-kit
-    // regenerated), update #1402 — the hash-ledger core stays correct either
-    // way; this test pins the shipped reality the core was built for.
-    const t9 = tags.find((t) => t.startsWith('0009_'));
-    const t10 = tags.find((t) => t.startsWith('0010_'));
-    const t8 = tags.find((t) => t.startsWith('0008_'));
-    expect([t8, t9, t10]).toBeDefined();
-    const journal = JSON.parse(readFileSync(resolve(folder, 'meta', '_journal.json'), 'utf8')) as {
-      entries: Array<{ tag: string; when: number }>;
-    };
-    const when = new Map(journal.entries.map((e) => [e.tag, e.when]));
-    if (t8 && t9 && t10) {
-      expect(when.get(t9)!).toBeLessThan(when.get(t8)!); // backdated below 0008
-      expect(when.get(t10)!).toBeLessThan(when.get(t8)!); // backdated below 0008
-    }
-  });
-});

packages/db/src/migrate.ts

@@ -1,7 +1,8 @@
-import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { sql } from 'drizzle-orm';
+import { drizzle as drizzlePostgres } from 'drizzle-orm/postgres-js';
+import { migrate as migratePostgres } from 'drizzle-orm/postgres-js/migrator';
 import { readMigrationFiles } from 'drizzle-orm/migrator';
 import postgres from 'postgres';
 import { DEFAULT_DATABASE_URL } from './defaults.js';
@@ -20,243 +21,89 @@ function migrationsFolder(): string {
   return resolve(here, '../drizzle');
 }
 
-/* ------------------------------------------------------------------ */
-/*  Shared hash-ledger migration core (#1392 / #1402)                  */
-/* ------------------------------------------------------------------ */
-//
-// Both tiers migrate through this single core, which applies migrations in
-// JOURNAL ORDER, one statement at a time, and skips by HASH — never by
-// folderMillis timestamp. The previous postgres path delegated to drizzle's
-// postgres-js migrator, which:
-//
-//   * applies only migrations with folderMillis > last-applied, silently
-//     skipping journal entries whose `when` is older than the ledger's newest
-//     stamp — 0009/0010 carry April-2025 timestamps below 0008's June-2026
-//     one, so any database last migrated in the 0008 era silently loses
-//     0009/0010 forever (#1402 D1); and
-//   * wraps each migration in ONE transaction, which breaks migrations that
-//     do `ALTER TYPE ADD VALUE` and then reference the new value in the same
-//     migration (0009) — Postgres' check_safe_enum_use rejects it (#1402 D2).
-//
-// Per-statement execution (each statement autocommits) and skip-by-hash fix
-// both. The PGlite path has run this way since it was written; this is the
-// TODO it left behind, now shared instead of duplicated.
-
-/** One migration as loaded from the shipped drizzle/ folder. */
-export interface MigrationPlanEntry {
-  hash: string;
-  folderMillis: number;
-  statements: string[];
-}
-
-/** The persistence operations the hash-ledger core needs, per tier. */
-export interface HashLedgerDeps {
-  /** Create the drizzle schema + ledger table if absent (idempotent). */
-  ensureLedger(): Promise<void>;
-  /** Hashes already recorded in the ledger. */
-  appliedHashes(): Promise<string[]>;
-  /** Record one fully-applied migration in the ledger. */
-  recordApplied(hash: string, folderMillis: number): Promise<void>;
-  /** Execute one SQL statement, autocommitting (never inside a wider tx). */
-  runStatement(statement: string): Promise<void>;
-}
-
-function loadPlan(): MigrationPlanEntry[] {
-  return readMigrationFiles({ migrationsFolder: migrationsFolder() }).map((m) => ({
-    hash: m.hash,
-    folderMillis: m.folderMillis,
-    statements: m.sql.map((s) => s.trim()).filter((s) => s.length > 0),
-  }));
-}
-
-/**
- * Apply every unapplied migration in journal order, skipping by hash.
- *
- * Failure model: each statement autocommits, and the ledger row is written
- * only after all statements of a migration succeed. A crash mid-migration
- * leaves the prefix applied with no ledger entry, so the next boot replays
- * those statements and fails loudly on "already exists". Recovery: drop the
- * partially-applied objects, or insert the migration's hash into
- * `drizzle.__drizzle_migrations` manually. The thrown error identifies the
- * statement and migration that failed.
- */
-export async function applyMigrationsByHash(
-  deps: HashLedgerDeps,
-  plan: MigrationPlanEntry[] = loadPlan(),
-): Promise<{ applied: number; skipped: number }> {
-  await deps.ensureLedger();
-  const alreadyApplied = new Set(await deps.appliedHashes());
-
-  let applied = 0;
-  let skipped = 0;
-  for (const migration of plan) {
-    if (alreadyApplied.has(migration.hash)) {
-      skipped += 1;
-      continue;
-    }
-    for (const [stmtIdx, stmt] of migration.statements.entries()) {
-      try {
-        await deps.runStatement(stmt);
-      } catch (err) {
-        const cause = err instanceof Error ? err.message : String(err);
-        throw new Error(
-          `migration hash=${migration.hash} statement #${stmtIdx} failed: ${cause}\n` +
-            `Statement: ${stmt.slice(0, 200)}${stmt.length > 200 ? '…' : ''}`,
-          { cause: err },
-        );
-      }
-    }
-    await deps.recordApplied(migration.hash, migration.folderMillis);
-    applied += 1;
-  }
-  return { applied, skipped };
-}
-
-const LEDGER_DDL = [
-  'CREATE SCHEMA IF NOT EXISTS drizzle',
-  `CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-      id SERIAL PRIMARY KEY,
-      hash text NOT NULL,
-      created_at bigint
-    )`,
-];
-
-function connectionString(url?: string): string {
-  return url ?? process.env['DATABASE_URL'] ?? DEFAULT_DATABASE_URL;
-}
-
-/**
- * Apply Drizzle migrations against a postgres database, hash-ledger style.
- * Idempotent: re-running against a fully-migrated database applies nothing.
- */
 export async function runMigrations(url?: string): Promise<void> {
-  const sqlClient = postgres(connectionString(url), { max: 1 });
+  const connectionString = url ?? process.env['DATABASE_URL'] ?? DEFAULT_DATABASE_URL;
+  const sqlClient = postgres(connectionString, { max: 1 });
+  const db = drizzlePostgres(sqlClient);
   try {
-    await applyMigrationsByHash({
+    // TODO: postgres-tier first-install also fails because (a) Drizzle wraps every
-      ensureLedger: async () => {
+    // migration in one transaction (breaks 0009's ALTER TYPE ADD VALUE → SET DEFAULT
-        for (const ddl of LEDGER_DDL) await sqlClient.unsafe(ddl);
+    // sequence) and (b) drizzle/meta/_journal.json has 0009 ordered before 0008,
-      },
+    // which the postgres-js migrator skips by `created_at < folderMillis`. The
-      appliedHashes: async () => {
+    // PGlite path below sidesteps both. A follow-up should either share the
-        const rows = (await sqlClient.unsafe(
+    // per-statement loop (see runPgliteMigrations) or fix the journal ordering.
-          'SELECT hash FROM drizzle.__drizzle_migrations',
+    await migratePostgres(db, { migrationsFolder: migrationsFolder() });
-        )) as Array<{ hash: string }>;
-        return rows.map((r) => String(r.hash));
-      },
-      recordApplied: async (hash, folderMillis) => {
-        await sqlClient.unsafe(
-          'INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES ($1, $2)',
-          [hash, folderMillis],
-        );
-      },
-      runStatement: async (stmt) => {
-        await sqlClient.unsafe(stmt);
-      },
-    });
   } finally {
     await sqlClient.end();
   }
 }
 
-/**
+// Apply Drizzle migrations against an embedded PGlite database.
- * Apply Drizzle migrations against an embedded PGlite database.
+//
- *
+// We don't reuse drizzle's pglite migrator because it wraps ALL migrations in
- * We don't reuse drizzle's pglite migrator for the same reasons as the
+// one outer transaction, which breaks Postgres' `check_safe_enum_use` rule —
- * postgres path (single-transaction wrap; folderMillis skip). PGlite's
+// e.g. migration 0009 does `ALTER TYPE ADD VALUE 'pending'` then references
- * `exec()` runs each statement under the Simple Query protocol,
+// `'pending'` as a default in the same tx. PGlite's `exec()` runs each
- * autocommitting between them — exactly the semantics the shared core needs.
+// statement under the Simple Query protocol, autocommitting between them.
- *
+//
- * The ledger rows this writes are interoperable with the postgres path (same
+// We still write to the standard `drizzle.__drizzle_migrations` ledger so the
- * schema, same hashes), because both consume the same shipped migrations.
+// result is interoperable with `runMigrations()` on a postgres-backed deploy
- */
+// (modulo the journal-ordering bug noted above).
+//
+// We skip-by-hash rather than skip-by-folderMillis (which is what Drizzle's
+// postgres-js migrator does). That's deliberate — out-of-order timestamps in
+// `_journal.json` won't silently drop migrations.
+//
+// Failure model: each statement autocommits, and the ledger row is written
+// only after all statements in a migration succeed. A crash mid-migration
+// leaves the prefix applied with no ledger entry, so the next boot will
+// replay those statements and fail loudly on "already exists". Recovery:
+// drop the partially-applied objects, or insert the migration's hash into
+// `drizzle.__drizzle_migrations` manually. The error log identifies which
+// statement of which migration was the culprit.
 export async function runPgliteMigrations(handle: DbHandle): Promise<void> {
   const client = (handle.db as unknown as { $client?: PgliteExecutor }).$client;
   if (!client || typeof client.exec !== 'function') {
     throw new Error('runPgliteMigrations: handle.db is not backed by a PGlite client');
   }
 
-  await applyMigrationsByHash({
+  await client.exec('CREATE SCHEMA IF NOT EXISTS drizzle');
-    ensureLedger: async () => {
+  await client.exec(`
-      for (const ddl of LEDGER_DDL) await client.exec(ddl);
+    CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-    },
+      id SERIAL PRIMARY KEY,
-    appliedHashes: async () => {
+      hash text NOT NULL,
-      const rows = (await handle.db.execute(
+      created_at bigint
-        sql`SELECT hash FROM drizzle.__drizzle_migrations`,
+    )
-      )) as unknown as ExecuteRows<{ hash: string }>;
+  `);
-      return rows.rows.map((r) => String(r.hash));
-    },
-    recordApplied: async (hash, folderMillis) => {
-      await handle.db.execute(
-        sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES (${hash}, ${folderMillis})`,
-      );
-    },
-    runStatement: async (stmt) => {
-      await client.exec(stmt);
-    },
-  });
-}
 
-/* ------------------------------------------------------------------ */
+  const appliedRows = (await handle.db.execute(
-/*  Migration status (#1392: the installer must VERIFY, not assume)     */
+    sql`SELECT hash FROM drizzle.__drizzle_migrations`,
-/* ------------------------------------------------------------------ */
+  )) as unknown as ExecuteRows<{ hash: string }>;
+  const applied = new Set(appliedRows.rows.map((r) => r.hash));
 
-/** Read the journal tags (migration folder names) in journal order. */
+  const migrations = readMigrationFiles({ migrationsFolder: migrationsFolder() });
-export function readJournalTags(folder: string = migrationsFolder()): string[] {
+  for (const migration of migrations) {
-  const journal = JSON.parse(readFileSync(resolve(folder, 'meta', '_journal.json'), 'utf8')) as {
+    if (applied.has(migration.hash)) continue;
-    entries?: Array<{ tag?: string }>;
-  };
-  return (journal.entries ?? []).map((e) => e.tag ?? '').filter((t) => t.length > 0);
-}
 
-export interface MigrationStatus {
+    // Run each statement-breakpoint chunk in its own exec() call so PGlite
-  /** Hashes recorded in the database's ledger (0 if no ledger exists). */
+    // commits between statements — this is what lets `ALTER TYPE ADD VALUE`
-  appliedCount: number;
+    // become visible before a subsequent statement references the new value.
-  /** Migrations shipped in this package's drizzle/ folder. */
+    for (const [stmtIdx, stmt] of migration.sql.entries()) {
-  expectedCount: number;
+      const trimmed = stmt.trim();
-  /** The tag (folder name) of the last journal entry, for error messages. */
+      if (!trimmed) continue;
-  expectedLastTag: string;
+      try {
-  /** True iff every shipped migration's hash is in the ledger. */
+        await client.exec(trimmed);
-  complete: boolean;
+      } catch (err) {
-}
+        const cause = err instanceof Error ? err.message : String(err);
-
+        throw new Error(
-/**
+          `runPgliteMigrations: migration hash=${migration.hash} statement #${stmtIdx} failed: ${cause}\n` +
- * Report whether a postgres database carries the full shipped schema.
+            `Statement: ${trimmed.slice(0, 200)}${trimmed.length > 200 ? '…' : ''}`,
- *
+          { cause: err },
- * Read-only apart from `ensureLedger` semantics: it never creates the ledger
+        );
- * (unlike the migrators), so a database with NO ledger reports
+      }
- * appliedCount=0 / complete=false — the exact #1392/#1389 signature (an
- * install whose dependency set shipped no migrations at all).
- */
-export async function getMigrationStatus(url?: string): Promise<MigrationStatus> {
-  const sqlClient = postgres(connectionString(url), { max: 1 });
-  try {
-    const plan = loadPlan();
-    const tags = readJournalTags();
-    const expectedHashes = new Set(plan.map((m) => m.hash));
-
-    let appliedHashes: string[] = [];
-    const regRows = (await sqlClient.unsafe(
-      "SELECT to_regclass('drizzle.__drizzle_migrations') AS reg",
-    )) as Array<{ reg: string | null }>;
-    if (regRows[0]?.reg) {
-      const rows = (await sqlClient.unsafe(
-        'SELECT hash FROM drizzle.__drizzle_migrations',
-      )) as Array<{ hash: string }>;
-      appliedHashes = rows.map((r) => String(r.hash));
     }
-
+    await handle.db.execute(
-    const appliedSet = new Set(appliedHashes);
+      sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES (${migration.hash}, ${migration.folderMillis})`,
-    return {
+    );
-      appliedCount: appliedHashes.length,
-      expectedCount: plan.length,
-      expectedLastTag: tags[tags.length - 1] ?? '',
-      complete:
-        plan.length > 0 &&
-        plan.every((m) => appliedSet.has(m.hash)) &&
-        // A ledger with entries OUTSIDE the shipped plan means the database
-        // came from a different (e.g. newer) build — not "complete" either.
-        appliedHashes.every((h) => expectedHashes.has(h)),
-    };
-  } finally {
-    await sqlClient.end();
   }
 }

packages/mosaic/framework/defaults/TOOLS.md

@@ -23,7 +23,6 @@ absent. Do not use raw `tmux send-keys` for fleet messaging.
 ```bash
 tools/git/pr-create.sh ...   tools/git/issue-create.sh ...   tools/git/pr-merge.sh ...
 tools/git/ci-queue-wait.sh --purpose push|merge   # REQUIRED before any push/merge
-tools/git/repo-decl.sh                            # shared .mosaic/repo.json consumption lib (sourced)
 ```
 
 **GITEA_LOGIN gotcha** — the wrappers default to login `mosaicstack`; on a USC repo that fails with

packages/mosaic/framework/guides/TOOLS-REFERENCE.md

@@ -111,7 +111,7 @@ approve path carries the trap.) `pr-review.sh` sends the correct token for the d
 Whatever you use, re-read `GET /pulls/{n}/reviews` and assert the state before reporting a verdict
 placed.
 
-The guard exits nonzero for any provider-asserted non-green, missing, or malformed CI state. If credentials or the provider are unavailable, it emits `CANNOT_ASSERT` and writes a JSONL audit record. Push degrades to exit 0 so recovery work is not bricked; merge holds with retryable exit 75 until the provider recovers, then self-clears without manual reset. Neither outcome is evidence that CI was clear. For a repository with no CI configured at all, `pr-merge.sh --no-ci-expected` is the sanctioned merge path: it forwards to `ci-queue-wait.sh --no-ci-expected`, which reclassifies a zero-context merge head as queue-clear only when the acting token holds repository admin and `MOSAIC_GIT_IDENTITY` names the asserting identity (a caller without one is refused with exit 78 before the admin lookup), and records the assertion (or its refusal) in the same JSONL audit log. `pr-merge.sh` automatically inspects the exact PR head repository and full commit SHA rather than its `main` base; this also handles fork PRs without branch-name ambiguity. Pass `--expect-head <approved-full-sha>` to bind a commit-specific review or merge-gate verdict; Gitea uses atomic `head_commit_id` and GitHub uses `--match-head-commit`.
+The guard exits nonzero for any provider-asserted non-green, missing, or malformed CI state. If credentials or the provider are unavailable, it emits `CANNOT_ASSERT` and writes a JSONL audit record. Push degrades to exit 0 so recovery work is not bricked; merge holds with retryable exit 75 until the provider recovers, then self-clears without manual reset. Neither outcome is evidence that CI was clear. `pr-merge.sh` automatically inspects the exact PR head repository and full commit SHA rather than its `main` base; this also handles fork PRs without branch-name ambiguity. Pass `--expect-head <approved-full-sha>` to bind a commit-specific review or merge-gate verdict; Gitea uses atomic `head_commit_id` and GitHub uses `--match-head-commit`.
 
 ### Code Review (Codex)
 
@@ -219,23 +219,6 @@ Multi-instance support: `-a <instance>` selects a named instance (e.g. `personal
 ~/.config/mosaic/tools/health/stack-health.sh -f json
 ```
 
-### Repo Structure Declaration (T51)
-
-```bash
-# Validate a .mosaic/repo.json declaration (schema v1/v2, host:/ grammar,
-# ref grammar, cross-field rules, remote normalization; spec §5)
-~/.config/mosaic/tools/structure/validate-repo-json.sh <repo>/.mosaic/repo.json
-
-# CI authoring rule: new/edited declarations must be schema_version 2
-~/.config/mosaic/tools/structure/validate-repo-json.sh <repo>/.mosaic/repo.json --require-v2
-
-# Display mode (warns and omits root-dependent checks when MOSAIC_HOST_ROOT unset)
-~/.config/mosaic/tools/structure/validate-repo-json.sh <repo>/.mosaic/repo.json --mode display
-
-# Hermetic hostile-input suite (101 arms)
-~/.config/mosaic/tools/structure/test-validate-repo-json.sh
-```
-
 ### Shared Credential Loader
 
 ```bash

packages/mosaic/framework/systemd/user/mosaic-agent@.service

@@ -11,17 +11,7 @@ PartOf=mosaic-tmux-holder.service
 # launcher would fail the unit. A skipped unit is the honest state for "enabled
 # but not yet configured"; systemd re-evaluates the condition on every start, so
 # the seat comes up on the next start once the reconciler has written env.
-#
+ConditionPathExists=%h/.config/mosaic/fleet/agents/%i.env.generated
-# #1408: the reconciler writes projections into the BRAIN home when one is
-# active (~/.mosaic/fleet/agents, mirroring start-agent-session.sh's brain-home
-# resolution), and into MOSAIC_HOME on a legacy single-tree host. A single
-# config-home condition therefore skipped every seat on brain-home estates —
-# measured on two estates: 27 projections vs 0, and 5 vs 0, gate never fired.
-# Two TRIGGERING conditions (the `|` prefix ORs same-type conditions, which
-# otherwise AND): either shape arms the unit; the launcher still resolves the
-# authoritative copy itself.
-ConditionPathExists=|%h/.config/mosaic/fleet/agents/%i.env.generated
-ConditionPathExists=|%h/.mosaic/fleet/agents/%i.env.generated
 
 [Service]
 Type=oneshot

packages/mosaic/framework/systemd/user/test-fleet-units.sh

@@ -32,17 +32,6 @@ if grep -qF -- '/bin/bash -lc' "$HOLDER"; then
   fail "holder must not start tmux through a login shell"
 fi
 grep -qF 'Requires=mosaic-tmux-holder.service' "$AGENT" || fail "agent does not require holder"
-# #1408: the projection condition must arm on EITHER home shape. Both lines must
-# carry the `|` triggering prefix — same-type conditions without it AND together,
-# which can never be true (one file cannot exist at two paths), so a bare-spelling
-# regression would disable autostart everywhere while reading as "has a condition".
-grep -qF 'ConditionPathExists=|%h/.config/mosaic/fleet/agents/%i.env.generated' "$AGENT" || \
-  fail "agent lacks triggering condition for the config home projection"
-grep -qF 'ConditionPathExists=|%h/.mosaic/fleet/agents/%i.env.generated' "$AGENT" || \
-  fail "agent lacks triggering condition for the brain home projection (#1408)"
-if grep -qE '^ConditionPathExists=[^|]' "$AGENT"; then
-  fail "agent has a non-triggering ConditionPathExists — same-type conditions AND, re-arming #1408"
-fi
 grep -qF 'start-agent-session.sh' "$AGENT" || fail "agent unit does not call start-agent-session.sh"
 if grep -qE '^Environment(File)?=' "$AGENT" "$INTERACTION"; then
   fail "agent units must not accept ambient or projection environment before strict parsing"

packages/mosaic/framework/tools/_scripts/mosaic-doctor

@@ -379,54 +379,8 @@ check_fleet_transport() {
   fi
 }
 
-check_structure_anchor_provisioning() {
-  # T51 WP0b (spec §1.2a + PHASE2-MAP F7): audit the two declaration anchors.
-  # Doctor runs from operator shells and CI where the launcher exports do not
-  # exist, so this is an AUDIT ONLY — it never exports, writes, or fabricates
-  # values for consumption. Four states (charter):
-  #   both present+nonempty  PASS (values reported as paths only)
-  #   one missing/empty     WARN naming the var + the launcher as authority
-  #   neither present       INFORMATIONAL launcher-equivalent derivation,
-  #                         explicitly non-authoritative, + launcher warning;
-  #                         never an error by design (F7(b))
-  # Severity follows the doctor's existing conventions: pass/note are quiet
-  # (note unless --verbose), warn counts toward --fail-on-warn.
-  local host_root="${MOSAIC_HOST_ROOT:-}" brain_home="${MOSAIC_BRAIN_HOME:-}"
-  # T51P2WP0BRW B1: presence is tracked SEPARATELY from value — `${VAR:-}`
-  # collapses exported-empty into genuinely-unset, which mis-filed both-empty
-  # and the mixed empty/unset states as informational. Only BOTH-genuinely-
-  # absent may be informational (charter state 3); any present-but-empty or
-  # single-present state warns.
-  local host_set=0 brain_set=0
-  [[ -v MOSAIC_HOST_ROOT ]]  && host_set=1
-  [[ -v MOSAIC_BRAIN_HOME ]] && brain_set=1
-  if [[ "$host_set" -eq 1 && "$brain_set" -eq 1 && -n "$host_root" && -n "$brain_home" ]]; then
-    pass "Structure anchors provisioned: MOSAIC_HOST_ROOT=$host_root MOSAIC_BRAIN_HOME=$brain_home (paths reported only; not expanded, not consumed)"
-    return
-  fi
-  if [[ "$host_set" -eq 0 && "$brain_set" -eq 0 ]]; then
-    note "Structure anchors not provisioned in this environment. Launcher-equivalent derivation (INFORMATIONAL, NON-AUTHORITATIVE — seats receive the authoritative values from the launchers): MOSAIC_HOST_ROOT would default to the operator home; MOSAIC_BRAIN_HOME would default to the brain tree resolved at launch. Doctor does not guess values for consumption; it audits provisioning."
-    note "Provision both anchors via the seat launchers (launch-seat.sh / launch-seat-claude.sh export them; see T51 spec §1.2a)."
-    return
-  fi
-  # At least one variable is present (possibly empty), or exactly one exists:
-  # every missing/empty anchor gets its own loud WARN naming the launchers.
-  if [[ "$host_set" -eq 0 ]]; then
-    warn "MOSAIC_HOST_ROOT is not set in this environment while MOSAIC_BRAIN_HOME is — declaration consumers fail closed without it (spec §1.2a). The seat launchers are the authoritative source."
-  elif [[ -z "$host_root" ]]; then
-    warn "MOSAIC_HOST_ROOT is present but EMPTY in this environment — declaration consumers fail closed without a usable value (spec §1.2a). The seat launchers are the authoritative source."
-  fi
-  if [[ "$brain_set" -eq 0 ]]; then
-    warn "MOSAIC_BRAIN_HOME is not set in this environment while MOSAIC_HOST_ROOT is — the projects/ mirror and brain declaration resolve from it (spec §1.2a). The seat launchers are the authoritative source."
-  elif [[ -z "$brain_home" ]]; then
-    warn "MOSAIC_BRAIN_HOME is present but EMPTY in this environment — the projects/ mirror and brain declaration resolve from it (spec §1.2a). The seat launchers are the authoritative source."
-  fi
-}
-
 check_fleet_transport
 
-check_structure_anchor_provisioning
-
 check_brain_home
 
 # Legacy migration surfaces should no longer contain symlink trees.

packages/mosaic/framework/tools/_scripts/test-structure-anchor-check.sh

@@ -1,131 +0,0 @@
-#!/usr/bin/env bash
-# Covers the structure-anchor provisioning check in `mosaic-doctor` (T51 WP0b).
-#
-# Same discipline as test-brain-home-check.sh: functions are extracted from the
-# shipped script (exact header + closing brace), never copied — a test carrying
-# its own copy of the logic keeps passing after the shipped copy changes.
-#
-# Four contract states (charter T51P2WP0B-20260824):
-#   1. both present+nonempty      -> pass ([OK]), no warns, no notes
-#   2a. host missing, brain set   -> warn naming MOSAIC_HOST_ROOT + launchers
-#   2b. brain missing, host set   -> warn naming MOSAIC_BRAIN_HOME + launchers
-#   2c. present-but-EMPTY counts as missing (warns; NEVER informational)
-#   3. neither present            -> informational notes, NON-AUTHORITATIVE, never warn
-# Arms include genuinely-UNSET (env -u) forms, not only empty strings.
-# Red control: empty-vs-unset distinction removed in a mutated copy -> suite red.
-set -euo pipefail
-
-SCRIPT_DIR=$(cd -- "$(dirname "$0")" && pwd)
-DOCTOR="$SCRIPT_DIR/mosaic-doctor"
-
-fail() {
-  echo "FAIL: $*" >&2
-  exit 1
-}
-
-[ -f "$DOCTOR" ] || fail "missing mosaic-doctor at $DOCTOR"
-
-extract_function() {
-  local name="$1"
-  local extracted
-  extracted=$(sed -n "/^${name}() {/,/^}/p" "$DOCTOR")
-  [ -n "$extracted" ] || fail "could not extract ${name}() from mosaic-doctor — script reshaped?"
-  printf '%s\n' "$extracted"
-}
-
-for fn in check_structure_anchor_provisioning; do
-  extract_function "$fn" >/dev/null
-done
-
-# run_case LABEL EXPECT(ok|warn|note) [env assignments as args; -u VAR tokens for unset]
-run_case() {
-  local label="$1" expect="$2"
-  shift 2
-  local envs=() unsets=()
-  local a
-  for a in "$@"; do
-    case "$a" in
-      -u:*) unsets+=("${a#-u:}") ;;
-      *) envs+=("$a") ;;
-    esac
-  done
-  local out warns notes oks
-  # build the env command with proper -u flags (array expansion must not
-  # glue '-u VAR' into one word)
-  local cmd=(env)
-  local e u
-  # env(1) parses options only before the first assignment — -u flags FIRST
-  for u in "${unsets[@]:-}"; do [ -n "$u" ] && cmd+=(-u "$u"); done
-  for e in "${envs[@]:-}"; do [ -n "$e" ] && cmd+=("$e"); done
-  cmd+=(bash -c "warn() { echo \"[WARN] \$*\"; }; note() { echo \"[NOTE] \$*\"; return 0; }; pass() { echo \"[OK] \$*\"; return 0; }; $(extract_function check_structure_anchor_provisioning); check_structure_anchor_provisioning")
-  out=$("${cmd[@]}" 2>&1)
-  warns=$(printf '%s\n' "$out" | grep -c '^\[WARN\]' || true)
-  notes=$(printf '%s\n' "$out" | grep -c '^\[NOTE\]' || true)
-  oks=$(printf '%s\n' "$out" | grep -c '^\[OK\]' || true)
-  if [[ "$expect" == ok && "$oks" -gt 0 && "$warns" -eq 0 && "$notes" -eq 0 ]]; then
-    echo "ok - $label"
-  elif [[ "$expect" == warn && "$warns" -ge 1 && "$notes" -eq 0 ]]; then
-    echo "ok - $label (warned x$warns)"
-  elif [[ "$expect" == note && "$notes" -gt 0 && "$warns" -eq 0 ]]; then
-    echo "ok - $label (noted)"
-  else
-    echo "output: $out" >&2
-    fail "$label: expected $expect (oks=$oks warns=$warns notes=$notes)"
-  fi
-}
-
-ROOT=$(mktemp -d)
-trap 'rm -rf "$ROOT"' EXIT
-HOST="$ROOT/host"
-BRAIN="$ROOT/brain"
-
-# ── state 1: both present + nonempty → pass ────────────────────────────────
-run_case "both anchors present passes" ok \
-  MOSAIC_HOST_ROOT="$HOST" MOSAIC_BRAIN_HOME="$BRAIN"
-
-# ── state 2a: host missing (unset), brain set → exactly one warn ───────────
-run_case "unset host root warns" warn \
-  -u:MOSAIC_HOST_ROOT MOSAIC_BRAIN_HOME="$BRAIN"
-
-# ── state 2b: brain missing (unset), host set → exactly one warn ───────────
-run_case "unset brain home warns" warn \
-  MOSAIC_HOST_ROOT="$HOST" -u:MOSAIC_BRAIN_HOME
-
-# ── state 2c-empty: present-but-empty counts as missing ────────────────────
-run_case "empty-string host root warns (empty != set)" warn \
-  MOSAIC_HOST_ROOT= MOSAIC_BRAIN_HOME="$BRAIN"
-run_case "empty-string brain home warns (empty != set)" warn \
-  MOSAIC_HOST_ROOT="$HOST" MOSAIC_BRAIN_HOME=
-
-# ── state 3: neither present (genuinely unset) → notes, never warn ─────────
-run_case "both unset yields non-authoritative notes" note \
-  -u:MOSAIC_HOST_ROOT -u:MOSAIC_BRAIN_HOME
-run_case "both empty-string warns (empty is present, not absent)" warn \
-  MOSAIC_HOST_ROOT= MOSAIC_BRAIN_HOME=
-run_case "host empty + brain unset warns" warn \
-  MOSAIC_HOST_ROOT= -u:MOSAIC_BRAIN_HOME
-run_case "host unset + brain empty warns" warn \
-  -u:MOSAIC_HOST_ROOT MOSAIC_BRAIN_HOME=
-
-# ── red control (mutation): presence tracking removed → red ────────────────
-# Mutant regresses to the reviewed defect shape: presence derived from
-# NONEMPTINESS (the `${VAR:-}` collapse) instead of true -v tracking. Both-empty
-# then looks genuinely-absent and is mis-filed as informational; the both-empty
-# warn arm above finds no WARN and the suite reds.
-MUT="$ROOT/mosaic-doctor.mutant"
-sed 's/\[\[ -v MOSAIC_HOST_ROOT \]\]  \&\& host_set=1/[[ -n "${MOSAIC_HOST_ROOT:-}" ]] \&\& host_set=1/; s/\[\[ -v MOSAIC_BRAIN_HOME \]\] \&\& brain_set=1/[[ -n "${MOSAIC_BRAIN_HOME:-}" ]] \&\& brain_set=1/' \
-  "$DOCTOR" > "$MUT"
-if cmp -s "$DOCTOR" "$MUT"; then
-  echo "SKIP red control (mutation anchor not found — sed pattern drifted)" >&2
-else
-  mut_fn=$(sed -n "/^check_structure_anchor_provisioning() {/,/^}/p" "$MUT")
-  outm=$(env MOSAIC_HOST_ROOT= MOSAIC_BRAIN_HOME= bash -c \
-    "warn() { echo \"[WARN] \$*\"; }; note() { echo \"[NOTE] \$*\"; return 0; }; pass() { echo \"[OK] \$*\"; return 0; }; $mut_fn; check_structure_anchor_provisioning" 2>&1)
-  if printf '%s\n' "$outm" | grep -q '^\[NOTE\]'; then
-    echo "ok - red control bites (mutant collapses empty into informational; shipped does not)"
-  else
-    fail "red control did not reproduce the regression shape (mutant output unexpected)"
-  fi
-fi
-
-echo "structure anchor doctor check: all arms passed"

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

@@ -304,17 +304,6 @@ if [ "$MODE" = stop ]; then
   exit 0
 fi
 
-# #1408 hazard: a seat still living on the DEFAULT tmux socket is invisible to the
-# declared-socket guard below, and launching over it creates a same-name duplicate that
-# name-addressed comms delivery cannot tell apart. Refuse with a distinct code (76,
-# after 75 broker-absent) so a cutover wave script can branch on "seat still on legacy
-# socket" vs "already running" (0) vs "broker absent" (75). Stopping the legacy session
-# belongs to the cutover procedure, never to this launcher.
-if [ -n "$MOSAIC_TMUX_SOCKET" ] && tmux has-session -t "=${AGENT_NAME}" 2>/dev/null; then
-  echo "[fleet] FAIL_LAUNCH seat-on-legacy-socket: session '${AGENT_NAME}' exists on the DEFAULT tmux socket; stop it before launching on '${MOSAIC_TMUX_SOCKET}'." >&2
-  exit 76
-fi
-
 if _tmux has-session -t "=${AGENT_NAME}:0.0" 2>/dev/null; then
   echo "Mosaic agent session already running: $AGENT_NAME on socket ${MOSAIC_TMUX_SOCKET:-(default)}"
   exit 0
@@ -432,22 +421,9 @@ if [ "$MOSAIC_AGENT_RUNTIME" = claude ]; then
     echo "WARNING: could not pre-trust workdir for claude agent $AGENT_NAME" >&2
 fi
 
-# #1408 hazard: prefer the seat's own launch.sh when the brain provides one. It is the
+LAUNCH_COMMAND=(mosaic yolo "$MOSAIC_AGENT_RUNTIME")
-# path that binds the auth profile (CLAUDE_SECURESTORAGE_CONFIG_DIR) and seeds the seat
+if [ -n "$MOSAIC_AGENT_MODEL" ]; then LAUNCH_COMMAND+=(--model "$MOSAIC_AGENT_MODEL"); fi
-# config; `mosaic yolo` relocates CLAUDE_CONFIG_DIR to the seat dir (launch.ts
+if [ -n "$MOSAIC_AGENT_REASONING" ]; then LAUNCH_COMMAND+=(--thinking "$MOSAIC_AGENT_REASONING"); fi
-# activeSeatDir/harnessEnv) but performs neither, so a yolo-launched seat points its
-# config at a directory holding no credentials. The env -i allowlist below still
-# applies: launch.sh reads its own launch.env.
-SEAT_LAUNCH="${BRAIN_HOME}/fleet/agents/${AGENT_NAME}/launch.sh"
-if [ -x "$SEAT_LAUNCH" ]; then
-  LAUNCH_COMMAND=("$SEAT_LAUNCH")
-  echo "[fleet] launch path: seat launch.sh ($SEAT_LAUNCH)"
-else
-  LAUNCH_COMMAND=(mosaic yolo "$MOSAIC_AGENT_RUNTIME")
-  if [ -n "$MOSAIC_AGENT_MODEL" ]; then LAUNCH_COMMAND+=(--model "$MOSAIC_AGENT_MODEL"); fi
-  if [ -n "$MOSAIC_AGENT_REASONING" ]; then LAUNCH_COMMAND+=(--thinking "$MOSAIC_AGENT_REASONING"); fi
-  echo "[fleet] launch path: mosaic yolo (no executable seat launch.sh)"
-fi
 
 # The tmux holder owns a named server. Explicitly clear the pane environment
 # so server/session variables cannot cross the launch boundary; retain only

packages/mosaic/framework/tools/fleet/test-agent-session-legacy-socket-guard.sh

@@ -1,216 +0,0 @@
-#!/usr/bin/env bash
-# CI-fit regression suite for the #1408 legacy-socket guard in
-# start-agent-session.sh.
-#
-# Same hermeticity contract as test-agent-session-broker-preflight.sh: a fake
-# tmux on PATH that scripts its own answers, a real unix socket in a tmpdir so
-# the broker preflight passes, env -i with a fake HOME. No case depends on host
-# state.
-#
-# The failure this suite is written down to catch: during a socket cutover a
-# seat's session still lives on the DEFAULT tmux socket while the launcher
-# targets the named one. The declared-socket has-session check cannot see the
-# legacy session (measured 2026-08-24: rc=1, script proceeds), so launch
-# creates a same-name duplicate — and comms delivery, which addresses sessions
-# by NAME, cannot tell the two apart. The guard refuses with its own code
-# (exit 76, after 75 broker-absent) BEFORE any tmux mutation.
-#
-# Cases:
-#   1. legacy session present -> exit 76, message names seat-on-legacy-socket
-#      + both sockets' roles, and NO tmux session was created.
-#   2. legacy session absent -> proceeds PAST the guard (the run then stops at
-#      a later precondition; asserted: exit != 76, stderr lacks the guard's
-#      code, proving the guard was not the refusal).
-#   3. MOSAIC_TMUX_SOCKET empty (single-socket host) -> guard is inert: the
-#      default-socket probe must not fire at all.
-#
-# Sabotage control, run by the developer (not in-suite): remove the guard
-# block, re-run — case 1 fails (exit is not 76), cases 2-3 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-legacy-socket-guard}"
-FAKE_HOME="$WORK_DIR/home"
-BIN_DIR="$WORK_DIR/bin"
-SOCK_DIR="$WORK_DIR/sockets"
-LOG_FILE="$WORK_DIR/tmux-calls.log"
-LEGACY_FLAG="$WORK_DIR/legacy-session-present"
-
-rm -rf "$WORK_DIR"
-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/lsguard-test.env.generated" <<'ENVEOF'
-MOSAIC_AGENT_NAME=lsguard-test
-MOSAIC_GIT_IDENTITY=lsguard-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/lsguard-test.env.generated"
-
-# A projection with NO named socket, for case 3. Same file minus the socket line.
-sed '/^MOSAIC_TMUX_SOCKET=/d; s/lsguard-test/lsguard-nosock/' \
-  "$FAKE_HOME/.config/mosaic/fleet/agents/lsguard-test.env.generated" \
-  > "$FAKE_HOME/.config/mosaic/fleet/agents/lsguard-nosock.env.generated"
-echo 'MOSAIC_TMUX_SOCKET=' >> "$FAKE_HOME/.config/mosaic/fleet/agents/lsguard-nosock.env.generated"
-chmod 600 "$FAKE_HOME/.config/mosaic/fleet/agents/lsguard-nosock.env.generated"
-
-# Ownership identity the launcher validates before anything touches tmux:
-# a 0600 uuid file plus a tmux global environment that matches it exactly.
-mkdir -p "$FAKE_HOME/.config/mosaic/fleet/run"
-chmod 750 "$FAKE_HOME/.config/mosaic/fleet/run"
-OWNER_UUID="aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
-printf '%s' "$OWNER_UUID" > "$FAKE_HOME/.config/mosaic/fleet/run/holder-owner"
-chmod 600 "$FAKE_HOME/.config/mosaic/fleet/run/holder-owner"
-
-# The exact env block assert_owned_tmux_server expects; the socket value differs
-# per case, so cases rewrite it via write_tmux_env before each run.
-write_tmux_env() {
-  printf '%s\n' \
-    "HOME=$FAKE_HOME" \
-    'PATH=/usr/bin:/bin' \
-    "PWD=$FAKE_HOME" \
-    "MOSAIC_FLEET_OWNER=$OWNER_UUID" \
-    'MOSAIC_TMUX_HOLDER=_holder' \
-    "MOSAIC_TMUX_SOCKET=$1" > "$WORK_DIR/tmux-env"
-}
-
-# ─── Fake tmux ──────────────────────────────────────────────────────────────
-# Scripted answers: a DEFAULT-socket has-session (argv carries no -L) answers
-# by the flag file; every named-socket call succeeds (holder present, no
-# existing session is fine for these cases since refusal happens first).
-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
-if [[ "\$*" == *show-environment* ]]; then
-  cat "$WORK_DIR/tmux-env"
-  exit 0
-fi
-if [[ "\$*" == *has-session* ]]; then
-  # holder session always present; the seat's DEFAULT-socket presence is the
-  # flag file; the seat is never already-running on the NAMED socket.
-  [[ "\$*" == *_holder* ]] && exit 0
-  if [[ "\$1" == "-L" ]]; then exit 1; fi
-  [[ -e "$LEGACY_FLAG" ]] && exit 0 || exit 1
-fi
-exit 0
-SH
-chmod +x "$BIN_DIR/tmux"
-
-for bin in mosaic pi claude; do
-  printf '#!/usr/bin/env bash\nexit 0\n' > "$BIN_DIR/$bin"
-  chmod +x "$BIN_DIR/$bin"
-done
-
-# Real socket so the #1292 broker preflight passes and the run reaches the guard.
-# Same idiom as the broker-preflight suite: AF_UNIX binds cap at 108 path bytes,
-# so the socket lives at a SHORT /tmp path held by a detached python holder (a
-# foreground bind would close on exit; -S on a closed-but-unlinked path fails).
-LIVE_SOCK="/tmp/mosaic-lsguard-$RANDOM-$$.sock"
-trap 'rm -f "$LIVE_SOCK"' EXIT
-rm -f "$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" &
-for _ in $(seq 1 50); do
-  [ -S "$LIVE_SOCK" ] && break
-  sleep 0.1
-done
-[ -S "$LIVE_SOCK" ] || { echo "FAIL: could not create live socket" >&2; exit 1; }
-
-run_session_script() {
-  local agent="$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" \
-      MOSAIC_LEASE_BROKER_SOCKET="$LIVE_SOCK" \
-      "$@" \
-      bash "$SCRIPT_DIR/start-agent-session.sh" "$agent"
-  )
-}
-
-fail=0
-assert() {
-  local desc="$1" expected="$2" actual="$3"
-  [[ "$expected" == "$actual" ]] || { echo "FAIL: $desc — expected '$expected', got '$actual'" >&2; fail=1; }
-}
-assert_contains() {
-  local desc="$1" haystack="$2" needle="$3"
-  [[ "$haystack" == *"$needle"* ]] || { echo "FAIL: $desc — missing '$needle'" >&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. Legacy session present → exit 76, no tmux mutation. ─────────────────
-write_tmux_env "mosaic-fleet"
-: > "$LOG_FILE"; touch "$LEGACY_FLAG"
-stderr_file="$WORK_DIR/stderr-1.tmp"
-set +e
-run_session_script lsguard-test >/dev/null 2>"$stderr_file"
-rc=$?
-set -e
-err=$(cat "$stderr_file")
-assert "legacy present exit code" "76" "$rc"
-assert_contains "names the failure" "$err" "FAIL_LAUNCH seat-on-legacy-socket"
-assert_contains "names the agent" "$err" "lsguard-test"
-assert_contains "names the target socket" "$err" "mosaic-fleet"
-assert_not_contains "no session created" "$(cat "$LOG_FILE")" "TMUX-NEW-SESSION-INVOKED"
-
-# ─── 2. Legacy session absent → guard is not the refusal. ───────────────────
-write_tmux_env "mosaic-fleet"
-: > "$LOG_FILE"; rm -f "$LEGACY_FLAG"
-stderr_file="$WORK_DIR/stderr-2.tmp"
-set +e
-run_session_script lsguard-test >/dev/null 2>"$stderr_file"
-rc=$?
-set -e
-err=$(cat "$stderr_file")
-if [[ "$rc" == "76" ]]; then
-  echo "FAIL: legacy absent must not exit 76" >&2; fail=1
-fi
-assert_not_contains "guard code absent from stderr" "$err" "seat-on-legacy-socket"
-
-# ─── 3. Empty MOSAIC_TMUX_SOCKET → guard inert, no default-socket probe. ────
-write_tmux_env ""
-: > "$LOG_FILE"; touch "$LEGACY_FLAG"   # even with a legacy session present
-stderr_file="$WORK_DIR/stderr-3.tmp"
-set +e
-run_session_script lsguard-nosock >/dev/null 2>"$stderr_file"
-rc=$?
-set -e
-err=$(cat "$stderr_file")
-if [[ "$rc" == "76" ]]; then
-  echo "FAIL: empty socket must never exit 76 (single-socket host)" >&2; fail=1
-fi
-assert_not_contains "guard code absent on single-socket host" "$err" "seat-on-legacy-socket"
-
-rm -f "$LEGACY_FLAG"
-if [[ "$fail" -ne 0 ]]; then
-  echo "start-agent-session legacy-socket guard regression FAILED" >&2
-  exit 1
-fi
-echo "start-agent-session legacy-socket guard regression passed"

packages/mosaic/framework/tools/git/ci-queue-wait.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # ci-queue-wait.sh - Wait until project CI queue is clear (no running/queued pipeline on branch head)
-# Usage: ci-queue-wait.sh [-B branch] [-t timeout_sec] [-i interval_sec] [--purpose push|merge] [--require-status] [--no-ci-expected]
+# Usage: ci-queue-wait.sh [-B branch] [-t timeout_sec] [-i interval_sec] [--purpose push|merge] [--require-status]
 
 set -euo pipefail
 
@@ -14,11 +14,10 @@ TIMEOUT_SEC=900
 INTERVAL_SEC=15
 PURPOSE="merge"
 REQUIRE_STATUS=0
-NO_CI_EXPECTED=0
 
 usage() {
     cat <<EOF
-Usage: $(basename "$0") [-B branch] [-R owner/repo] [--sha full-40] [-t timeout_sec] [-i interval_sec] [--purpose push|merge] [--require-status] [--no-ci-expected]
+Usage: $(basename "$0") [-B branch] [-R owner/repo] [--sha full-40] [-t timeout_sec] [-i interval_sec] [--purpose push|merge] [--require-status]
 
 Options:
   -B, --branch BRANCH      Branch head to inspect (default: current branch)
@@ -28,7 +27,6 @@ Options:
   -i, --interval SECONDS   Poll interval in seconds (default: 15)
       --purpose VALUE      Log context: push|merge (default: merge)
       --require-status     Fail if no CI status contexts are present
-      --no-ci-expected     Assert this repository has no CI configured: a merge guard on a zero-context head becomes queue-clear (requires the acting token to hold repository admin); refused with exit 78 when MOSAIC_GIT_IDENTITY is unset or empty
   -h, --help               Show this help
 
 Examples:
@@ -177,50 +175,6 @@ PY
     return 0
 }
 
-# Durable audit record for an explicit no-CI assertion event (granted or
-# refused). Same JSONL sink and field shape as record_cannot_assert so one
-# reader covers all three outcomes; the outcome value distinguishes them.
-# rc 70 on an unwritable sink: a merge pass that cannot be audited must not
-# be reachable, mirroring record_cannot_assert's refusal of a degraded pass.
-record_assertion_event() {
-    local outcome="$1" reason="$2" asserted_by="$3"
-    local audit_log="${MOSAIC_CI_QUEUE_AUDIT_LOG:-${XDG_STATE_HOME:-${HOME:-}/.local/state}/mosaic/audit/ci-queue-wait.jsonl}"
-
-    if [[ -z "$audit_log" ]] || ! mkdir -p "$(dirname "$audit_log")"; then
-        echo "Error: could not write ${outcome} audit record (audit directory unavailable at ${audit_log})." >&2
-        return 70
-    fi
-
-    if ! python3 - "$audit_log" "$outcome" "$reason" "$asserted_by" "${PLATFORM:-unknown}" "$PURPOSE" "${BRANCH:-unknown}" "${OWNER:-unknown}/${REPO:-unknown}" <<'PY'
-import datetime
-import json
-import os
-import sys
-
-path, outcome, reason, asserted_by, platform, purpose, branch, repo = sys.argv[1:]
-record = {
-    "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
-    "outcome": outcome,
-    "reason": reason,
-    "platform": platform,
-    "purpose": purpose,
-    "branch": branch,
-    "repo": repo,
-    "asserted_by": asserted_by,
-}
-fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
-try:
-    os.write(fd, (json.dumps(record, separators=(",", ":")) + "\n").encode())
-finally:
-    os.close(fd)
-PY
-    then
-        echo "Error: could not write ${outcome} audit record at ${audit_log}; refusing to proceed unaudited." >&2
-        return 70
-    fi
-    return 0
-}
-
 github_get_branch_head_sha() {
     local owner="$1"
     local repo="$2"
@@ -228,24 +182,6 @@ github_get_branch_head_sha() {
     gh api "repos/${owner}/${repo}/branches/${branch}" --jq '.commit.sha'
 }
 
-# Repository-admin state for the acting credential, GitHub flavor. The
-# repository object's permissions.admin is the field; read through the same
-# gh CLI the guard already authenticates with. rc 0 = admin, 1 = not admin
-# (or field absent), 2 = indeterminate (transport/API failure).
-github_repo_admin_state() {
-    local owner="$1"
-    local repo="$2"
-    local perm
-    if ! perm=$(gh api "repos/${owner}/${repo}" --jq '.permissions.admin' 2>/dev/null); then
-        return 2
-    fi
-    case "$perm" in
-        true)  return 0 ;;
-        false|null|"") return 1 ;;
-        *)     return 2 ;;
-    esac
-}
-
 github_get_commit_status_json() {
     local owner="$1"
     local repo="$2"
@@ -370,41 +306,6 @@ gitea_get_commit_status_json() {
     curl -fsSL -H "User-Agent: curl/8" -H "Authorization: token ${token}" "$url"
 }
 
-# Repository-admin state for the acting credential, Gitea flavor. The guard's
-# existing fetches (branch head, combined status) carry no permissions object
-# (measured: neither response includes one), so the elevation check reads the
-# repository object's permissions.admin, the one documented carrier of that
-# field. rc 0 = admin, 1 = not admin (or field absent), 2 = indeterminate
-# (non-200 or unparseable).
-gitea_repo_admin_state() {
-    local host="$1"
-    local repo="$2"
-    local token="$3"
-    local url="https://${host}/api/v1/repos/${repo}"
-    local resp code body
-    resp=$(curl -sS -H "User-Agent: curl/8" -H "Authorization: token ${token}" -w $'\n%{http_code}' "$url") || return 2
-    code="${resp##*$'\n'}"
-    body="${resp%$'\n'*}"
-    if [[ "$code" != "200" ]]; then
-        return 2
-    fi
-    printf '%s' "$body" | python3 -c '
-import json
-import sys
-
-try:
-    payload = json.load(sys.stdin)
-except Exception:
-    raise SystemExit(2)
-if not isinstance(payload, dict):
-    raise SystemExit(2)
-permissions = payload.get("permissions")
-if not isinstance(permissions, dict) or permissions.get("admin") is not True:
-    raise SystemExit(1)
-raise SystemExit(0)
-'
-}
-
 while [[ $# -gt 0 ]]; do
     case "$1" in
         -B|--branch)
@@ -435,10 +336,6 @@ while [[ $# -gt 0 ]]; do
             REQUIRE_STATUS=1
             shift
             ;;
-        --no-ci-expected)
-            NO_CI_EXPECTED=1
-            shift
-            ;;
         -h|--help)
             usage
             exit 0
@@ -468,10 +365,6 @@ if [[ "$PURPOSE" != "push" && "$PURPOSE" != "merge" ]]; then
     echo "Error: --purpose must be push or merge." >&2
     exit 1
 fi
-if [[ "$NO_CI_EXPECTED" -eq 1 && "$REQUIRE_STATUS" -eq 1 ]]; then
-    echo "Error: --no-ci-expected and --require-status contradict each other: one asserts the repository has no CI, the other demands status contexts. Pass at most one." >&2
-    exit 1
-fi
 
 OWNER="unknown"
 REPO="unknown"
@@ -503,28 +396,6 @@ if [[ -z "$BRANCH" ]]; then
     fi
 fi
 
-# T51 WP5b (spec 4.1, review ruling C4/F8): the declaration adds ROUTE CONTEXT only.
-# Branch-selection semantics are UNCHANGED — the guard keeps inspecting the
-# exact head above. No declaration dependency gates the wait (4.3/DR2 R9:
-# blocking here adds a blocker with no safety gain); absence is silent.
-# shellcheck source=packages/mosaic/framework/tools/git/ci-queue-wait.sh
-if git rev-parse --show-toplevel >/dev/null 2>&1 \
-   && [ -f "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/repo-decl.sh" ]; then
-    source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/repo-decl.sh"
-    repo_decl_load
-    if [[ "$DECL_STATE" == invalid ]]; then
-        repo_decl_report_invalid
-    elif [[ "$DECL_STATE" == valid && "$DECL_SCHEMA" == 2 ]]; then
-        route="feature"
-        if [[ "$BRANCH" == "$DECL_TRUNK" ]]; then
-            route="trunk (integration head)"
-        elif [[ "$BRANCH" == "$DECL_RELEASE" ]]; then
-            route="release branch"
-        fi
-        echo "repo-decl: route context flow=$DECL_FLOW trunk=$DECL_TRUNK release=$DECL_RELEASE; guarded head '$BRANCH' is a $route head (spec 4.1)" >&2
-    fi
-fi
-
 if [[ "$PLATFORM" == "github" ]]; then
     if ! command -v gh >/dev/null 2>&1; then
         record_cannot_assert "github-cli-unavailable"
@@ -613,48 +484,6 @@ while true; do
                 echo "[ci-queue-wait] queue-clear state=no-status purpose=push branch=${BRANCH}; no queued or running CI."
                 exit 0
             fi
-            if [[ "$NO_CI_EXPECTED" -eq 1 ]]; then
-                # Explicit, elevated, audit-visible assertion that this
-                # repository has no CI to wait on. The zero-context case is
-                # the ONLY state the flag reclassifies: a pending or failed
-                # context still holds or fails exactly as without it, and a
-                # non-admin token is refused rather than trusted.
-                # The assertion must name an asserting identity: "unknown"
-                # attributes nothing, so a caller with MOSAIC_GIT_IDENTITY
-                # unset or empty is refused (exit 78) BEFORE the permission
-                # lookup -- an unattributable caller never triggers that
-                # network call.
-                if [[ -z "${MOSAIC_GIT_IDENTITY:-}" ]]; then
-                    record_assertion_event "ASSERTION_UNATTRIBUTABLE" "actor-unattributable" "unknown" \
-                        || echo "Warning: could not write the ASSERTION_UNATTRIBUTABLE audit record; the refusal itself stands." >&2
-                    echo "Error: ASSERTION_UNATTRIBUTABLE state=no-status purpose=merge asserted-by=unknown reason=no-ci-expected branch=${BRANCH}; --no-ci-expected requires MOSAIC_GIT_IDENTITY to name the asserting identity and it is unset or empty (exit 78)." >&2
-                    exit 78
-                fi
-                ASSERTED_BY="${MOSAIC_GIT_IDENTITY}"
-                ADMIN_STATE=2
-                if [[ "$PLATFORM" == "github" ]]; then
-                    if github_repo_admin_state "$OWNER" "$REPO"; then ADMIN_STATE=0; else ADMIN_STATE=$?; fi
-                else
-                    if gitea_repo_admin_state "$HOST" "$OWNER/$REPO" "$TOKEN"; then ADMIN_STATE=0; else ADMIN_STATE=$?; fi
-                fi
-                case "$ADMIN_STATE" in
-                    0)
-                        record_assertion_event "NO_CI_ASSERTED" "no-ci-expected" "$ASSERTED_BY" || exit $?
-                        echo "[ci-queue-wait] queue-clear state=no-status purpose=merge asserted-by=${ASSERTED_BY} reason=no-ci-expected branch=${BRANCH}"
-                        exit 0
-                        ;;
-                    1)
-                        record_assertion_event "ASSERTION_REFUSED" "actor-not-repo-admin" "$ASSERTED_BY" \
-                            || echo "Warning: could not write the ASSERTION_REFUSED audit record; the refusal itself stands." >&2
-                        echo "Error: ASSERTION_REFUSED state=no-status purpose=merge asserted-by=${ASSERTED_BY} reason=no-ci-expected branch=${BRANCH}; --no-ci-expected requires repository admin and the acting token is not an admin of ${OWNER}/${REPO} (exit 77)." >&2
-                        exit 77
-                        ;;
-                    *)
-                        record_cannot_assert "repo-permissions-unavailable"
-                        exit $?
-                        ;;
-                esac
-            fi
             echo "Error: ASSERTED_NOT_READY state=no-status purpose=${PURPOSE} branch=${BRANCH}." >&2
             exit 3
             ;;

packages/mosaic/framework/tools/git/mosaic-worktree.sh

@@ -192,47 +192,6 @@ cmd_new() {
   local path; path="$(derive_path "$branch")"
   assert_not_home "$path"
 
-  # T51 WP5b (spec 4.4 staged rule + 4.5 advisory policy): placement stays
-  # DERIVED; the declaration never moves the worktree. An INVALID declaration
-  # fails branch-creation loud (a broken structure file must not ride a new
-  # branch); an absent one warns (rollout window, Q-C); a valid one contributes
-  # policy ADVICE only. The advisory worktree_root comparison runs only when
-  # MOSAIC_HOST_ROOT is set (1.2a: warn-and-omit for advisory display).
-  # shellcheck source=packages/mosaic/framework/tools/git/repo-decl.sh
-  _rd="$(cd "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")" && pwd)/repo-decl.sh"
-if [ -f ""$_rd"" ]; then
-    source ""$_rd""
-    repo_decl_load
-else
-    DECL_STATE=absent; DECL_SCHEMA=""
-    repo_decl_warn() { printf 'repo-decl: %s\n' "$*" >&2; }
-      repo_decl_report_invalid() { :; }
-    repo_decl_warn_absent_reversible() { :; }
-    repo_decl_warn_absent_irreversible() { :; }
-    repo_decl_remote_matches() { return 0; }
-    repo_decl_check_transition() { return 2; }
-fi
-  case "$DECL_STATE" in
-    invalid)
-      repo_decl_report_invalid
-      die "worktree branch-creation refused: the structure declaration is invalid (spec 4.4 — fix it before creating branches)"
-      ;;
-    absent)
-      repo_decl_warn_absent_irreversible "worktree branch-creation"
-      ;;
-    valid)
-      if [ "$DECL_SCHEMA" = 2 ] && [ "$DECL_POLICY" = "orchestrator-precreated" ]; then
-        echo "repo-decl: worktree_policy=orchestrator-precreated (TRANSITIONAL, spec 4.5): tasking pre-creates worktrees; creating one directly is the interim path until the J3/#1174 amendment unblocks the wrapper consumer." >&2
-      fi
-      if [ -n "${MOSAIC_HOST_ROOT:-}" ] && [ -n "$DECL_WT_ROOT" ]; then
-        dwt="$(repo_decl_path "$DECL_WT_ROOT" 2>/dev/null || true)"
-        if [ -n "$dwt" ] && [ "${dwt%/}" != "${WT_ROOT%/}" ]; then
-          echo "repo-decl: derived root $WT_ROOT diverges from the declared advisory worktree_root $dwt (advisory per spec 4.1/5.2 — placement stays derived)" >&2
-        fi
-      fi
-      ;;
-  esac
-
   if [ -e "$path" ]; then
     echo "exists: $path"
     echo "(already checked out — reuse it, or 'rm' it first)"

packages/mosaic/framework/tools/git/pr-create.sh

@@ -19,41 +19,6 @@ ISSUE=""
 
 # get_remote_host, get_gitea_token, get_repo_info, and get_gitea_repo_args are provided by detect-platform.sh
 
-gitea_default_branch() {
-    # Forge default branch for the current repo (T51-P2 WP5a / spec E4): the
-    # API fallback must not guess a base. Empty output or any lookup failure
-    # returns nonzero so the caller fails loud instead of mistargeting a PR.
-    local host repo token url body branch
-    host=$(get_remote_host) || return 1
-    repo=$(get_repo_info) || return 1
-    token=$(get_gitea_token "$host") || return 1
-    url="https://${host}/api/v1/repos/${repo}"
-    # Fetch and parse as separate steps (T51P2WP5AR B2): a piped
-    # `curl | python` reports only python's status, so an HTTP failure that
-    # still emits parseable JSON would masquerade as success. curl's own
-    # exit status is authoritative here.
-    if ! body=$(curl -fsS \
-        -H "User-Agent: curl/8" \
-        -H "Authorization: token ${token}" \
-        "$url" 2>/dev/null); then
-        return 1
-    fi
-    # A valid base is a NONBLANK JSON STRING (T51P2WP5AR B3): null, numbers,
-    # and whitespace-only values are failed resolution, never a POSTed base.
-    branch=$(printf '%s' "$body" | python3 -c '
-import json, sys
-try:
-    value = json.load(sys.stdin).get("default_branch")
-except Exception:
-    sys.exit(1)
-if not isinstance(value, str) or not value.strip():
-    sys.exit(1)
-print(value.strip())
-' 2>/dev/null) || return 1
-    [[ -n "$branch" ]] || return 1
-    printf '%s' "$branch"
-}
-
 gitea_pr_create_api() {
     local host repo token url payload
     host=$(get_remote_host) || {
@@ -73,28 +38,14 @@ gitea_pr_create_api() {
         echo "Warning: API fallback applies title/body/head/base only; labels/milestone/draft require authenticated tea setup." >&2
     fi
 
-    # Base resolution (spec E4): an explicit -B always wins; with none, the
+    payload=$(TITLE="$TITLE" BODY="$BODY" HEAD_BRANCH="$HEAD_BRANCH" BASE_BRANCH="$BASE_BRANCH" python3 - <<'PY'
-    # forge default branch is resolved from the provider API -- never the
-    # historical "main" literal, which mistargeted every fallback PR on
-    # repos whose trunk is not main (e.g. mosaicstack/stack -> next).
-    local api_base=""
-    if [[ -n "$EFFECTIVE_BASE" ]]; then
-        api_base="$EFFECTIVE_BASE"
-    else
-        api_base=$(gitea_default_branch) || {
-            echo "Error: could not resolve the forge default branch for the API-fallback base; pass -B <branch> explicitly" >&2
-            return 1
-        }
-    fi
-
-    payload=$(TITLE="$TITLE" BODY="$BODY" HEAD_BRANCH="$HEAD_BRANCH" API_BASE="$api_base" python3 - <<'PY'
 import json
 import os
 
 payload = {
     "title": os.environ["TITLE"],
     "head": os.environ["HEAD_BRANCH"],
-    "base": os.environ["API_BASE"],
+    "base": os.environ["BASE_BRANCH"] or "main",
 }
 body = os.environ.get("BODY", "")
 if body:
@@ -121,7 +72,7 @@ Create a pull request on the current repository (Gitea or GitHub).
 Options:
     -t, --title TITLE       PR title (required, or use --issue)
     -b, --body BODY         PR description/body
-    -B, --base BRANCH       Base branch to merge into (default: the forge repository's default branch)
+    -B, --base BRANCH       Base branch to merge into (default: main/master)
     -H, --head BRANCH       Head branch with changes (default: current branch)
     -l, --labels LABELS     Comma-separated labels
     -m, --milestone NAME    Milestone name
@@ -198,52 +149,6 @@ if [[ -z "$HEAD_BRANCH" ]]; then
     HEAD_BRANCH=$(git branch --show-current)
 fi
 
-# T51 WP5b: declaration-driven base resolution (spec 4.1). Precedence:
-#   explicit -B  -> validated as an ALLOWED transition (4.2: a flag is input,
-#                    not authority) when a consumable declaration exists
-#   declared trunk (v2 declarations only) -> used directly
-#   legacy        -> WP5a forge-default floor (unmanaged/absent/v1, 4.3)
-# shellcheck source=packages/mosaic/framework/tools/git/repo-decl.sh
-if [ -f "$SCRIPT_DIR/repo-decl.sh" ]; then
-    source "$SCRIPT_DIR/repo-decl.sh"
-    repo_decl_load
-else
-    DECL_STATE=absent; DECL_SCHEMA=""
-    repo_decl_warn() { printf 'repo-decl: %s\n' "$*" >&2; }
-    repo_decl_report_invalid() { :; }
-    repo_decl_warn_absent_reversible() { :; }
-    repo_decl_warn_absent_irreversible() { :; }
-    repo_decl_remote_matches() { return 0; }
-    repo_decl_check_transition() { return 2; }
-fi
-EFFECTIVE_BASE="$BASE_BRANCH"
-case "$DECL_STATE" in
-    invalid) repo_decl_report_invalid ;;
-esac
-if [[ "$DECL_STATE" == valid && "$DECL_SCHEMA" != 2 ]]; then
-    repo_decl_warn "declaration is v$DECL_SCHEMA — carries no consumable flow/trunk fields; legacy behavior"
-fi
-if [[ "$DECL_STATE" == valid && "$DECL_SCHEMA" == 2 ]]; then
-    # Write path: a normalized-remote mismatch refuses (spec 5.3).
-    if ! repo_decl_remote_matches; then
-        echo "Error: origin remote does not match the declared canonical_remote (spec 5.3, write path) — refusing to create a PR against the wrong forge. Fix the origin remote or the declaration." >&2
-        exit 1
-    fi
-    if [[ -n "$BASE_BRANCH" ]]; then
-        trc=0
-        repo_decl_check_transition "$HEAD_BRANCH" "$BASE_BRANCH" || trc=$?
-        if [[ "$trc" == 1 ]]; then
-            echo "Error: -B '$BASE_BRANCH' is not an allowed transition for head '$HEAD_BRANCH' under the declared flow (spec 4.2). The declaration governs; supply an allowed base." >&2
-            exit 1
-        fi
-        # trc 2 cannot happen here (state=valid): 0 = allowed
-    else
-        EFFECTIVE_BASE="$DECL_TRUNK"
-    fi
-elif [[ -z "$BASE_BRANCH" ]]; then
-    repo_decl_warn_absent_reversible "pr-create"
-fi
-
 # Add issue reference to body if provided
 if [[ -n "$ISSUE" ]]; then
     if [[ -n "$BODY" ]]; then
@@ -261,7 +166,7 @@ case "$PLATFORM" in
     github)
         CMD=(gh pr create --title "$TITLE")
         [[ -n "$BODY" ]] && CMD+=(--body "$BODY")
-        [[ -n "$EFFECTIVE_BASE" ]] && CMD+=(--base "$EFFECTIVE_BASE")
+        [[ -n "$BASE_BRANCH" ]] && CMD+=(--base "$BASE_BRANCH")
         [[ -n "$HEAD_BRANCH" ]] && CMD+=(--head "$HEAD_BRANCH")
         [[ -n "$LABELS" ]] && CMD+=(--label "$LABELS")
         [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
@@ -286,7 +191,7 @@ case "$PLATFORM" in
         REPO_ARGS=(--repo "$REPO_SLUG" --login "$GITEA_LOGIN_NAME")
         CMD=(tea pr create "${REPO_ARGS[@]}" --title "$TITLE")
         [[ -n "$BODY" ]] && CMD+=(--description "$BODY")
-        [[ -n "$EFFECTIVE_BASE" ]] && CMD+=(--base "$EFFECTIVE_BASE")
+        [[ -n "$BASE_BRANCH" ]] && CMD+=(--base "$BASE_BRANCH")
         [[ -n "$HEAD_BRANCH" ]] && CMD+=(--head "$HEAD_BRANCH")
 
         # Handle labels for tea

packages/mosaic/framework/tools/git/pr-merge.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # pr-merge.sh - Merge pull requests on Gitea or GitHub
-# Usage: pr-merge.sh -n PR_NUMBER [-m squash] [-d] [--expect-head SHA] [--no-ci-expected] [--co-author-trailers --escalate-to PRINCIPAL]
+# Usage: pr-merge.sh -n PR_NUMBER [-m squash] [-d] [--expect-head SHA] [--co-author-trailers --escalate-to PRINCIPAL]
 
 set -euo pipefail
 
@@ -16,7 +16,6 @@ DRY_RUN=false
 EXPECT_HEAD=""
 CO_AUTHOR_TRAILERS=false
 ESCALATE_TO=""
-NO_CI_EXPECTED=false
 
 usage() {
     cat <<EOF
@@ -30,7 +29,6 @@ Options:
     -d, --delete-branch     Delete the head branch after merge
         --dry-run           Run metadata/login preflight without merging
         --expect-head SHA   Refuse unless the PR head matches this full commit SHA
-        --no-ci-expected    Assert the target repository has no CI: forward --no-ci-expected to the queue guard (requires repository admin)
         --co-author-trailers Build verified trailers from linked PR commit authors
         --escalate-to NAME  Named principal for an unresolved-author BLOCK
     -h, --help              Show this help message
@@ -72,10 +70,6 @@ while [[ $# -gt 0 ]]; do
             EXPECT_HEAD="$2"
             shift 2
             ;;
-        --no-ci-expected)
-            NO_CI_EXPECTED=true
-            shift
-            ;;
         --co-author-trailers)
             CO_AUTHOR_TRAILERS=true
             shift
@@ -137,44 +131,9 @@ HEAD_REPO="$(printf '%s' "$PR_METADATA" | python3 -c 'import json, sys; value=js
 BASE_REPO="$(printf '%s' "$PR_METADATA" | python3 -c 'import json, sys; value=json.load(sys.stdin).get("baseRepository") or ""; print((value.get("nameWithOwner") or value.get("full_name") or "") if isinstance(value, dict) else str(value).strip())')"
 PR_TITLE="$(printf '%s' "$PR_METADATA" | python3 -c 'import json, sys; print((json.load(sys.stdin).get("title") or "").strip())')"
 PR_AUTHOR="$(printf '%s' "$PR_METADATA" | python3 -c 'import json, sys; value=json.load(sys.stdin).get("author") or ""; print((value.get("login") or "").strip() if isinstance(value, dict) else str(value).strip())')"
-# T51 WP5b: transition validation against the declaration (spec 4.1/4.2).
+if [[ "$BASE_BRANCH" != "main" && "$BASE_BRANCH" != "next" ]]; then
-# Target branches are validated against the declaration, NEVER hardcoded;
+    echo "Error: Mosaic policy allows merges only for PRs targeting 'main' or 'next' (found '$BASE_BRANCH')." >&2
-# the legacy main/next check survives only for undeclared repos during the
+    exit 1
-# rollout window (4.3 irreversible class, loud warning).
-# shellcheck source=packages/mosaic/framework/tools/git/repo-decl.sh
-if [ -f "$SCRIPT_DIR/repo-decl.sh" ]; then
-    source "$SCRIPT_DIR/repo-decl.sh"
-    repo_decl_load
-else
-    DECL_STATE=absent; DECL_SCHEMA=""
-    repo_decl_warn() { printf 'repo-decl: %s\n' "$*" >&2; }
-    repo_decl_report_invalid() { :; }
-    repo_decl_warn_absent_reversible() { :; }
-    repo_decl_warn_absent_irreversible() { :; }
-    repo_decl_remote_matches() { return 0; }
-    repo_decl_check_transition() { return 2; }
-fi
-if [[ "$DECL_STATE" == invalid ]]; then
-    repo_decl_report_invalid
-fi
-if [[ "$DECL_STATE" == valid && "$DECL_SCHEMA" == 2 ]]; then
-    if ! repo_decl_remote_matches; then
-        echo "Error: origin remote does not match the declared canonical_remote (spec 5.3, write path) — refusing to merge against the wrong forge. Fix the origin remote or the declaration." >&2
-        exit 1
-    fi
-    trc=0
-    repo_decl_check_transition "$HEAD_BRANCH" "$BASE_BRANCH" || trc=$?
-    if [[ "$trc" == 1 ]]; then
-        echo "Error: PR '$HEAD_BRANCH' -> '$BASE_BRANCH' is not a declared transition (flow=$DECL_FLOW, trunk=$DECL_TRUNK, release=$DECL_RELEASE; spec 4.2)." >&2
-        exit 1
-    fi
-    echo "repo-decl: transition OK under flow=$DECL_FLOW (trunk=$DECL_TRUNK release=$DECL_RELEASE)" >&2
-else
-    repo_decl_warn_absent_irreversible "pr-merge"
-    if [[ "$BASE_BRANCH" != "main" && "$BASE_BRANCH" != "next" ]]; then
-        echo "Error: Mosaic policy allows merges only for PRs targeting 'main' or 'next' (found '$BASE_BRANCH')." >&2
-        exit 1
-    fi
 fi
 if [[ -z "$HEAD_BRANCH" || -z "$HEAD_REPO" || ! "$HEAD_SHA" =~ ^[0-9a-fA-F]{40}$ ]]; then
     echo "Error: Could not resolve the PR head branch, repository, and full commit SHA for queue inspection." >&2
@@ -195,18 +154,13 @@ if [[ "$DRY_RUN" != true ]]; then
     if [[ -z "$BASE_REPO" ]]; then
         BASE_REPO="$(get_repo_owner)/$(get_repo_name)"
     fi
-    guard_args=(
+    "$SCRIPT_DIR/ci-queue-wait.sh" \
-        --purpose merge
+        --purpose merge \
-        -B "$HEAD_BRANCH"
+        -B "$HEAD_BRANCH" \
-        -R "$BASE_REPO"
+        -R "$BASE_REPO" \
-        --sha "$HEAD_SHA"
+        --sha "$HEAD_SHA" \
-        -t "${MOSAIC_CI_QUEUE_TIMEOUT_SEC:-900}"
+        -t "${MOSAIC_CI_QUEUE_TIMEOUT_SEC:-900}" \
         -i "${MOSAIC_CI_QUEUE_POLL_SEC:-15}"
-    )
-    if [[ "$NO_CI_EXPECTED" == true ]]; then
-        guard_args+=(--no-ci-expected)
-    fi
-    "$SCRIPT_DIR/ci-queue-wait.sh" "${guard_args[@]}"
 fi
 
 PLATFORM=$(detect_platform)

packages/mosaic/framework/tools/git/repo-decl.sh

@@ -1,198 +0,0 @@
-#!/usr/bin/env bash
-# repo-decl.sh — shared .mosaic/repo.json consumption for the git wrappers (T51 WP5b).
-#
-# Spec of record: docs/plans/2026-08-23_repo-structure-declaration.md (brain
-# repo) sections 4 (consumption contract), 5.3 (normalization), 5.4
-# (enforcement points), 1.2a (root anchoring). ALL consumers invoke the SAME
-# WP1 validator (spec 5.1 — no in-process-only parsing of the declaration).
-#
-# Source this file, then call repo_decl_load once. It sets:
-#   DECL_STATE    absent | invalid | valid
-#   DECL_FILE     the declaration path that was inspected
-#   DECL_ERROR    the validator's error line when DECL_STATE=invalid
-#   DECL_TRUNK / DECL_RELEASE / DECL_FLOW / DECL_REMOTE / DECL_POLICY /
-#   DECL_WT_ROOT  / DECL_CLONE   (populated only when DECL_STATE=valid)
-#   DECL_ORIGIN_N the normalized origin URL (when resolvable)
-#
-# Enforcement point 5.4(1): an invalid or unknown-version file counts as
-# ABSENT for behavior, PLUS a loud error naming the file and the validator's
-# key/reason — callers print DECL_ERROR (repo_decl_report_invalid) whenever
-# they loaded something that failed validation; they do not silently ignore a
-# broken file.
-#
-# Absence behavior (4.3) is the CALLER's policy (reversible vs irreversible;
-# managed vs unmanaged — the adoption register is WP6, so during rollout every
-# repo is unmanaged: warn + legacy). Helpers below provide the shared wordings.
-#
-# Root-dependent fields: consumers here read branch/flow/remote/policy only —
-# NO path resolution happens in this library. The one helper that would
-# resolve a host:/ path (repo_decl_path) fails closed while MOSAIC_HOST_ROOT
-# is unset (1.2a: never guess a root), for any future caller that needs it.
-#
-# No output on success; diagnostics go to stderr.
-
-REPO_DECL_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_DECL_VALIDATOR="$REPO_DECL_SCRIPT_DIR/../structure/validate-repo-json.sh"
-
-repo_decl_warn() { printf 'repo-decl: %s\n' "$*" >&2; }
-
-# Load and classify the declaration for the repo containing the current
-# directory. Never fatal — classification is the product.
-repo_decl_load() {
-    DECL_STATE=absent
-    DECL_FILE=""
-    DECL_ERROR=""
-    DECL_SCHEMA=""
-    DECL_TRUNK=""; DECL_RELEASE=""; DECL_FLOW=""; DECL_REMOTE=""
-    DECL_POLICY=""; DECL_WT_ROOT=""; DECL_CLONE=""
-    DECL_ORIGIN_N=""
-
-    local root
-    root="$(git rev-parse --show-toplevel 2>/dev/null)" || {
-        repo_decl_warn "no git repository — declaration consumption skipped"
-        return 0
-    }
-    DECL_FILE="$root/.mosaic/repo.json"
-    [ -f "$DECL_FILE" ] || return 0
-
-    if [ ! -x "$REPO_DECL_VALIDATOR" ] && [ ! -f "$REPO_DECL_VALIDATOR" ]; then
-        # 5.1 mandates the shared validator; a missing validator is an
-        # infrastructure failure, not an absent declaration.
-        repo_decl_warn "validator not found at $REPO_DECL_VALIDATOR — treating declaration as invalid"
-        DECL_STATE=invalid
-        DECL_ERROR="VALIDATION_ERROR validator: the shared validator is missing"
-        return 0
-    fi
-
-    local vout
-    if ! vout="$("$REPO_DECL_VALIDATOR" "$DECL_FILE" --mode display 2>&1)"; then
-        DECL_STATE=invalid
-        DECL_ERROR="$(printf '%s\n' "$vout" | grep -m1 'VALIDATION_ERROR' || printf '%s\n' "$vout" | head -1)"
-        return 0
-    fi
-
-    # Valid: extract the consumed fields via the same python stdlib the
-    # ecosystem already uses. Field-level grammar was the validator's job.
-    eval "$(python3 - "$DECL_FILE" <<'PY'
-import json, sys
-d = json.load(open(sys.argv[1]))
-def q(k):
-    v = d.get(k, "")
-    return v if isinstance(v, str) else ""
-sv = d.get("schema_version", 1)
-print(f"DECL_SCHEMA={sv if isinstance(sv, int) and not isinstance(sv, bool) else 0!r}")
-print(f"DECL_TRUNK={q('integration_trunk')!r}")
-print(f"DECL_RELEASE={q('release_branch')!r}")
-print(f"DECL_FLOW={q('flow')!r}")
-print(f"DECL_REMOTE={q('canonical_remote')!r}")
-print(f"DECL_POLICY={q('worktree_policy')!r}")
-print(f"DECL_WT_ROOT={q('worktree_root')!r}")
-print(f"DECL_CLONE={q('canonical_clone')!r}")
-PY
-)" || {
-        DECL_STATE=invalid
-        DECL_ERROR="VALIDATION_ERROR internal: field extraction failed"
-        return 0
-    }
-    DECL_STATE=valid
-
-    # 5.3: normalize origin once for remote comparisons (read callers warn,
-    # write callers refuse). An unresolvable origin is left empty — callers
-    # treat empty as "cannot compare" and act per their read/write policy.
-    local ourl
-    if ourl="$(git remote get-url origin 2>/dev/null)" && [ -n "$ourl" ]; then
-        DECL_ORIGIN_N="$("$REPO_DECL_VALIDATOR" --normalize-remote "$ourl" 2>/dev/null || true)"
-    fi
-    return 0
-}
-
-# The mandatory loud error for an invalid file (5.4 point 1). Callers invoke
-# this whenever DECL_STATE=invalid, regardless of their proceed/refuse policy.
-repo_decl_report_invalid() {
-    repo_decl_warn "declaration INVALID at $DECL_FILE — $DECL_ERROR"
-    repo_decl_warn "treating the declaration as ABSENT (spec 5.4); legacy behavior follows"
-}
-
-# Shared absence wordings (4.3, rollout window: no adoption register yet, so
-# every repo is unmanaged; warn + legacy per the Q-C ruling).
-repo_decl_warn_absent_reversible() { # $1 = operation name
-    repo_decl_warn "no .mosaic/repo.json — $1 is unmanaged during rollout: legacy behavior, no declaration guarantees (spec 4.3)"
-}
-repo_decl_warn_absent_irreversible() { # $1 = operation name
-    repo_decl_warn "no .mosaic/repo.json — $1 proceeds on LEGACY assumptions during the rollout window; declaration-validated transitions unavailable (spec 4.3)"
-}
-
-# Remote comparison (5.3). rc 0 match/unknown, rc 1 mismatch.
-repo_decl_remote_matches() {
-    [ "$DECL_STATE" = valid ] || return 0
-    [ -n "$DECL_ORIGIN_N" ] && [ -n "$DECL_REMOTE" ] || return 0
-    local want
-    want="$("$REPO_DECL_VALIDATOR" --normalize-remote "$DECL_REMOTE" 2>/dev/null || true)"
-    [ -n "$want" ] || return 0
-    [ "$DECL_ORIGIN_N" = "$want" ]
-}
-
-# Resolve a host:/-anchored declaration path (1.2a). Fails CLOSED while
-# MOSAIC_HOST_ROOT is unset or empty — never guesses a root. No WP5b consumer
-# calls this today; it exists so the first one that needs a path cannot
-# silently guess.
-repo_decl_path() { # $1 = host:/... value; prints the resolved absolute path
-    local v="${1:-}" root="${MOSAIC_HOST_ROOT:-}"
-    case "$v" in
-        host:/*) ;;
-        *) return 1 ;;
-    esac
-    if [ -z "$root" ]; then
-        repo_decl_warn "MOSAIC_HOST_ROOT is unset — refusing to resolve '$v' (spec 1.2a fail-closed; never guess a root)"
-        return 1
-    fi
-    printf '%s/%s\n' "${root%/}" "${v#host:/}"
-}
-
-# Transition validation (4.2: a CLI flag is input, not authority).
-# rc 0 = allowed; rc 1 = forbidden (message on stderr); rc 2 = no valid
-# declaration (caller applies its absence policy).
-#   flow=direct:       base must be the trunk (trunk == release); head must
-#                      differ from it.
-#   flow=trunk-release: feature->trunk allowed; trunk->release allowed (release
-#                      promotion: head IS the trunk); anything else refused —
-#                      feature->release explicitly REJECTED.
-repo_decl_check_transition() { # $1 head, $2 base
-    [ "$DECL_STATE" = valid ] || return 2
-    local head="$1" base="$2"
-    if [ -z "$head" ] || [ -z "$base" ]; then
-        repo_decl_warn "transition check needs a head and a base (got head='$head' base='$base')"
-        return 1
-    fi
-    if [ "$head" = "$base" ]; then
-        repo_decl_warn "forbidden transition: head '$head' equals base '$base'"
-        return 1
-    fi
-    case "$DECL_FLOW" in
-        direct)
-            if [ "$base" = "$DECL_TRUNK" ]; then
-                return 0
-            fi
-            repo_decl_warn "forbidden transition (flow=direct): base must be the trunk '$DECL_TRUNK', got '$base'"
-            return 1
-            ;;
-        trunk-release)
-            if [ "$base" = "$DECL_TRUNK" ] && [ "$head" != "$DECL_TRUNK" ] && [ "$head" != "$DECL_RELEASE" ]; then
-                return 0   # feature -> trunk
-            fi
-            if [ "$head" = "$DECL_TRUNK" ] && [ "$base" = "$DECL_RELEASE" ]; then
-                return 0   # release promotion: trunk -> release
-            fi
-            if [ "$base" = "$DECL_RELEASE" ] && [ "$head" != "$DECL_TRUNK" ]; then
-                repo_decl_warn "forbidden transition (flow=trunk-release): feature->release is REJECTED (head '$head' -> release '$DECL_RELEASE'); promote via $DECL_TRUNK"
-                return 1
-            fi
-            repo_decl_warn "forbidden transition (flow=trunk-release): '$head' -> '$base' is not a declared transition (feature->$DECL_TRUNK or $DECL_TRUNK->$DECL_RELEASE)"
-            return 1
-            ;;
-        *)
-            repo_decl_warn "unknown declared flow '$DECL_FLOW'"
-            return 1
-            ;;
-    esac
-}

packages/mosaic/framework/tools/git/test-ci-queue-wait-no-ci-expected.sh

@@ -1,323 +0,0 @@
-#!/usr/bin/env bash
-# Regression harness for ci-queue-wait.sh's --no-ci-expected assertion:
-# the sanctioned merge path for a repository with no CI configured at all.
-#
-# Zero status contexts ("no-status") stays fail-closed for --purpose merge
-# by default, because at merge time no-status can also mean "CI has not
-# reported yet". --no-ci-expected reclassifies ONLY that zero-context case
-# as queue-clear, and only for a caller whose acting token holds repository
-# admin. This harness pins:
-#   (a) merge + no-status + flag + admin     -> exit 0, audit line + JSONL.
-#   (b) merge + no-status, no flag           -> exit 3, existing text (unchanged).
-#   (c) merge + no-status + flag + non-admin -> exit 77 ASSERTION_REFUSED
-#       (distinct text, exit code NOT 3) + JSONL refusal record.
-#   (c2) flag + admin payload without the admin field -> fail closed as (c).
-#   (d) flag + --require-status              -> usage error, before any network.
-#   (e) flag + a real pending context        -> still holds (timeout 124),
-#       and the admin endpoint is never consulted.
-#   (f) push + no-status, with and without the flag -> push queue-clear
-#       unchanged; no admin consultation on push.
-#   (g) flag + admin lookup unreachable      -> CANNOT_ASSERT hold (75),
-#       not a silent pass and not a refusal.
-#   (h) flag + admin stub + NO MOSAIC_GIT_IDENTITY -> refusal BEFORE
-#       queue-clear and BEFORE the admin lookup: exit 78, no queue-clear
-#       line, an ASSERTION_UNATTRIBUTABLE JSONL record, no repos/ call.
-
-set -u
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/ci-queue-wait-no-ci-expected}"
-REPO_DIR="$WORK_DIR/repo"
-STUB_DIR="$WORK_DIR/stubs"
-URL_LOG="$WORK_DIR/urls.log"
-
-rm -rf "$WORK_DIR"
-mkdir -p "$REPO_DIR" "$STUB_DIR"
-
-git -C "$REPO_DIR" init -q
-git -C "$REPO_DIR" remote add origin https://git.example.test/acme/widgets.git
-
-# Same stub conventions as test-ci-queue-wait-no-status.sh; adds the
-# repository-object endpoint (admin state) selected by MOSAIC_STUB_ADMIN_MODE.
-cat > "$STUB_DIR/curl" <<'SH'
-#!/usr/bin/env bash
-set -euo pipefail
-
-has_w=0
-url=""
-for arg in "$@"; do
-    case "$arg" in
-        -w) has_w=1 ;;
-        http://*|https://*) url="$arg" ;;
-    esac
-done
-printf '%s\n' "$url" >> "${MOSAIC_STUB_URL_LOG:?}"
-
-case "$url" in
-    */branches/*)
-        body='{"commit":{"id":"deadbeefcafef00d0123456789abcdef01234567"}}'
-        if [[ "$has_w" == 1 ]]; then
-            printf '%s\n200' "$body"
-        else
-            printf '%s' "$body"
-        fi
-        exit 0
-        ;;
-    */status)
-        mode="${MOSAIC_STUB_STATUS_MODE:?MOSAIC_STUB_STATUS_MODE not set}"
-        case "$mode" in
-            no-status)   body='{"state":"","statuses":[]}' ;;
-            real-pending) body='{"state":"pending","statuses":[{"context":"ci/woodpecker","status":"running","target_url":""}]}' ;;
-            *) echo "curl stub: unknown status mode=$mode" >&2; exit 2 ;;
-        esac
-        printf '%s' "$body"
-        exit 0
-        ;;
-    */repos/*)
-        mode="${MOSAIC_STUB_ADMIN_MODE:?MOSAIC_STUB_ADMIN_MODE not set}"
-        case "$mode" in
-            admin)          body='{"permissions":{"admin":true,"push":true,"pull":true}}' ;;
-            non-admin)      body='{"permissions":{"admin":false,"push":true,"pull":true}}' ;;
-            no-admin-field) body='{"permissions":{}}' ;;
-            unreachable)    exit 7 ;;
-            *) echo "curl stub: unknown admin mode=$mode" >&2; exit 2 ;;
-        esac
-        if [[ "$has_w" == 1 ]]; then
-            printf '%s\n200' "$body"
-        else
-            printf '%s' "$body"
-        fi
-        exit 0
-        ;;
-    *)
-        echo "curl stub: unrecognized URL: $url" >&2
-        exit 2
-        ;;
-esac
-SH
-chmod +x "$STUB_DIR/curl"
-
-failures=0
-
-run_guard() {
-    local name="$1"; shift
-    (
-        cd "$REPO_DIR" || exit
-        export PATH="$STUB_DIR:$PATH"
-        export MOSAIC_CREDENTIALS_FILE="$WORK_DIR/no-credentials.json"
-        export MOSAIC_CI_QUEUE_AUDIT_LOG="$WORK_DIR/audit-$name.jsonl"
-        export MOSAIC_STUB_URL_LOG="$URL_LOG"
-        export GITEA_TOKEN="stub-token"
-        export GITEA_URL="https://git.example.test"
-        export MOSAIC_GIT_IDENTITY="test-identity"
-        "$SCRIPT_DIR/ci-queue-wait.sh" -B main -t 3 -i 1 "$@"
-    )
-}
-
-# The suite exports test-identity globally, so the unattributable-caller
-# case must strip it from the child environment at invocation with env -u,
-# not rely on the export order.
-run_guard_no_identity() {
-    local name="$1"; shift
-    (
-        cd "$REPO_DIR" || exit
-        export PATH="$STUB_DIR:$PATH"
-        export MOSAIC_CREDENTIALS_FILE="$WORK_DIR/no-credentials.json"
-        export MOSAIC_CI_QUEUE_AUDIT_LOG="$WORK_DIR/audit-$name.jsonl"
-        export MOSAIC_STUB_URL_LOG="$URL_LOG"
-        export GITEA_TOKEN="stub-token"
-        export GITEA_URL="https://git.example.test"
-        export MOSAIC_GIT_IDENTITY="test-identity"
-        env -u MOSAIC_GIT_IDENTITY \
-            "$SCRIPT_DIR/ci-queue-wait.sh" -B main -t 3 -i 1 "$@"
-    )
-}
-
-expect_rc() {
-    local name="$1" want="$2" got="$3"
-    if [[ "$want" == "not3" ]]; then
-        if [[ "$got" -eq 0 || "$got" -eq 3 ]]; then
-            echo "FAIL $name: expected a refusal rc (nonzero, not 3), got $got" >&2
-            failures=$((failures + 1))
-            return 1
-        fi
-    elif [[ "$got" -ne "$want" ]]; then
-        echo "FAIL $name: expected rc=$want, got rc=$got" >&2
-        failures=$((failures + 1))
-        return 1
-    fi
-    return 0
-}
-
-expect_text() {
-    local name="$1" want="$2" output="$3" polarity="${4:-present}"
-    if [[ "$polarity" == "present" && "$output" != *"$want"* ]]; then
-        echo "FAIL $name: output missing '$want'" >&2
-        printf '%s\n' "$output" >&2
-        failures=$((failures + 1))
-    elif [[ "$polarity" == "absent" && "$output" == *"$want"* ]]; then
-        echo "FAIL $name: output unexpectedly contains '$want'" >&2
-        printf '%s\n' "$output" >&2
-        failures=$((failures + 1))
-    fi
-}
-
-repo_root_fetched() {
-    grep -q 'repos/acme/widgets$' "$URL_LOG"
-}
-
-# (a) merge + no-status + flag + admin -> exit 0, assertion line, JSONL record.
-: > "$URL_LOG"
-set +e
-out_a=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=admin run_guard a --purpose merge --no-ci-expected 2>&1)
-rc_a=$?
-set -u
-if expect_rc a 0 "$rc_a"; then
-    expect_text a "queue-clear state=no-status purpose=merge asserted-by=test-identity reason=no-ci-expected branch=main" "$out_a"
-    expect_text a "ASSERTED_NOT_READY" "$out_a" absent
-    if ! grep -q '"outcome":"NO_CI_ASSERTED"' "$WORK_DIR/audit-a.jsonl" 2>/dev/null; then
-        echo "FAIL a: expected a NO_CI_ASSERTED JSONL audit record" >&2
-        failures=$((failures + 1))
-    elif ! grep -q '"asserted_by":"test-identity"' "$WORK_DIR/audit-a.jsonl"; then
-        echo "FAIL a: audit record does not name the asserting identity" >&2
-        failures=$((failures + 1))
-    fi
-fi
-
-# (b) merge + no-status, no flag -> exit 3, existing error text unchanged.
-: > "$URL_LOG"
-set +e
-out_b=$(MOSAIC_STUB_STATUS_MODE=no-status run_guard b --purpose merge 2>&1)
-rc_b=$?
-set -u
-if expect_rc b 3 "$rc_b"; then
-    expect_text b "Error: ASSERTED_NOT_READY state=no-status purpose=merge branch=main." "$out_b"
-    expect_text b "asserted-by" "$out_b" absent
-fi
-if repo_root_fetched; then
-    echo "FAIL b: admin endpoint consulted without the flag" >&2
-    failures=$((failures + 1))
-fi
-
-# (c) merge + no-status + flag + non-admin -> distinct refusal, rc NOT 3.
-: > "$URL_LOG"
-set +e
-out_c=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=non-admin run_guard c --purpose merge --no-ci-expected 2>&1)
-rc_c=$?
-set -u
-if expect_rc c not3 "$rc_c"; then
-    if [[ "$rc_c" -ne 77 ]]; then
-        echo "FAIL c: expected the documented refusal rc=77, got $rc_c" >&2
-        failures=$((failures + 1))
-    fi
-    expect_text c "ASSERTION_REFUSED state=no-status purpose=merge asserted-by=test-identity reason=no-ci-expected branch=main" "$out_c"
-    expect_text c "ASSERTED_NOT_READY" "$out_c" absent
-    if ! grep -q '"outcome":"ASSERTION_REFUSED"' "$WORK_DIR/audit-c.jsonl" 2>/dev/null; then
-        echo "FAIL c: expected an ASSERTION_REFUSED JSONL audit record" >&2
-        failures=$((failures + 1))
-    fi
-fi
-
-# (c2) admin payload with no admin field -> fail closed as non-admin.
-: > "$URL_LOG"
-set +e
-out_c2=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=no-admin-field run_guard c2 --purpose merge --no-ci-expected 2>&1)
-rc_c2=$?
-set -u
-if expect_rc c2 77 "$rc_c2"; then
-    expect_text c2 "ASSERTION_REFUSED" "$out_c2"
-fi
-
-# (d) flag + --require-status -> usage error before any network I/O.
-: > "$URL_LOG"
-set +e
-out_d=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=admin run_guard d --purpose merge --no-ci-expected --require-status 2>&1)
-rc_d=$?
-set -u
-if expect_rc d 1 "$rc_d"; then
-    expect_text d "--no-ci-expected and --require-status contradict" "$out_d"
-fi
-if [[ -s "$URL_LOG" ]]; then
-    echo "FAIL d: usage error must precede every network call" >&2
-    failures=$((failures + 1))
-fi
-
-# (e) flag + a real pending context -> still holds; admin endpoint never asked.
-: > "$URL_LOG"
-set +e
-out_e=$(MOSAIC_STUB_STATUS_MODE=real-pending MOSAIC_STUB_ADMIN_MODE=admin run_guard e --purpose merge --no-ci-expected 2>&1)
-rc_e=$?
-set -u
-if expect_rc e 124 "$rc_e"; then
-    expect_text e "ASSERTED_NOT_READY" "$out_e"
-    expect_text e "ci/woodpecker=running" "$out_e"
-fi
-if repo_root_fetched; then
-    echo "FAIL e: a pending context must not trigger the admin assertion" >&2
-    failures=$((failures + 1))
-fi
-
-# (f) push + no-status stays queue-clear, with and without the flag.
-: > "$URL_LOG"
-set +e
-out_f=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=non-admin run_guard f --purpose push 2>&1)
-rc_f=$?
-set -u
-if expect_rc f 0 "$rc_f"; then
-    expect_text f "queue-clear state=no-status purpose=push branch=main; no queued or running CI." "$out_f"
-fi
-: > "$URL_LOG"
-set +e
-out_f2=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=non-admin run_guard f2 --purpose push --no-ci-expected 2>&1)
-rc_f2=$?
-set -u
-if expect_rc f2 0 "$rc_f2"; then
-    expect_text f2 "queue-clear state=no-status purpose=push branch=main; no queued or running CI." "$out_f2"
-    expect_text f2 "asserted-by" "$out_f2" absent
-fi
-if repo_root_fetched; then
-    echo "FAIL f: push must not consult the admin endpoint" >&2
-    failures=$((failures + 1))
-fi
-
-# (g) flag + admin lookup unreachable -> CANNOT_ASSERT hold (75), not a pass.
-: > "$URL_LOG"
-set +e
-out_g=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=unreachable run_guard g --purpose merge --no-ci-expected 2>&1)
-rc_g=$?
-set -u
-if expect_rc g 75 "$rc_g"; then
-    expect_text g "CANNOT_ASSERT reason=repo-permissions-unavailable" "$out_g"
-fi
-if ! grep -q '"outcome":"CANNOT_ASSERT"' "$WORK_DIR/audit-g.jsonl" 2>/dev/null; then
-    echo "FAIL g: expected a CANNOT_ASSERT JSONL audit record" >&2
-    failures=$((failures + 1))
-fi
-
-# (h) flag + admin stub + no asserting identity -> refusal before queue-clear
-# and before the admin lookup: rc 78, no queue-clear line, an
-# ASSERTION_UNATTRIBUTABLE JSONL record, and zero repos/ network calls.
-: > "$URL_LOG"
-set +e
-out_h=$(MOSAIC_STUB_STATUS_MODE=no-status MOSAIC_STUB_ADMIN_MODE=admin run_guard_no_identity h --purpose merge --no-ci-expected 2>&1)
-rc_h=$?
-set -u
-if expect_rc h 78 "$rc_h"; then
-    expect_text h "ASSERTION_UNATTRIBUTABLE state=no-status purpose=merge asserted-by=unknown reason=no-ci-expected branch=main" "$out_h"
-    expect_text h "queue-clear" "$out_h" absent
-    if ! grep -q '"outcome":"ASSERTION_UNATTRIBUTABLE"' "$WORK_DIR/audit-h.jsonl" 2>/dev/null; then
-        echo "FAIL h: expected an ASSERTION_UNATTRIBUTABLE JSONL audit record" >&2
-        failures=$((failures + 1))
-    fi
-fi
-if repo_root_fetched; then
-    echo "FAIL h: an unattributable caller must not trigger the permission lookup" >&2
-    failures=$((failures + 1))
-fi
-
-if [[ "$failures" -ne 0 ]]; then
-    echo "ci-queue-wait no-ci-expected regression failed ($failures assertions)" >&2
-    exit 1
-fi
-
-echo "ci-queue-wait no-ci-expected regression passed (all outcome classes)"

packages/mosaic/framework/tools/git/test-gitea-login-resolution.sh

@@ -100,15 +100,6 @@ case "$url" in
     */commits/*/status)
         printf '{"state":"success","statuses":[{"context":"ci/mock","status":"success"}]}'
         ;;
-    # Repo roots: the pr-create API fallback resolves its base from the forge
-    # default_branch (T51-P2 WP5a). Exact-suffix matches so the /pulls POST
-    # endpoint (no trailing path) still falls through to the catch-all.
-    */api/v1/repos/USC/uconnect)
-        printf '{"default_branch":"main"}'
-        ;;
-    */api/v1/repos/mosaicstack/stack)
-        printf '{"default_branch":"next"}'
-        ;;
     *)
         printf '{}'
         ;;

packages/mosaic/framework/tools/git/test-issue-create-interactive-auth.sh

@@ -67,18 +67,7 @@ cat > "$BIN_DIR/curl" <<'SH'
 #!/usr/bin/env bash
 set -euo pipefail
 printf 'curl %s\n' "$*" >> "$MOSAIC_TEST_LOG"
-# Repo roots: the pr-create API fallback resolves its base from the forge
+printf '%s\n' '{"number":703}'
-# default_branch (T51-P2 WP5a). Exact-suffix so every other endpoint keeps
-# the historical answer below.
-url="${*: -1}"
-case "$url" in
-    */api/v1/repos/mosaicstack/stack)
-        printf '%s\n' '{"default_branch":"next"}'
-        ;;
-    *)
-        printf '%s\n' '{"number":703}'
-        ;;
-esac
 SH
 chmod +x "$BIN_DIR/tea" "$BIN_DIR/curl"
 

packages/mosaic/framework/tools/git/test-pr-create-fallback-default-base.sh

@@ -1,178 +0,0 @@
-#!/usr/bin/env bash
-# test-pr-create-fallback-default-base.sh — hermetic test for the API-fallback
-# base resolution in pr-create.sh (T51-P2 WP5a / spec E4).
-#
-# The API-fallback payload historically hardcoded "base": "main", mistargeting
-# every fallback PR on repos whose trunk is not main (e.g. mosaicstack/stack,
-# default branch "next"). The fix: an explicit -B always wins; with none, the
-# base is resolved from the provider API default_branch, and a failed
-# resolution fails loud instead of guessing.
-#
-# Hermetic by construction: every curl invocation is a PATH-first stub; the
-# fixture repo's remote is git.example.test (never dialed); HOME is a sandbox
-# with no tea config (so the wrapper takes the API fallback path); GITEA_TOKEN
-# comes from the environment. No real forge is contacted.
-
-# shellcheck disable=SC2317
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/pr-create-fallback-base}"
-
-PASS=0 FAIL=0 FAILED_CASES=""
-
-ok()  { PASS=$((PASS + 1)); }
-bad() { FAIL=$((FAIL + 1)); FAILED_CASES="$FAILED_CASES $1"; printf 'FAIL: %s\n' "$1" >&2; }
-
-assert_rc()    { local d="$1" e="$2" a="$3"; [ "$e" = "$a" ] && ok || bad "$d (expected rc=$e got rc=$a)"; }
-assert_eq()    { local d="$1" e="$2" a="$3"; [ "$e" = "$a" ] && ok || bad "$d (expected [$e] got [$a])"; }
-assert_contains() { local d="$1" h="$2" n="$3"; case "$h" in *"$n"*) ok ;; *) bad "$d (missing [$n])" ;; esac; }
-
-json_field() { # $1 payload file, $2 field
-    python3 -c 'import json,sys; print(json.load(open(sys.argv[1])).get(sys.argv[2], ""))' "$1" "$2"
-}
-
-rm -rf "$WORK_DIR"
-
-# ---- fixture -----------------------------------------------------------------
-ROOT="$WORK_DIR/fixture"
-TOOLS="$ROOT/tools/git"
-mkdir -p "$TOOLS" "$ROOT/repo" "$ROOT/home" "$ROOT/stub"
-cp "$SCRIPT_DIR/pr-create.sh" "$TOOLS/pr-create.sh"
-cp "$SCRIPT_DIR/detect-platform.sh" "$TOOLS/detect-platform.sh"
-
-git -C "$ROOT/repo" init -q -b fix/e4
-git -C "$ROOT/repo" -c user.name=fixture -c user.email=fixture@test commit -q --allow-empty -m base
-git -C "$ROOT/repo" remote add origin https://git.example.test/acme/widgets.git
-
-# curl stub: GET repo -> default_branch JSON (or failure mode); POST pulls ->
-# capture payload, answer with a minimal PR JSON. Every call is logged.
-cat > "$ROOT/stub/curl" <<STUB
-#!/usr/bin/env bash
-set -u
-mode="\${CURL_STUB_GET_MODE:-ok}"
-printf '%s\n' "\$*" >> "$ROOT/curl-calls.log"
-url="\${!#}"
-if [[ "\$url" == */api/v1/repos/acme/widgets ]]; then
-    # repo GET (default-branch resolution). Modes cover the value shapes the
-    # resolver must accept or refuse (T51P2WP5AR B2/B3).
-    case "\$mode" in
-        ok)         printf '%s\n' '{"id":1,"default_branch":"next","full_name":"acme/widgets"}' ;;
-        fail)       echo "curl stub: simulated repo lookup failure" >&2; exit 1 ;;
-        fail-json)  printf '%s\n' '{"default_branch":"next"}'; exit 22 ;;
-        null)       printf '%s\n' '{"default_branch":null}' ;;
-        numeric)    printf '%s\n' '{"default_branch":7}' ;;
-        blank)      printf '%s\n' '{"default_branch":"   "}' ;;
-        *)          echo "curl stub: unknown GET mode \$mode" >&2; exit 1 ;;
-    esac
-    exit 0
-fi
-if [[ "\$url" == */api/v1/repos/acme/widgets/pulls ]]; then
-    # PR POST: capture the payload, emit a PR-shaped answer
-    while [[ \$# -gt 0 ]]; do
-        case "\$1" in
-            -d) printf '%s' "\$2" > "$ROOT/payload.json"; shift 2 ;;
-            *) shift ;;
-        esac
-    done
-    printf '%s\n' '{"number":42,"html_url":"https://git.example.test/acme/widgets/pulls/42"}'
-    exit 0
-fi
-echo "curl stub: unexpected URL \$url" >&2
-exit 1
-STUB
-chmod +x "$ROOT/stub/curl"
-
-run_pr_create() { # args... -> sets RC/OUT/ERR
-    RC=0
-    OUT=$(cd "$ROOT/repo" && env -i \
-        PATH="$ROOT/stub:/usr/bin:/bin" \
-        HOME="$ROOT/home" \
-        GITEA_TOKEN=stub-token \
-        bash "$TOOLS/pr-create.sh" "$@" 2>"$ROOT/err.txt")
-    RC=$?
-    ERR="$(cat "$ROOT/err.txt")"
-}
-
-calls_matching() { grep -c -- "$1" "$ROOT/curl-calls.log" 2>/dev/null || true; }
-
-echo "== (1) no -B: fallback base resolves to the forge default branch, not main =="
-: > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-run_pr_create -t "fix thing"
-assert_rc "rc" 0 "$RC"
-assert_contains "API fallback path taken (tea login unresolvable in fixture)" "$ERR" "trying Gitea API fallback"
-assert_eq "repo GET performed" 1 "$(calls_matching '/api/v1/repos/acme/widgets$')"
-assert_eq "POST performed" 1 "$(calls_matching '/pulls$')"
-assert_eq "payload base is forge default (next)" "next" "$(json_field "$ROOT/payload.json" base)"
-assert_eq "payload head" "fix/e4" "$(json_field "$ROOT/payload.json" head)"
-assert_eq "payload title" "fix thing" "$(json_field "$ROOT/payload.json" title)"
-
-echo "== (2) explicit -B wins; the default branch is not consulted =="
-: > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-run_pr_create -t "fix thing" -B release/1.x
-assert_rc "rc" 0 "$RC"
-assert_eq "repo GET not consulted for explicit base" 0 "$(calls_matching '/api/v1/repos/acme/widgets$')"
-assert_eq "payload base is the explicit -B" "release/1.x" "$(json_field "$ROOT/payload.json" base)"
-
-echo "== (3) default-branch lookup failure: loud refusal, no POST =="
-: > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-RC=0
-OUT=$(cd "$ROOT/repo" && env -i \
-    PATH="$ROOT/stub:/usr/bin:/bin" \
-    HOME="$ROOT/home" \
-    GITEA_TOKEN=stub-token \
-    CURL_STUB_GET_MODE=fail \
-    bash "$TOOLS/pr-create.sh" -t "fix thing" 2>"$ROOT/err.txt")
-RC=$?
-ERR="$(cat "$ROOT/err.txt")"
-assert_rc "nonzero rc on unresolvable base" 1 "$RC"
-assert_contains "loud error names -B" "$ERR" "could not resolve the forge default branch"
-assert_contains "error names the remedy" "$ERR" "pass -B <branch> explicitly"
-assert_eq "no POST issued" 0 "$(calls_matching '/pulls$')"
-
-echo "== (4) payload never contains the literal fallback main =="
-: > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-run_pr_create -t "fix thing"
-assert_rc "rc" 0 "$RC"
-assert_eq "base field is next, never main" "next" "$(json_field "$ROOT/payload.json" base)"
-
-echo "== (5) B2: HTTP failure with parseable JSON on stdout is a FAILED resolution =="
-: > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-RC=0
-OUT=$(cd "$ROOT/repo" && env -i \
-    PATH="$ROOT/stub:/usr/bin:/bin" \
-    HOME="$ROOT/home" \
-    GITEA_TOKEN=stub-token \
-    CURL_STUB_GET_MODE=fail-json \
-    bash "$TOOLS/pr-create.sh" -t "fix thing" 2>"$ROOT/err.txt")
-RC=$?
-ERR="$(cat "$ROOT/err.txt")"
-assert_rc "nonzero rc on HTTP failure despite valid JSON" 1 "$RC"
-assert_contains "loud error names -B" "$ERR" "could not resolve the forge default branch"
-assert_contains "error names the remedy" "$ERR" "pass -B <branch> explicitly"
-assert_eq "no POST issued" 0 "$(calls_matching '/pulls$')"
-
-echo "== (6) B3: null / numeric / blank default_branch are failed resolutions =="
-for bad in null numeric blank; do
-    : > "$ROOT/curl-calls.log"; rm -f "$ROOT/payload.json"
-    RC=0
-    OUT=$(cd "$ROOT/repo" && env -i \
-        PATH="$ROOT/stub:/usr/bin:/bin" \
-        HOME="$ROOT/home" \
-        GITEA_TOKEN=stub-token \
-        CURL_STUB_GET_MODE="$bad" \
-        bash "$TOOLS/pr-create.sh" -t "fix thing" 2>"$ROOT/err.txt")
-    RC=$?
-    ERR="$(cat "$ROOT/err.txt")"
-    assert_rc "B3 $bad: nonzero rc" 1 "$RC"
-    assert_contains "B3 $bad: loud error" "$ERR" "could not resolve the forge default branch"
-    assert_eq "B3 $bad: no POST issued" 0 "$(calls_matching '/pulls$')"
-done
-
-echo
-echo "pass=$PASS fail=$FAIL"
-if [ "$FAIL" -gt 0 ]; then
-    echo "FAILED CASES:$FAILED_CASES"
-    exit 1
-fi
-echo "ALL GREEN"

packages/mosaic/framework/tools/git/test-pr-merge-no-ci-expected.sh

@@ -1,84 +0,0 @@
-#!/usr/bin/env bash
-# pr-merge must forward --no-ci-expected to the queue guard, and only then.
-# The flag is the sanctioned merge path for a repository with no CI configured
-# (see test-ci-queue-wait-no-ci-expected.sh for the guard-side semantics);
-# this harness pins only the pass-through: present when requested, absent when
-# not, with the rest of the guard invocation unchanged.
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-WORK_DIR="${MOSAIC_TEST_WORK_DIR:-$PWD/.mosaic-test-work/pr-merge-no-ci-expected}"
-FIXTURE_DIR="$WORK_DIR/tools/git"
-CALL_LOG="$WORK_DIR/queue-call.log"
-
-rm -rf "$WORK_DIR"
-mkdir -p "$FIXTURE_DIR"
-cp "$SCRIPT_DIR/pr-merge.sh" "$FIXTURE_DIR/pr-merge.sh"
-cp "$SCRIPT_DIR/detect-platform.sh" "$FIXTURE_DIR/detect-platform.sh"
-
-cat > "$FIXTURE_DIR/pr-metadata.sh" <<'SH'
-#!/usr/bin/env bash
-printf '%s\n' '{"baseRefName":"main","baseRepository":"mosaicstack/stack","headRefName":"fix/no-ci-fixture","headRefOid":"0123456789abcdef0123456789abcdef01234567","headRepository":"mosaicstack/stack"}'
-SH
-
-cat > "$FIXTURE_DIR/ci-queue-wait.sh" <<'SH'
-#!/usr/bin/env bash
-printf '%s\n' "$*" > "${MOSAIC_QUEUE_CALL_LOG:?}"
-exit 42
-SH
-chmod +x "$FIXTURE_DIR"/*.sh
-
-run_merge() {
-    (
-        cd "$WORK_DIR"
-        export MOSAIC_QUEUE_CALL_LOG="$CALL_LOG"
-        "$FIXTURE_DIR/pr-merge.sh" -n 123 "$@"
-    ) >/dev/null 2>&1
-}
-
-fail=0
-
-# With the flag: it must reach the guard invocation.
-: > "$CALL_LOG"
-set +e
-run_merge --no-ci-expected
-rc_with=$?
-set -e
-if [[ "$rc_with" -ne 42 ]]; then
-    echo "FAIL(with): expected queue stub rc=42 to propagate, got $rc_with" >&2
-    fail=1
-elif ! grep -q -- '--no-ci-expected' "$CALL_LOG"; then
-    echo "FAIL(with): --no-ci-expected did not reach the queue guard" >&2
-    cat "$CALL_LOG" >&2
-    fail=1
-fi
-# The rest of the guard invocation is unchanged by the flag.
-for required in '--purpose merge' '-B fix/no-ci-fixture' '-R mosaicstack/stack' \
-    '--sha 0123456789abcdef0123456789abcdef01234567'; do
-    if ! grep -qF -- "$required" "$CALL_LOG"; then
-        echo "FAIL(with): guard invocation lost '$required'" >&2
-        cat "$CALL_LOG" >&2
-        fail=1
-    fi
-done
-
-# Without the flag: it must NOT appear in the guard invocation.
-: > "$CALL_LOG"
-set +e
-run_merge
-rc_without=$?
-set -e
-if [[ "$rc_without" -ne 42 ]]; then
-    echo "FAIL(without): expected queue stub rc=42 to propagate, got $rc_without" >&2
-    fail=1
-elif grep -q -- '--no-ci-expected' "$CALL_LOG"; then
-    echo "FAIL(without): --no-ci-expected reached the guard without being requested" >&2
-    cat "$CALL_LOG" >&2
-    fail=1
-fi
-
-if [[ "$fail" -eq 0 ]]; then
-    echo "pr-merge no-ci-expected pass-through regression passed"
-fi
-exit "$fail"

packages/mosaic/framework/tools/git/test-repo-decl-consumption.sh

@@ -1,333 +0,0 @@
-#!/usr/bin/env bash
-# test-repo-decl-consumption.sh — hermetic declaration-consumption suite for the
-# git wrappers (T51 WP5b).
-#
-# Spec of record (brain repo): docs/plans/2026-08-23_repo-structure-declaration.md
-# sections 4 (consumption), 5.3 (normalization), 5.4 (hostile-input classes),
-# 1.2a (root anchoring). Covers every §5.4 class applicable to consumed fields
-# plus the per-tool behaviors (base precedence, transition validation, remote
-# fail-closed, absence policy, route context, staged worktree rule).
-#
-# Red-first usage: WP5B_TOOLS=<dir with PRE-change tool copies> bash $0
-# exits nonzero — the declaration-driven arms fail against tools that predate
-# the change (evidence captured in the WP5b report).
-#
-# Hermetic: scratch repos under $TMPDIR, PATH-stubbed curl, sandboxed HOME; no
-# network, no live forge, no writes outside the sandbox.
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TOOLS_SRC="${WP5B_TOOLS:-$SCRIPT_DIR}"
-TROOT="${TMPDIR:-/tmp}"
-
-PASS=0 FAIL=0 FAILED_CASES=""
-FIXTURES=()
-cleanup_all() { local f; for f in "${FIXTURES[@]:-}"; do rm -rf -- "$f"; done; }
-trap cleanup_all EXIT INT TERM
-
-ok()  { PASS=$((PASS + 1)); }
-bad() { FAIL=$((FAIL + 1)); FAILED_CASES="$FAILED_CASES $1"; printf 'FAIL: %s\n' "$1" >&2; }
-assert_rc()    { local d="$1" e="$2" a="$3"; [ "$e" = "$a" ] && ok || bad "$d (expected rc=$e got rc=$a)"; }
-assert_eq()    { local d="$1" e="$2" a="$3"; [ "$e" = "$a" ] && ok || bad "$d (expected [$e] got [$a])"; }
-assert_contains() { local d="$1" h="$2" n="$3"; case "$h" in *"$n"*) ok ;; *) bad "$d (missing [$n])" ;; esac; }
-assert_not_contains() { local d="$1" h="$2" n="$3"; case "$h" in *"$n"*) bad "$d (unexpected [$n])" ;; *) ok ;; esac; }
-assert_count() { local d="$1" e="$2" a="$3"; [ "$e" = "$a" ] && ok || bad "$d (expected $e got $a)"; }
-
-new_sb() { SB="$(mktemp -d "$TROOT/wp5b-test.XXXXXX")"; FIXTURES+=("$SB"); }
-
-# A fixture repo with the (possibly pre-change) tools + validator installed.
-# $1 dir, stdin = declaration JSON ("" = none), $2 = origin url ("" = none)
-mkrepo() {
-    local d="$1" decl_origin="${2:-}"
-    mkdir -p "$d/tools/git" "$d/tools/structure" "$d/home"
-    cp "$TOOLS_SRC/repo-decl.sh" "$d/tools/git/" 2>/dev/null || true
-    cp "$TOOLS_SRC/pr-create.sh" "$TOOLS_SRC/pr-merge.sh" "$TOOLS_SRC/mosaic-worktree.sh" "$TOOLS_SRC/ci-queue-wait.sh" "$TOOLS_SRC/detect-platform.sh" "$d/tools/git/" 2>/dev/null || true
-    cp "$SCRIPT_DIR/../structure/validate-repo-json.sh" "$d/tools/structure/"
-    git -C "$d" init -q -b feature/x
-    git -C "$d" config user.name fixture; git -C "$d" config user.email fixture@test
-    mkdir -p "$d/.mosaic" "$d/sites"
-    printf 'base\n' > "$d/f"; git -C "$d" add -A; git -C "$d" commit -q -m base
-    [ -n "$decl_origin" ] && git -C "$d" remote add origin "$decl_origin"
-    cat > "$d/.mosaic/repo.json"
-    # whitespace-only input (the absent-decl arms use <<< "") must mean ABSENT,
-    # not an invalid-file fixture: strip it to no file.
-    grep -q '[^[:space:]]' "$d/.mosaic/repo.json" 2>/dev/null || rm -f "$d/.mosaic/repo.json"
-}
-
-# The canonical v2 declaration used by default (custom branch names prove the
-# tools never hardcode): trunk=dev-trunk release=prod-rel flow=trunk-release.
-DECL_TR='{
-  "schema_version": 2,
-  "integration_trunk": "dev-trunk",
-  "release_branch": "prod-rel",
-  "flow": "trunk-release",
-  "canonical_remote": "https://git.example.test/acme/widgets",
-  "canonical_clone": "host:/src/widgets",
-  "worktree_root": "host:/src/widgets-worktrees",
-  "worktree_policy": "orchestrator-precreated"
-}'
-
-decl_direct() { printf '{\n  "schema_version": 2,\n  "integration_trunk": "mainline",\n  "release_branch": "mainline",\n  "flow": "direct",\n  "canonical_remote": "https://git.example.test/acme/widgets",\n  "canonical_clone": "host:/src/widgets"\n}\n'; }
-
-load_decl_in() { # $1 dir -> runs repo_decl_load in a subshell, prints STATE etc.
-    ( cd "$1" && source "$1/tools/git/repo-decl.sh" && repo_decl_load \
-        && printf 'STATE=%s SCHEMA=%s TRUNK=%s RELEASE=%s FLOW=%s ERROR=%s\n' \
-           "$DECL_STATE" "${DECL_SCHEMA:-}" "${DECL_TRUNK:-}" "${DECL_RELEASE:-}" "${DECL_FLOW:-}" "${DECL_ERROR:-}" )
-}
-
-echo "== A. lib classification + hostile inputs (spec 5.4 classes) =="
-new_sb; mkrepo "$SB/r1" <<< "$DECL_TR" "https://git.example.test/acme/widgets.git"
-A="$(load_decl_in "$SB/r1")"
-assert_contains "A1 valid v2 state" "$A" "STATE=valid"
-assert_contains "A1 trunk" "$A" "TRUNK=dev-trunk"
-assert_contains "A1 release" "$A" "RELEASE=prod-rel"
-assert_contains "A1 flow" "$A" "FLOW=trunk-release"
-assert_contains "A1 schema" "$A" "SCHEMA=2"
-
-new_sb; mkrepo "$SB/r2" <<< "" "https://git.example.test/acme/widgets"
-A="$(load_decl_in "$SB/r2")"
-assert_contains "A2 missing file = absent" "$A" "STATE=absent"
-
-new_sb; mkrepo "$SB/r3" <<< '{ not json'
-A="$(load_decl_in "$SB/r3")"
-assert_contains "A3 malformed JSON = invalid" "$A" "STATE=invalid"
-assert_contains "A3 error names the failure" "$A" "VALIDATION_ERROR"
-
-new_sb; mkrepo "$SB/r4" <<< '{"schema_version": 99, "integration_trunk": "x", "release_branch": "y", "flow": "direct", "canonical_remote": "https://a/b"}'
-A="$(load_decl_in "$SB/r4")"
-assert_contains "A4 unknown schema_version = invalid" "$A" "STATE=invalid"
-
-new_sb; mkrepo "$SB/r5" <<< '{"integration_trunk": "x", "release_branch": "y"}'
-A="$(load_decl_in "$SB/r5")"
-assert_contains "A5 v1 validates" "$A" "STATE=valid"
-assert_contains "A5 v1 schema recorded" "$A" "SCHEMA=1"
-
-new_sb; mkrepo "$SB/r6" <<< '{"schema_version": 2, "integration_trunk": "x", "release_branch": "y", "flow": "direct", "canonical_remote": "https://a/b", "surprise": 1}'
-A="$(load_decl_in "$SB/r6")"
-assert_contains "A6 unknown top-level key = invalid" "$A" "STATE=invalid"
-
-new_sb; mkrepo "$SB/r7" <<< '{"schema_version": 2, "integration_trunk": "bad..name", "release_branch": "y", "flow": "direct", "canonical_remote": "https://a/b"}'
-A="$(load_decl_in "$SB/r7")"
-assert_contains "A7 bad ref name = invalid" "$A" "STATE=invalid"
-
-new_sb; mkrepo "$SB/r8" <<< '{"schema_version": 2, "integration_trunk": "a", "release_branch": "b", "flow": "direct", "canonical_remote": "https://a/b"}'
-A="$(load_decl_in "$SB/r8")"
-assert_contains "A8 cross-field violation = invalid" "$A" "STATE=invalid"
-
-new_sb; mkrepo "$SB/r9" <<< '{"schema_version": 2, "integration_trunk": "a", "release_branch": "b", "flow": "trunk-release", "canonical_remote": "https://user:pw@a/b"}'
-A="$(load_decl_in "$SB/r9")"
-assert_contains "A9 userinfo URL = invalid" "$A" "STATE=invalid"
-
-echo "== A2. transitions + remote + path anchoring =="
-new_sb; mkrepo "$SB/t1" <<< "$DECL_TR"
-T=(); rc=0
-T_out="$( cd "$SB/t1" && source tools/git/repo-decl.sh && repo_decl_load
-  repo_decl_check_transition feat dev-trunk && echo "feat->trunk:ALLOWED"
-  repo_decl_check_transition dev-trunk prod-rel && echo "trunk->rel:ALLOWED"
-  repo_decl_check_transition feat prod-rel || echo "feat->rel:REFUSED"
-  repo_decl_check_transition other other || echo "same:REFUSED"
-  repo_decl_check_transition feat elsewhere || echo "arbitrary:REFUSED" )"
-assert_contains "T1 feature->trunk allowed" "$T_out" "feat->trunk:ALLOWED"
-assert_contains "T1 trunk->release allowed" "$T_out" "trunk->rel:ALLOWED"
-assert_contains "T1 feature->release refused" "$T_out" "feat->rel:REFUSED"
-assert_contains "T1 head==base refused" "$T_out" "same:REFUSED"
-assert_contains "T1 arbitrary target refused" "$T_out" "arbitrary:REFUSED"
-
-new_sb; mkrepo "$SB/t2" <<< "$(decl_direct)"
-T_out="$( cd "$SB/t2" && source tools/git/repo-decl.sh && repo_decl_load
-  repo_decl_check_transition feat mainline && echo "direct-ok:ALLOWED"
-  repo_decl_check_transition feat other || echo "direct-other:REFUSED" )"
-assert_contains "T2 direct feature->trunk allowed" "$T_out" "direct-ok:ALLOWED"
-assert_contains "T2 direct other base refused" "$T_out" "direct-other:REFUSED"
-
-new_sb; mkrepo "$SB/t3" <<< "$DECL_TR" "https://Git.Example.Test/acme/widgets.git/"
-M="$( cd "$SB/t3" && source tools/git/repo-decl.sh && repo_decl_load && repo_decl_remote_matches && echo MATCH )"
-assert_contains "T3 normalization: .git/case differences still MATCH" "$M" "MATCH"
-new_sb; mkrepo "$SB/t4" <<< "$DECL_TR" "https://git.example.test/acme/OTHER"
-M="$( cd "$SB/t4" && source tools/git/repo-decl.sh && repo_decl_load && { repo_decl_remote_matches && echo MATCH; } || echo MISMATCH )"
-assert_contains "T4 remote mismatch detected" "$M" "MISMATCH"
-
-new_sb; mkrepo "$SB/t5" <<< "$DECL_TR"
-P="$( cd "$SB/t5" && source tools/git/repo-decl.sh && { repo_decl_path "host:/src/x" 2>/dev/null && echo RESOLVED; } || echo FAILCLOSED )"
-assert_contains "T5 host:/ resolution fails closed (root unset)" "$P" "FAILCLOSED"
-
-echo "== B. pr-create consumption =="
-mkpr() { # $1 dir: install the curl stub + run env; sets PR_RC/PR_OUT/PR_ERR/PR_PAYLOAD
-    mkdir -p "$1/stub"
-    cat > "$1/stub/curl" <<'STUB'
-#!/usr/bin/env bash
-url="${*: -1}"
-printf 'curl %s\n' "$*" >> "${STUB_DIR:?}/calls.log"
-case "$url" in
-    */api/v1/repos/acme/widgets) printf '%s\n' '{"default_branch":"forge-default"}'; exit 0 ;;
-    */pulls)
-        while [[ $# -gt 0 ]]; do
-            case "$1" in -d) printf '%s' "$2" > "${STUB_DIR:?}/payload.json"; shift 2 ;; *) shift ;; esac
-        done
-        printf '%s\n' '{"number":42}'; exit 0 ;;
-    *) printf '%s\n' '{}'; exit 0 ;;
-esac
-STUB
-    chmod +x "$1/stub/curl"
-}
-run_pr() { # $1 dir, rest args -> pr-create
-    local prdir="$1"; shift
-    PR_RC=0
-    PR_OUT="$(cd "$prdir" && env -i PATH="$prdir/stub:/usr/bin:/bin" HOME="$prdir/home" \
-        GITEA_TOKEN=stub-token STUB_DIR="$prdir" \
-        bash "$prdir/tools/git/pr-create.sh" "$@" < /dev/null 2>"$prdir/err.txt")" || PR_RC=$?
-    PR_ERR="$(cat "$prdir/err.txt")"
-    PR_PAYLOAD="$(cat "$prdir/payload.json" 2>/dev/null || true)"
-    PR_GETS="$(grep -c 'repos/acme/widgets$' "$prdir/calls.log" 2>/dev/null || true)"; PR_GETS="${PR_GETS:-0}"
-    PR_POSTS="$(grep -c '/pulls$' "$prdir/calls.log" 2>/dev/null || true)"; PR_POSTS="${PR_POSTS:-0}"
-    : > "$prdir/calls.log" 2>/dev/null || true
-    rm -f "$prdir/payload.json"
-}
-
-new_sb; mkrepo "$SB/b1" <<< "$DECL_TR" "https://git.example.test/acme/widgets"; mkpr "$SB/b1"
-git -C "$SB/b1" checkout -q -b feature/x 2>/dev/null || true
-run_pr "$SB/b1" -t "T"
-assert_rc "B1 declared trunk base rc 0" 0 "$PR_RC"
-base="$(printf '%s' "$PR_PAYLOAD" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("base",""))' 2>/dev/null || true)"
-assert_eq "B1 payload base = declared trunk (no -B)" "dev-trunk" "$base"
-assert_count "B1 zero repo GETs (declared trunk consulted, not the forge default)" 0 "$PR_GETS"
-
-run_pr "$SB/b1" -t "T" -B prod-rel
-assert_rc "B2 -B feature->release REFUSED (4.2)" 1 "$PR_RC"
-assert_contains "B2 names the transition rule" "$PR_ERR" "not an allowed transition"
-assert_count "B2 no POST issued" 0 "$PR_POSTS"
-
-run_pr "$SB/b1" -t "T" -B dev-trunk
-assert_rc "B3 -B feature->trunk allowed" 0 "$PR_RC"
-base="$(printf '%s' "$PR_PAYLOAD" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("base",""))' 2>/dev/null || true)"
-assert_eq "B3 payload base = explicit allowed -B" "dev-trunk" "$base"
-
-run_pr "$SB/b1" -t "T" -B dev-trunk --head dev-trunk
-assert_rc "B4 -B trunk->trunk (head==base) refused" 1 "$PR_RC"
-
-new_sb; mkrepo "$SB/b5" <<< "$DECL_TR" "https://git.example.test/acme/wrong"; mkpr "$SB/b5"
-run_pr "$SB/b5" -t "T"
-assert_rc "B5 remote mismatch on write path refuses" 1 "$PR_RC"
-assert_contains "B5 names the 5.3 rule" "$PR_ERR" "canonical_remote"
-assert_count "B5 no POST" 0 "$PR_POSTS"
-
-new_sb; mkrepo "$SB/b6" <<< "" "https://git.example.test/acme/widgets"; mkpr "$SB/b6"
-run_pr "$SB/b6" -t "T"
-assert_rc "B6 absent decl: legacy forge default rc 0" 0 "$PR_RC"
-base="$(printf '%s' "$PR_PAYLOAD" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("base",""))' 2>/dev/null || true)"
-assert_eq "B6 payload base = forge default" "forge-default" "$base"
-assert_count "B6 repo GET performed (WP5a floor preserved)" 1 "$PR_GETS"
-assert_contains "B6 absence warning present" "$PR_ERR" "unmanaged during rollout"
-
-new_sb; mkrepo "$SB/b7" <<< '{ not json' "https://git.example.test/acme/widgets"; mkpr "$SB/b7"
-run_pr "$SB/b7" -t "T"
-assert_rc "B7 invalid decl: loud report + legacy proceed" 0 "$PR_RC"
-assert_contains "B7 validation error reported" "$PR_ERR" "declaration INVALID"
-base="$(printf '%s' "$PR_PAYLOAD" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("base",""))' 2>/dev/null || true)"
-assert_eq "B7 legacy forge default used" "forge-default" "$base"
-
-new_sb; mkrepo "$SB/b8" <<< '{"integration_trunk": "x", "release_branch": "y"}' "https://git.example.test/acme/widgets"; mkpr "$SB/b8"
-run_pr "$SB/b8" -t "T"
-assert_rc "B8 v1 decl: legacy proceed rc 0" 0 "$PR_RC"
-assert_contains "B8 v1 note present" "$PR_ERR" "no consumable flow/trunk fields"
-base="$(printf '%s' "$PR_PAYLOAD" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("base",""))' 2>/dev/null || true)"
-assert_eq "B8 legacy forge default used" "forge-default" "$base"
-
-echo "== C. pr-merge transition validation (no hardcoded targets) =="
-mkmerge() { # $1 dir, $2 base, $3 head -> stubs pr-metadata; runs pr-merge; sets M_RC/M_OUT/M_ERR
-    cp "$SCRIPT_DIR/pr-merge.sh" "$1/tools/git/pr-merge.sh" 2>/dev/null || true
-    cat > "$1/tools/git/pr-metadata.sh" <<EOF
-#!/usr/bin/env bash
-printf '%s\n' '{"baseRefName":"$2","headRefName":"$3","headRefOid":"0123456789abcdef0123456789abcdef01234567","headRepository":"acme/widgets","title":"t","author":{"login":"a"}}'
-EOF
-    chmod +x "$1/tools/git/pr-metadata.sh"
-    cat > "$1/tools/git/ci-queue-wait.sh" <<'EOF'
-#!/usr/bin/env bash
-exit 0
-EOF
-    chmod +x "$1/tools/git/ci-queue-wait.sh"
-    mkdir -p "$1/stub"
-    printf '#!/usr/bin/env bash\nexit 0\n' > "$1/stub/curl"; chmod +x "$1/stub/curl"
-    M_RC=0
-    M_OUT="$(cd "$1" && env -i PATH="$1/stub:/usr/bin:/bin" HOME="$1/home" GITEA_TOKEN=stub-token \
-        bash "$1/tools/git/pr-merge.sh" -n 7 --dry-run < /dev/null 2>"$1/merr.txt")" || M_RC=$?
-    M_ERR="$(cat "$1/merr.txt")"
-}
-
-new_sb; mkrepo "$SB/c1" <<< "$DECL_TR" "https://git.example.test/acme/widgets"
-mkmerge "$SB/c1" dev-trunk feature/x
-assert_rc "C1 feature->trunk under decl (custom trunk name, no hardcode)" 0 "$M_RC"
-assert_contains "C1 transition context printed" "$M_ERR" "transition OK under flow=trunk-release"
-
-mkmerge "$SB/c1" prod-rel feature/x
-assert_rc "C2 feature->release REJECTED under decl" 1 "$M_RC"
-assert_contains "C2 names the declared transition rule" "$M_ERR" "not a declared transition"
-
-mkmerge "$SB/c1" prod-rel dev-trunk
-assert_rc "C3 trunk->release promotion allowed" 0 "$M_RC"
-
-new_sb; mkrepo "$SB/c4" <<< "" "https://git.example.test/acme/widgets"
-mkmerge "$SB/c4" main feature/x
-assert_rc "C4 absent decl: legacy main/next check still enforced (main ok)" 0 "$M_RC"
-assert_contains "C4 legacy warning present" "$M_ERR" "LEGACY assumptions"
-mkmerge "$SB/c4" trunk-x feature/x
-assert_rc "C4 absent decl: unknown target rejected by legacy check" 1 "$M_RC"
-
-new_sb; mkrepo "$SB/c5" <<< "$DECL_TR" "https://git.example.test/acme/wrong"
-mkmerge "$SB/c5" dev-trunk feature/x
-assert_rc "C5 remote mismatch refuses the merge" 1 "$M_RC"
-assert_contains "C5 names 5.3" "$M_ERR" "canonical_remote"
-
-echo "== D. mosaic-worktree staged rule (4.4/4.5) =="
-mkwt() { # $1 dir: home outside the repo so derivation passes assert_not_home
-    mv "$1/home" "$SB/wthome" 2>/dev/null || true
-}
-new_sb; mkrepo "$SB/d1" <<< '{ not json'; mkwt "$SB/d1"
-WT_RC=0
-WT_OUT="$(cd "$SB/d1" && env -i PATH="/usr/bin:/bin" HOME="$SB/wthome" \
-    bash "$SB/d1/tools/git/mosaic-worktree.sh" new feat2 < /dev/null 2>"$SB/d1/wterr.txt")" || WT_RC=$?
-assert_rc "D1 invalid decl fails branch-creation loud" 1 "$WT_RC"
-assert_contains "D1 names the invalid declaration" "$(cat "$SB/d1/wterr.txt")" "INVALID"
-
-new_sb; mkrepo "$SB/d2" <<< ""; mkwt "$SB/d2"
-WT_RC=0
-WT_OUT="$(cd "$SB/d2" && env -i PATH="/usr/bin:/bin" HOME="$SB/wthome" \
-    bash "$SB/d2/tools/git/mosaic-worktree.sh" new feat3 < /dev/null 2>"$SB/d2/wterr.txt")" || WT_RC=$?
-assert_rc "D2 absent decl: warn + proceed" 0 "$WT_RC"
-assert_contains "D2 loud warning present" "$(cat "$SB/d2/wterr.txt")" "LEGACY assumptions"
-
-new_sb; mkrepo "$SB/d3" <<< "$DECL_TR"; mkwt "$SB/d3"
-WT_RC=0
-WT_OUT="$(cd "$SB/d3" && env -i PATH="/usr/bin:/bin" HOME="$SB/wthome" \
-    bash "$SB/d3/tools/git/mosaic-worktree.sh" new feat4 < /dev/null 2>"$SB/d3/wterr.txt")" || WT_RC=$?
-assert_rc "D3 valid decl: policy advisory + proceed" 0 "$WT_RC"
-assert_contains "D3 precreated policy note" "$(cat "$SB/d3/wterr.txt")" "orchestrator-precreated"
-assert_contains "D3 placement stays derived (no decl path used)" "$(cat "$SB/d3/wterr.txt")" "TRANSITIONAL"
-
-echo "== E. ci-queue-wait route context (C4: context only, never a gate) =="
-new_sb; mkrepo "$SB/e1" <<< "$DECL_TR" "https://git.example.test/acme/widgets"
-git -C "$SB/e1" checkout -q -b dev-trunk 2>/dev/null || { git -C "$SB/e1" branch -q dev-trunk; git -C "$SB/e1" checkout -q dev-trunk; }
-E_RC=0
-E_OUT="$(cd "$SB/e1" && env -i PATH="/usr/bin:/bin" HOME="$SB/e1/home" \
-    bash "$SB/e1/tools/git/ci-queue-wait.sh" < /dev/null 2>"$SB/e1/eerr.txt")" || E_RC=$?
-E_ERR="$(cat "$SB/e1/eerr.txt")"
-assert_contains "E1 route context names trunk head" "$E_ERR" "'dev-trunk' is a trunk (integration head) head"
-assert_contains "E1 context names the flow" "$E_ERR" "flow=trunk-release"
-
-new_sb; mkrepo "$SB/e2" <<< "" "https://git.example.test/acme/widgets"
-E_RC=0
-E_OUT="$(cd "$SB/e2" && env -i PATH="/usr/bin:/bin" HOME="$SB/e2/home" \
-    bash "$SB/e2/tools/git/ci-queue-wait.sh" < /dev/null 2>"$SB/e2/eerr.txt")" || E_RC=$?
-assert_not_contains "E2 absence is SILENT for the guard (N4)" "$(cat "$SB/e2/eerr.txt")" "repo-decl"
-
-cleanup_all
-assert_count "final: zero scratch residue" 0 "$(ls -d "$TROOT"/wp5b-test.* 2>/dev/null | wc -l | tr -d ' ')"
-
-echo
-echo "pass=$PASS fail=$FAIL"
-if [ "$FAIL" -gt 0 ]; then
-    echo "FAILED CASES:$FAILED_CASES"
-    exit 1
-fi
-echo "ALL GREEN"

packages/mosaic/framework/tools/git/test-wrapper-guard.sh

@@ -515,40 +515,12 @@ FIXTURES="$TMP/fixtures.tsv"
   printf '0\t{"tool_input":{"command":"curl -s https://git.example.invalid/api/v1/repos/a/b/issues?q=a%%20b"}}\ta percent-escape in a READ is not this hook'"'"'s business\n'
 } > "$FIXTURES"
 
-# Flake containment (#1380-FF, pipelines 2635/2637): a transient failure of the
-# ASSERTION TOOLING (grep rc>=2 — fork/alloc error under node pressure) is not a
-# contract drift, but the `if ! ... | grep -Fq` shape printed the identical
-# FAIL line for both, failing merge verifies on correct guard output. Classify
-# instead: retry tool errors 3x; rc=1 is the real mismatch; persistent tool
-# failure reports TOOL-ERROR (fail stays 1 — never green on infra noise — but
-# the line names the class so a re-run can be judged, not debugged).
-assert_out_contains() { # needle why
-  local attempt rc1
-  for attempt in 1 2 3; do
-    printf '%s' "$out" | grep -Fq -- "$1" && return 0
-    rc1=$?
-    [ "$rc1" -eq 1 ] && return 1   # grep answered NO — real mismatch
-    sleep 0.2                      # rc>=2: grep itself errored — retry
-  done
-  printf 'TOOL-ERROR %s (assertion grep failed 3x — infra/tooling, not guard drift)\n' "$2" >&2
-  return 2
-}
-
 fail=0 n=0
 while IFS=$'\t' read -r want payload why remedy; do
   [ -n "${want:-}" ] || continue
   n=$((n + 1))
   out="$(printf '%s' "$payload" | "$GUARD" 2>&1)"
   got=$?
-  # Flake containment (stack#1380-FF, pipeline 2635): a transient failure of
-  # the ASSERTION TOOLING (grep/fork/alloc error under node pressure) is not a
-  # contract drift, but this loop's `if !` shape made it indistinguishable
-  # from one — the harness printed the advice-mismatch FAIL and failed a merge
-  # verify on a run whose guard output was correct. Distinguish the two: an
-  # assertion tool that itself fails is retried a bounded number of times, and
-  # if it never succeeds the case reports a TOOL-ERROR line (fail=1 stays, so
-  # the run is never green-on-infra-noise, but the line names the real class
-  # and a re-run can be judged instead of debugged as a guard defect).
   if [ "$got" != "$want" ]; then
     printf 'FAIL  %s (want exit %s, got %s)\n' "$why" "$want" "$got"
     fail=1
@@ -558,15 +530,10 @@ while IFS=$'\t' read -r want payload why remedy; do
   # now it was invisible here: the harness read the exit code and nothing else,
   # so /issues/1/labels blocking with "use issue-create.sh" passed every run for
   # six rounds. Where a fixture states the remediation it expects, assert it.
-  if [ -n "${remedy:-}" ]; then
+  if [ -n "${remedy:-}" ] && ! printf '%s' "$out" | grep -Fq -- "$remedy"; then
-    assert_out_contains "$remedy" "$why"
+    printf 'FAIL  %s (blocked, but the advice does not name %s)\n' "$why" "$remedy"
-    arcret=$?
+    fail=1
-    if [ "$arcret" -eq 1 ]; then
+    continue
-      printf 'FAIL  %s (blocked, but the advice does not name %s)\n' "$why" "$remedy"
-      fail=1
-      continue
-    fi
-    [ "$arcret" -eq 0 ] || { fail=1; continue; }
   fi
   printf 'ok    %s\n' "$why"
 done < "$FIXTURES"
@@ -605,15 +572,10 @@ home_case() {
     fail=1
     return
   fi
-  if [ -n "$needle" ]; then
+  if [ -n "$needle" ] && ! printf '%s' "$out" | grep -Fq -- "$needle"; then
-    assert_out_contains "$needle" "$why"
+    printf 'FAIL  %s (exit %s, but the message does not say %s)\n' "$why" "$got" "$needle"
-    arcret=$?
+    fail=1
-    if [ "$arcret" -eq 1 ]; then
+    return
-      printf 'FAIL  %s (exit %s, but the message does not say %s)\n' "$why" "$got" "$needle"
-      fail=1
-      return
-    fi
-    [ "$arcret" -eq 0 ] || { fail=1; return; }
   fi
   printf 'ok    %s\n' "$why"
 }
@@ -703,15 +665,10 @@ lone_case() {
     fail=1
     return
   fi
-  if [ -n "$needle" ]; then
+  if [ -n "$needle" ] && ! printf '%s' "$out" | grep -Fq -- "$needle"; then
-    assert_out_contains "$needle" "$why"
+    printf 'FAIL  %s [standalone] (exit %s, but the message does not say %s)\n' "$why" "$got" "$needle"
-    arcret=$?
+    fail=1
-    if [ "$arcret" -eq 1 ]; then
+    return
-      printf 'FAIL  %s [standalone] (exit %s, but the message does not say %s)\n' "$why" "$got" "$needle"
-      fail=1
-      return
-    fi
-    [ "$arcret" -eq 0 ] || { fail=1; return; }
   fi
   printf 'ok    %s [standalone]\n' "$why"
 }

packages/mosaic/framework/tools/structure/test-validate-repo-json.sh

@@ -1,289 +0,0 @@
-#!/usr/bin/env bash
-# test-validate-repo-json.sh — hostile-input suite for the T51 declaration validator.
-# (Vendored with validate-repo-json.sh from mosaic-brain @ 515bcbab — see the
-# validator header for provenance.)
-#
-# Hermetic: all fixtures in a tracked mktemp sandbox removed by an EXIT trap
-# (pass and fail paths both — zero residue). No network, no real repos, no host
-# state mutated. MOSAIC_HOST_ROOT is set/unset per arm via env only.
-#
-# T51P2RW1: arms extended per review T51P2R1 (F1-F5): root gate for ordinary
-# v2 declarations (unset AND explicitly empty; display warns), git-grammar
-# branch arms (double slash, dot component, control byte), contract-escape
-# arms (list enums, invalid UTF-8, NaN — one VALIDATION_ERROR line, never a
-# traceback), remote normalization (.git/ ordering, port preservation), and
-# mirror-component fullmatch arms (trailing newline, control bytes).
-
-set -u
-
-HERE=$(cd "$(dirname "$0")" && pwd)
-V="$HERE/validate-repo-json.sh"
-
-PASS=0; FAIL=0; FAILED=""
-ok()  { PASS=$((PASS+1)); }
-bad() { FAIL=$((FAIL+1)); FAILED="$FAILED $1"; printf 'FAIL: %s\n' "$1" >&2; }
-
-SB=$(mktemp -d "${TMPDIR:-/tmp}/vrj-test.XXXXXX")
-trap 'rm -rf "$SB"' EXIT
-
-fx() { printf '%s' "$2" > "$SB/$1"; }
-
-run() { # [env KV=V ...] -- args...
-  local envs=()
-  while [ "$1" != "--" ]; do envs+=("$1"); shift; done; shift
-  OUT=$(env "${envs[@]:-_=_}" bash "$V" "$@" 2>&1 < /dev/null; echo "__RC__$?")
-  RC=${OUT##*__RC__}; OUT=${OUT%__RC__*}; OUT=${OUT%$'\n'}
-}
-expect_ok()   { local d="$1"; shift; run "$@"; if [ "$RC" = 0 ] && printf '%s' "$OUT" | grep -q '^OK'; then ok; else bad "$d (rc=$RC out=$(printf '%s' "$OUT" | head -1))"; fi; }
-expect_err() { # desc expected-substring [env... -- args...]
-  local d="$1" sub="$2"; shift 2
-  run "$@"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "VALIDATION_ERROR.*$sub"; then ok
-  else bad "$d (rc=$RC, wanted error ~$sub, got: ${OUT%%$'\n'*})"; fi
-}
-expect_err_notrace() { # like expect_err, plus no traceback anywhere in output
-  local d="$1" sub="$2"; shift 2
-  run "$@"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "VALIDATION_ERROR.*$sub" && ! printf '%s' "$OUT" | grep -q "Traceback"; then ok
-  else bad "$d (rc=$RC, wanted clean error ~$sub, got: ${OUT%%$'\n'*})"; fi
-}
-
-STACK='{"schema_version":2,"integration_trunk":"next","release_branch":"main","flow":"trunk-release","canonical_remote":"https://git.mosaicstack.dev/mosaicstack/stack","canonical_clone":"host:/src/mosaic-stack","worktree_root":"host:/src/mosaic-stack-worktrees","worktree_policy":"orchestrator-precreated","notes":"x"}'
-BRAIN='{"schema_version":2,"integration_trunk":"main","release_branch":"main","flow":"direct","canonical_remote":"https://git.example.invalid/acme/brain","canonical_clone":"host:/.mosaic","worktree_root":"host:/.mosaic-worktrees","worktree_policy":"orchestrator-precreated"}'
-ROOT="$SB/hostroot"; mkdir -p "$ROOT"
-
-echo "== (0) syntax + version =="
-bash -n "$V" && ok || bad "bash -n"
-run -- --version; [ "$RC" = 0 ] && case "$OUT" in validate-repo-json\ *) ok ;; *) bad "version output" ;; esac || bad "version rc"
-
-echo "== (1) spec examples: stack + brain OK (root set) =="
-fx stack.json "$STACK"; fx brain.json "$BRAIN"
-expect_ok a1 MOSAIC_HOST_ROOT=$ROOT -- "$SB/stack.json"
-expect_ok a2 MOSAIC_HOST_ROOT=$ROOT -- "$SB/brain.json"
-
-echo "== (2) malformed JSON (stable contract, no traceback) =="
-fx bad.json '{"schema_version": 2, '
-expect_err_notrace b1 "json:" -- "$SB/bad.json"
-fx arr.json '[1,2]'
-expect_err_notrace b2 "top level" -- "$SB/arr.json"
-printf '\xff\xfe{"schema_version":2}' > "$SB/utf8.json"
-expect_err_notrace b3 "UTF-8" MOSAIC_HOST_ROOT=$ROOT -- "$SB/utf8.json"
-fx nan.json '{"schema_version":NaN}'
-expect_err_notrace b4 "malformed JSON" MOSAIC_HOST_ROOT=$ROOT -- "$SB/nan.json"
-
-echo "== (3) unknown schema_version = ABSENT-loud =="
-fx v3.json "${STACK/schema_version\":2/schema_version\":3}"
-expect_err c1 "schema_version" MOSAIC_HOST_ROOT=$ROOT -- "$SB/v3.json"
-
-echo "== (4) v1 mode + authoring rule (v1 consumes no paths: no root needed) =="
-fx v1.json '{"integration_trunk":"next","release_branch":"main"}'
-expect_ok  d1 -- "$SB/v1.json"
-expect_err d2 "schema_version" -- --require-v2 "$SB/v1.json"
-fx v1x.json '{"integration_trunk":"next","release_branch":"main","notes":"no"}'
-expect_err d3 "x_extensions" -- "$SB/v1x.json"
-
-echo "== (5) unknown top-level key rejected; x_extensions home OK =="
-fx unk.json "${STACK%\}*},\"typo_key\":1}"
-expect_err e1 "typo_key" MOSAIC_HOST_ROOT=$ROOT -- "$SB/unk.json"
-fx ext.json "${STACK%\}*},\"x_extensions\":{\"future\":true}}"
-expect_ok e2 MOSAIC_HOST_ROOT=$ROOT -- "$SB/ext.json"
-
-echo "== (6) flow: required (no defaulting) + cross-field =="
-fx noflow.json "$(printf '%s' "$STACK" | python3 -c 'import json,sys; d=json.load(sys.stdin); del d["flow"]; print(json.dumps(d))')"
-expect_err f1 "flow" MOSAIC_HOST_ROOT=$ROOT -- "$SB/noflow.json"
-fx xdirect.json "${STACK/\"trunk-release\"/\"direct\"}"
-expect_err f2 "direct" MOSAIC_HOST_ROOT=$ROOT -- "$SB/xdirect.json"
-fx xtr.json "${BRAIN/\"direct\"/\"trunk-release\"}"
-expect_err f3 "trunk-release" MOSAIC_HOST_ROOT=$ROOT -- "$SB/xtr.json"
-
-echo "== (7) dot-segment / empty-segment / tilde escapes =="
-fx dots.json "${STACK/host:\/src\/mosaic-stack\"/host:/src/../secrets\"}"
-expect_err g1 "dot segment" MOSAIC_HOST_ROOT=$ROOT -- "$SB/dots.json"
-fx dot1.json "${STACK/host:\/src\/mosaic-stack\"/host:/src/./mosaic-stack\"}"
-expect_err g2 "dot segment" MOSAIC_HOST_ROOT=$ROOT -- "$SB/dot1.json"
-fx empty.json "${STACK/host:\/src\/mosaic-stack\"/host://src/mosaic-stack\"}"
-expect_err g3 "empty segment" MOSAIC_HOST_ROOT=$ROOT -- "$SB/empty.json"
-fx tild.json "${STACK/host:\/src\/mosaic-stack\"/~jw/src/mosaic-stack\"}"
-expect_err g4 "tilde" MOSAIC_HOST_ROOT=$ROOT -- "$SB/tild.json"
-fx tailslash.json "${STACK/host:\/src\/mosaic-stack\"/host:/src/mosaic-stack/\"}"
-expect_err g5 "empty segment" MOSAIC_HOST_ROOT=$ROOT -- "$SB/tailslash.json"
-fx noanchor.json "${STACK/host:\/src\/mosaic-stack\"//src/mosaic-stack\"}"
-expect_err g6 "host:/" MOSAIC_HOST_ROOT=$ROOT -- "$SB/noanchor.json"
-
-echo "== (8) branch-name grammar (delegated to git check-ref-format, F2) =="
-fx badbr.json "${STACK/\"next\"/\"bad..name\"}"
-expect_err h1 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/badbr.json"
-fx sp.json "${STACK/\"next\"/\"fea ture\"}"
-expect_err h2 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/sp.json"
-fx lock.json "${STACK/\"next\"/\"feature/x.lock\"}"
-expect_err h3 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/lock.json"
-fx slash.json "${STACK/\"next\"/\"feature/x\"}"
-expect_ok h4 MOSAIC_HOST_ROOT=$ROOT -- "$SB/slash.json"
-fx dslash.json "${STACK/\"next\"/\"feature//x\"}"
-expect_err h5 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/dslash.json"
-fx hidden.json "${STACK/\"next\"/\"feature/.hidden\"}"
-expect_err h6 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/hidden.json"
-fx ctrl.json "$(printf '%s' "$STACK" | python3 -c 'import json,sys; d=json.load(sys.stdin); d["integration_trunk"]="feature/\x01x"; print(json.dumps(d))')"
-expect_err h7 "branch name" MOSAIC_HOST_ROOT=$ROOT -- "$SB/ctrl.json"
-
-echo "== (8b) reflog shorthand rejected independent of ambient checkout history (B1) =="
-# Hermetic repo WITH checkout history: proves '@{-1}' (which git would expand to
-# 'main' from THIS repo's reflog) is still refused by the pre-delegation gate.
-HISTREPO="$SB/histrepo"; mkdir -p "$HISTREPO"
-(cd "$HISTREPO" && git init -q -b main . \
-  && git -c user.name=t -c user.email=t@t commit -q --allow-empty -m m \
-  && git checkout -q -b feature/x \
-  && git checkout -q main \
-  && git check-ref-format --branch "@{-1}" >/dev/null 2>&1 && echo "ambient-expandable" || echo "not-expandable") \
-  | grep -q ambient-expandable && ok || bad "fixture repo failed to make @{-1} expandable"
-fx atminus1.json "$(printf '%s' "$STACK" | python3 -c 'import json,sys; d=json.load(sys.stdin); d["integration_trunk"]="@{-1}"; print(json.dumps(d))')"
-# Run the validator from INSIDE the history repo via command substitution so the
-# assertion runs in the PARENT shell (T51P2R3 B1: the previous ( subshell ) form
-# mutated ok/bad counters only in a dead subshell — FAIL printed, suite rc 0).
-OUTX=$(cd "$HISTREPO" && MOSAIC_HOST_ROOT=$ROOT bash "$V" "$SB/atminus1.json" 2>&1 </dev/null; echo "__RC__$?")
-RCX=${OUTX##*__RC__}
-if [ "$RCX" = 1 ] && printf '%s' "$OUTX" | grep -q "VALIDATION_ERROR.*@{"; then ok
-else bad "@{-1} must be rejected inside a repo with checkout history (got rc=$RCX)"; fi
-fx atbrace.json "$(printf '%s' "$STACK" | python3 -c 'import json,sys; d=json.load(sys.stdin); d["integration_trunk"]="@{u}"; print(json.dumps(d))')"
-expect_err h9 "@{" MOSAIC_HOST_ROOT=$ROOT -- "$SB/atbrace.json"
-
-echo "== (9) canonical_remote: userinfo, list-type, normalization (F3/F4) =="
-fx user.json "${STACK/https:\/\/git.mosaicstack.dev/https:\/\/bot:s3cret@git.mosaicstack.dev}"
-expect_err_notrace i1 "userinfo" MOSAIC_HOST_ROOT=$ROOT -- "$SB/user.json"
-fx listflow.json "${STACK/\"trunk-release\"/[\"trunk-release\"]}"
-expect_err_notrace i2 "flow" MOSAIC_HOST_ROOT=$ROOT -- "$SB/listflow.json"
-fx listpol.json "${STACK/\"orchestrator-precreated\"/[\"tool-managed\"]}"
-expect_err_notrace i3 "worktree_policy" MOSAIC_HOST_ROOT=$ROOT -- "$SB/listpol.json"
-run -- --normalize-remote "HTTPS://Git.Example.Invalid/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.example.invalid/o/r" ] && ok || bad "norm .git/case ($OUT)"
-run -- --normalize-remote "https://git.mosaicstack.dev/mosaicstack/stack/"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.mosaicstack.dev/mosaicstack/stack" ] && ok || bad "norm trailing slash ($OUT)"
-run -- --normalize-remote "git.mosaicstack.dev/mosaicstack/stack"
-[ "$RC" = 1 ] && ok || bad "schemeless must fail"
-run -- --normalize-remote "HTTPS://Git.Example.Invalid/o/r.git/"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.example.invalid/o/r" ] && ok || bad "norm .git-then-slash ($OUT)"
-run -- --normalize-remote "https://Git.Example.Invalid:8443/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.example.invalid:8443/o/r" ] && ok || bad "port must be preserved ($OUT)"
-run -- --normalize-remote "https://[2001:db8::1]:8443/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://[2001:db8::1]:8443/o/r" ] && ok || bad "IPv6 must stay bracketed with port ($OUT)"
-run -- --normalize-remote "https://[2001:db8::1]/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://[2001:db8::1]/o/r" ] && ok || bad "IPv6 must stay bracketed ($OUT)"
-run -- --normalize-remote "https://Git.Example.Invalid:0/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.example.invalid:0/o/r" ] && ok || bad "explicit port 0 must be preserved ($OUT)"
-run -- --normalize-remote "https://[::1].evil.example/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "suffix after ] must be rejected (.evil.example)"
-run -- --normalize-remote "https://[::1]x:8443/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "suffix after ] must be rejected (x:8443)"
-run -- --normalize-remote "https://[::1]x/o/r.git"
-[ "$RC" = 1 ] && ok || bad "suffix after ] must be rejected (x)"
-echo "== (9b) IPvFuture bracketed authorities (R4-B1: guard keys off raw netloc) =="
-run -- --normalize-remote "https://[v1.fe80]/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://[v1.fe80]/o/r" ] && ok || bad "valid IPvFuture must keep brackets ($OUT)"
-run -- --normalize-remote "https://[vF.foo]:8443/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://[vf.foo]:8443/o/r" ] && ok || bad "valid IPvFuture+port must keep brackets ($OUT)"
-run -- --normalize-remote "https://[v1.fe80]evil/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "IPvFuture suffix must be rejected (evil)"
-run -- --normalize-remote "https://[v1.fe80].evil.example/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "IPvFuture suffix must be rejected (.evil.example)"
-run -- --normalize-remote "https://[vF.foo]x:8443/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "IPvFuture suffix must be rejected (x:8443)"
-echo "== (9d) non-bracketed authority grammar (R6-B1) =="
-for U in "https://:8443/o/r.git" "https://bad host/o/r.git" "https://bad^host/o/r.git" "https://bad\\host/o/r.git" "https://bad%zz/o/r.git" "https://bad%2/o/r.git" "https://bad%/o/r.git"; do
-  run -- --normalize-remote "$U"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "VALIDATION_ERROR canonical_remote"; then ok
-  else bad "non-bracketed authority must be rejected: $U (rc=$RC out=$OUT)"; fi
-done
-run -- --normalize-remote "https://git.mosaicstack.dev:9000/mosaicstack/stack"
-[ "$RC" = 0 ] && [ "$OUT" = "https://git.mosaicstack.dev:9000/mosaicstack/stack" ] && ok || bad "valid host:port unchanged ($OUT)"
-run -- --normalize-remote "https://192.168.1.10:8443/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://192.168.1.10:8443/o/r" ] && ok || bad "IPv4 reg-name stays valid ($OUT)"
-run -- --normalize-remote "https://bad%2Fx/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://bad%2fx/o/r" ] && ok || bad "complete %HH must stay legal, case-normalized ($OUT)"
-echo "== (9e) ASCII-only authority bytes (R7-B1) =="
-# isolated port arm (R8): VALID ASCII host + full-width-digit port ONLY —
-# unconfounded, so restoring Unicode-aware isdigit() goes red right here.
-run -- --normalize-remote "https://git.example.invalid:４４３/o/r.git"
-if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "ASCII digits only"; then ok
-else bad "full-width-digit port on a VALID host must be rejected with the port reason (rc=$RC out=$OUT)"; fi
-for U in "https://éxample.invalid/o/r.git" "https://例え.テスト/o/r.git" "https://full－width.invalid/o/r.git" "https://mosaic－stack.dev:４４３/o/r.git"; do
-  run -- --normalize-remote "$U"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "VALIDATION_ERROR canonical_remote"; then ok
-  else bad "non-ASCII authority must be rejected: $U (rc=$RC out=$OUT)"; fi
-done
-run -- --normalize-remote "https://xn--xample-9ua.invalid/o/r.git"
-[ "$RC" = 0 ] && [ "$OUT" = "https://xn--xample-9ua.invalid/o/r" ] && ok || bad "punycode xn-- host must stay legal ($OUT)"
-echo "== (9c) bracket-payload grammar + raw control bytes (R5-B1) =="
-for P in "v1. " "v1.a b" "v1.a^b" "v1.a\\b" "v1.%20" "not-an-ip" "::gg::1"; do
-  run -- --normalize-remote "https://[$P]/o/r.git"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "VALIDATION_ERROR canonical_remote"; then ok
-  else bad "bracket payload [$P] must be rejected (rc=$RC out=$OUT)"; fi
-done
-for CB in $'\t' $'\n' $'\r'; do
-  run -- --normalize-remote "https://[v1.a${CB}b]/o/r.git"
-  if [ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "control byte"; then ok
-  else bad "raw control byte must be rejected before urlsplit (rc=$RC out=$OUT)"; fi
-done
-run -- --normalize-remote "https://[v1.fe80%zone]/o/r.git"
-[ "$RC" = 1 ] && ok || bad "percent (not in RFC host grammar) must be rejected ($OUT)"
-run -- --normalize-remote "https://[fe80::1%eth0]/o/r.git"
-[ "$RC" = 1 ] && printf '%s' "$OUT" | grep -q "canonical_remote" && ok || bad "IPv6 zone-id (not RFC host grammar) must be rejected ($OUT)"
-
-echo "== (10) root gate: every v2 managed validation fails closed (F1) =="
-# NOTE (spec §4.5): host:/ paths resolve UNDER MOSAIC_HOST_ROOT by construction,
-# so tool-managed is not declarable today — the cross-check fails for every
-# host:/ root until the anchor scheme grows an outside-root form (J3 era).
-expect_err j1 "MOSAIC_HOST_ROOT" MOSAIC_HOST_ROOT= -- "$SB/stack.json"
-expect_err j2 "MOSAIC_HOST_ROOT" MOSAIC_HOST_ROOT= -- "$SB/brain.json"
-expect_err j3 "MOSAIC_HOST_ROOT" MOSAIC_HOST_ROOT= -- "$SB/stack.json"
-# rider (T51P2R2): genuine ABSENCE, not just explicitly empty — captured via
-# command substitution, asserted in the parent shell (no subshell-counter shape).
-OUTU=$(cd "$SB" && env -u MOSAIC_HOST_ROOT bash "$V" "$SB/stack.json" 2>&1 </dev/null; echo "__RC__$?")
-RCU=${OUTU##*__RC__}
-if [ "$RCU" = 1 ] && printf '%s' "$OUTU" | grep -q "VALIDATION_ERROR.*MOSAIC_HOST_ROOT"; then ok
-else bad "unset-by-absence root must fail closed in managed mode (rc=$RCU)"; fi
-run MOSAIC_HOST_ROOT= -- --mode display "$SB/stack.json"
-if [ "$RC" = 0 ] && printf '%s' "$OUT" | grep -q '^OK' && printf '%s' "$OUT" | grep -q "host root unset"; then ok
-else bad "display-mode unset must pass with the specified warning (rc=$RC)"; fi
-run MOSAIC_HOST_ROOT= -- --mode display "$SB/brain.json"
-if [ "$RC" = 0 ] && printf '%s' "$OUT" | grep -q "host root unset"; then ok
-else bad "display-mode warn missing for brain fixture"; fi
-TM='{"schema_version":2,"integration_trunk":"next","release_branch":"main","flow":"trunk-release","canonical_remote":"https://git.mosaicstack.dev/mosaicstack/stack","canonical_clone":"host:/src/mosaic-stack","worktree_root":"host:/src/mosaic-stack-worktrees","worktree_policy":"tool-managed"}'
-fx tm.json "$TM"; mkdir -p "$ROOT/src"
-expect_err j4 "inside MOSAIC_HOST_ROOT" MOSAIC_HOST_ROOT=$ROOT -- "$SB/tm.json"
-fx tm_noroot.json "$(printf '%s' "$TM" | python3 -c 'import json,sys; d=json.load(sys.stdin); del d["worktree_root"]; print(json.dumps(d))')"
-expect_err j5 "worktree_root" MOSAIC_HOST_ROOT=$ROOT -- "$SB/tm_noroot.json"
-echo "== (10b) symlink escape cannot fake outside-ness (B3 fix: lexical containment) =="
-OUTSIDE="$SB/outside-target"; mkdir -p "$OUTSIDE"
-ln -s "$OUTSIDE" "$ROOT/escape"
-TM_ESC="${TM/host:\/src\/mosaic-stack-worktrees/host:/escape/worktrees}"
-fx tmsym.json "$TM_ESC"
-expect_err j6 "inside MOSAIC_HOST_ROOT" MOSAIC_HOST_ROOT=$ROOT -- "$SB/tmsym.json"
-
-echo "== (11) mirror-path components: collision/delimiter/control fixtures (F5) =="
-run -- --mirror-path git.mosaicstack.dev mosaicstack stack
-[ "$RC" = 0 ] && [ "$OUT" = "projects/git.mosaicstack.dev/mosaicstack/stack/repo.json" ] && ok || bad "mirror path ok ($OUT)"
-expect_err k1 "mirror-component" -- --mirror-path "git.mosaicstack.dev" "a__b" "c"
-expect_err k2 "mirror-component" -- --mirror-path "git.mosaicstack.dev" "a" "b__c"
-expect_err k3 "mirror-component" -- --mirror-path "git.mosaicstack.dev/x" "a" "b"
-expect_err k4 "mirror-component" -- --mirror-path "git.mosaicstack.dev" "A" "B"
-expect_err k5 "mirror-component" -- --mirror-path "git.mosaicstack.dev" "" "stack"
-run -- --mirror-path git.mosaicstack.dev a b.c
-[ "$RC" = 0 ] && [ "$OUT" = "projects/git.mosaicstack.dev/a/b.c/repo.json" ] && ok || bad "distinct path ($OUT)"
-run -- --mirror-path $'git.example.invalid\n' owner repo
-[ "$RC" = 1 ] && ok || bad "trailing-newline host must be rejected (fullmatch)"
-run -- --mirror-path $'git.\texample' owner repo
-[ "$RC" = 1 ] && ok || bad "control-byte host must be rejected"
-
-echo "== (12) missing required keys =="
-for key in release_branch canonical_clone; do
-  fx miss.json "$(printf '%s' "$STACK" | python3 -c "import json,sys; d=json.load(sys.stdin); del d['$key']; print(json.dumps(d))")"
-  expect_err "l-$key" "$key" MOSAIC_HOST_ROOT=$ROOT -- "$SB/miss.json"
-done
-
-echo "== (13) absent file =="
-expect_err m1 "file" -- "$SB/nonexistent.json"
-
-echo
-echo "pass=$PASS fail=$FAIL"
-if [ "$FAIL" -gt 0 ]; then echo "FAILED:$FAILED"; exit 1; fi
-echo "ALL GREEN"

packages/mosaic/framework/tools/structure/validate-repo-json.sh

@@ -1,386 +0,0 @@
-#!/usr/bin/env bash
-# validate-repo-json.sh — declaration validator for T51 repo structure declarations.
-#
-# Spec of record: docs/plans/2026-08-23_repo-structure-declaration.md @ 1896adc1
-# (R3). Implements the spec's validation surface: schema v1/v2 (§1.2), host:/
-# path grammar with canonical segment normalization — empty/./.. rejected
-# BEFORE resolution — and tilde rejection (§1.2a), mirror path component
-# validation (§3.1), cross-field rules (§5.2), remote normalization (§5.3).
-#
-# PROVENANCE (T51 WP5c vendoring): ported verbatim from the mosaic-brain tree —
-# tools/repo-structure-decl/validate-repo-json.sh @ brain main merge 515bcbab
-# (PR 28, wave-1 R9 PASS, 101-arm suite green). This file is now the framework
-# home per spec §5.1 ("shipped in the framework package"); the brain copy is the
-# development origin. Re-sync rule: changes land here via reviewed PR and are
-# back-ported to the brain tree (or the brain copy retires) — never fork silently.
-# Validator version at port: 1.1.0+t51spec-r3+t51p2rw1 (R2-R8 rework included).
-# No operator literal appears in this file; the host root is read from
-# MOSAIC_HOST_ROOT configuration only.
-#
-# Unset-root semantics (spec §1.2a, fail-closed; T51P2R1 F1): v2 declarations
-# always consume a path (canonical_clone is required), so in --mode managed an
-# unset OR EMPTY MOSAIC_HOST_ROOT is a VALIDATION_ERROR for every v2 file —
-# not only tool-managed. In --mode display it warns and omits root-dependent
-# resolution; grammar checks still run.
-#
-# Error contract (T51P2R1 F3): every malformed input — bad UTF-8, non-RFC JSON
-# constants (NaN/Infinity), wrong-typed enums, anything unexpected — yields
-# exactly one stable VALIDATION_ERROR line and exit 1. No traceback ever
-# escapes. Branch names are validated by delegating to `git check-ref-format
-# --branch` (F2), translated into this contract.
-#
-# Usage:
-#   validate-repo-json.sh <repo.json> [--mode managed|display] [--require-v2]
-#   validate-repo-json.sh --mirror-path <host> <owner> <repo>   # §3.1 component check
-#   validate-repo-json.sh --normalize-remote <url>              # §5.3, prints normalized
-#   validate-repo-json.sh --version
-#
-# Output: OK (exit 0) | VALIDATION_ERROR <key>: <reason> (exit 1) | warnings on stderr.
-set -euo pipefail
-
-VERSION="1.1.0+t51spec-r3+t51p2rw1"
-
-if [ "${1:-}" = "--version" ]; then echo "validate-repo-json $VERSION"; exit 0; fi
-
-exec python3 - "$@" <<'PYEOF'
-import json, os, re, subprocess, sys, urllib.parse
-
-def err(key, reason):
-    print(f"VALIDATION_ERROR {key}: {reason}")
-    sys.exit(1)
-
-def warn(msg):
-    print(f"warning: {msg}", file=sys.stderr)
-
-def main():
-    ARGS = sys.argv[1:]
-    MODE = "managed"
-    REQUIRE_V2 = False
-
-    # ---- subcommands first (they take no file argument) ----
-    def check_mirror_components(host, owner, repo):
-        # fullmatch: '$' must bind at true end (F5 — a trailing newline must
-        # NOT pass); the charset excludes control bytes outright.
-        comp_re = re.compile(r"[a-z0-9][a-z0-9.-]*")
-        for label, value in (("host", host), ("owner", owner), ("repo", repo)):
-            if not isinstance(value, str) or not value or not comp_re.fullmatch(value):
-                err("mirror-component", f"{label} {value!r} fails §3.1 charset ^[a-z0-9][a-z0-9.-]*$ (fullmatch, no '/', no delimiter, no control bytes)")
-        return f"projects/{host}/{owner}/{repo}/repo.json"
-
-    def normalize_remote(url):
-        # R5-B1 part 1: reject raw control bytes BEFORE urlsplit — urlsplit
-        # silently strips TAB/LF/CR, so different input bytes would normalize
-        # to a different host. The raw bytes ARE the input; nothing may rewrite them.
-        for ch in url:
-            if ord(ch) < 0x20 or ord(ch) == 0x7F:
-                err("canonical_remote", "control byte in URL rejected before parsing (urlsplit would strip it and change the host)")
-        try:
-            p = urllib.parse.urlsplit(url)
-        except ValueError as e:
-            # py3.12 urlsplit itself validates bracketed hosts (ipaddress) and
-            # raises for garbage authorities — translate, never traceback.
-            err("canonical_remote", f"invalid URL authority: {e}")
-        if not p.scheme or not p.netloc:
-            err("canonical_remote", f"not a URL with scheme+host: {url!r}")
-        if p.username or p.password or "@" in (p.netloc or ""):
-            err("canonical_remote", "userinfo in URL is rejected (§5.3)")
-        scheme = p.scheme.lower()
-        # T51P2R4 B1: bracketing is detected from the RAW netloc ('[' prefix),
-        # not from a ':' in the parsed hostname — IPvFuture literals ([v1.fe80])
-        # contain no colon and must not bypass the raw-authority proof.
-        bracketed = p.netloc.startswith("[")
-        if bracketed:
-            # Prove the RAW authority is exactly '[host]' + optional ':port'
-            # (case-normalized); any text after ']' is hostile/truncated input,
-            # rejected — never silently rewritten.
-            import re as _re
-            import ipaddress as _ip
-            m = _re.fullmatch(r"\[([^\]]*)\](?::([0-9]+))?", p.netloc)
-            if not m:
-                err("canonical_remote", f"malformed bracketed authority {p.netloc!r}: text after ']' is rejected (no silent truncation)")
-            payload = m.group(1)
-            # R5-B1 part 2: the bracket payload must be a REAL RFC literal —
-            # an IPv6 address (ipaddress parse) or an IPvFuture literal
-            # ("v" + HEXDIG+ + "." + unreserved / sub-delims / ":" only).
-            # Anything else inside brackets is rejected, closing the payload
-            # grammar as a class.
-            if _re.fullmatch(r"v[0-9A-Fa-f]+\.[A-Za-z0-9._~!$&'()*+,;=:-]*", payload):
-                pass  # IPvFuture (case-normalized below)
-            elif _re.fullmatch(r"[0-9A-Fa-f:.]+", payload):
-                # strict IPv6 lexical form (hex/colon/dot only — ipaddress alone
-                # would also accept scoped zone-ids like fe80::1%eth0, which are
-                # not valid URI host grammar unless %25-encoded)
-                try:
-                    _ip.IPv6Address(payload)
-                except ValueError:
-                    err("canonical_remote",
-                        f"bracket payload {payload!r} is not a valid IPv6 address")
-            else:
-                err("canonical_remote",
-                    f"bracket payload {payload!r} is neither a valid IPv6 address nor an IPvFuture literal (v+HEXDIG+.+unreserved/sub-delims/colon)")
-            host = f"[{payload.lower()}]"  # brackets preserved (IPv6 + IPvFuture)
-        else:
-            # R6-B1: the non-bracketed branch — urlsplit PARSES but does not
-            # VALIDATE reg-name, and netloc-nonempty is not host presence.
-            # Split the raw authority ourselves (host[:port]) and validate the
-            # raw host against real grammar: unreserved / sub-delims / complete
-            # %HH octets (reg-name), or IPv4 dotted-quad (reg-name's numeric
-            # case). Port must be all digits. No branch trusts urlsplit alone.
-            import re as _re
-            raw_host, sep, raw_port = p.netloc.rpartition(":")
-            if sep and _re.fullmatch(r"[0-9]+", raw_port):
-                pass  # host:port split
-            elif sep:
-                err("canonical_remote", f"invalid port {raw_port!r} in authority {p.netloc!r} (ASCII digits only)")
-            else:
-                raw_host, raw_port = p.netloc, None
-            if not raw_host:
-                err("canonical_remote", f"empty host in authority {p.netloc!r}")
-            # strict reg-name / IPv4 scan: unreserved + sub-delims, with '%'
-            # only inside complete %HH octets (IPv4 dotted-quad is a subset of
-            # this charset — digits and dots — so one scan covers both).
-            import re as _re
-            i = 0
-            ok_host = True
-            while i < len(raw_host):
-                c = raw_host[i]
-                if c == "%":
-                    if i + 2 >= len(raw_host) or not _re.fullmatch(r"[0-9A-Fa-f]{2}", raw_host[i+1:i+3]):
-                        ok_host = False; break
-                    i += 3
-                elif c in "!$&'()*+,;=-._~" or ("a" <= c <= "z") or ("A" <= c <= "Z") or ("0" <= c <= "9"):
-                    # R7-B1: EXPLICIT ASCII only — str.isalnum() is Unicode-aware
-                    # and admits non-ASCII letters/digits (é, full-width ０). Policy
-                    # is ASCII-only reg-name; punycode xn-- is the sanctioned
-                    # Unicode spelling and remains legal under this charset.
-                    i += 1
-                else:
-                    ok_host = False; break
-            if not ok_host:
-                err("canonical_remote", f"host {raw_host!r} is not valid reg-name/IPv4 grammar (unreserved/sub-delims/complete %HH only)")
-            host = raw_host.lower()
-        port = p.port  # None when absent; preserved whenever explicitly present (B2: incl. 0)
-        authority = host + (f":{port}" if port is not None else "")
-        path = p.path or "/"
-        # canonical trailing-slash + .git strip as ONE operation (F4): slash
-        # first, then .git, then any slash exposed by that strip.
-        path = path.rstrip("/")
-        if path.endswith(".git"):
-            path = path[:-4].rstrip("/")
-        return f"{scheme}://{authority}{path or ''}"
-
-    if "--mirror-path" in ARGS:
-        idx = ARGS.index("--mirror-path")
-        parts = ARGS[idx + 1:]
-        if len(parts) != 3:
-            err("usage", "--mirror-path takes <host> <owner> <repo>")
-        print(check_mirror_components(*parts))
-        sys.exit(0)
-    if "--normalize-remote" in ARGS:
-        idx = ARGS.index("--normalize-remote")
-        vals = ARGS[idx + 1:]
-        if len(vals) != 1:
-            err("usage", "--normalize-remote takes <url>")
-        print(normalize_remote(vals[0]))
-        sys.exit(0)
-
-    # ---- arg parsing ----
-    if not ARGS:
-        err("usage", "a repo.json path is required")
-    path = None
-    i = 0
-    while i < len(ARGS):
-        a = ARGS[i]
-        if a == "--mode":
-            i += 1
-            if i >= len(ARGS) or ARGS[i] not in ("managed", "display"):
-                err("usage", "--mode takes managed|display")
-            MODE = ARGS[i]
-        elif a == "--require-v2":
-            REQUIRE_V2 = True
-        elif a.startswith("--"):
-            err("usage", f"unknown option {a}")
-        else:
-            if path is not None:
-                err("usage", "multiple file arguments")
-            path = a
-        i += 1
-    if path is None:
-        err("usage", "a repo.json path is required")
-
-    # ---- load: strict UTF-8, strict RFC JSON (F3) ----
-    try:
-        with open(path, "rb") as fh:
-            raw_bytes = fh.read()
-    except OSError as e:
-        err("file", str(e))
-    try:
-        raw = raw_bytes.decode("utf-8")
-    except UnicodeDecodeError as e:
-        err("json", f"invalid UTF-8: {e}")
-    def _reject_constant(name):
-        raise ValueError(f"non-RFC JSON constant {name}")
-    try:
-        doc = json.loads(raw, parse_constant=_reject_constant)
-    except (json.JSONDecodeError, ValueError) as e:
-        err("json", f"malformed JSON: {e}")
-    if not isinstance(doc, dict):
-        err("json", "top level must be an object")
-
-    HOST_ROOT = os.environ.get("MOSAIC_HOST_ROOT", "")
-
-    V1_KEYS = {"integration_trunk", "release_branch"}
-    V2_REQUIRED = ["schema_version", "integration_trunk", "release_branch", "flow",
-                   "canonical_remote", "canonical_clone"]
-    V2_OPTIONAL = {"worktree_root", "worktree_policy", "notes", "x_extensions"}
-    ENUM_FLOW = {"direct", "trunk-release"}
-    ENUM_POLICY = {"tool-managed", "orchestrator-precreated"}
-
-    def check_branch(key, value):
-        # Delegate the full git branch grammar to git itself (F2). B1: reject
-        # reflog shorthand BEFORE delegation — `git check-ref-format --branch
-        # '@{-n}'` expands from the CALLER repo's checkout history, making
-        # validation cwd-dependent; a persistent declaration must never bind
-        # to ambient reflog state.
-        if not isinstance(value, str) or not value:
-            err(key, "must be a non-empty string")
-        if "@{" in value:
-            err(key, f"{value!r} contains '@{{' reflog/namespace shorthand — declarations must be literal branch names (B1)")
-        if value.startswith("refs/heads/"):  # check-ref-format --branch strips this; we do not allow it
-            err(key, "bare branch name expected, not a full ref")
-        try:
-            r = subprocess.run(["git", "check-ref-format", "--branch", value],
-                               capture_output=True)
-        except OSError as e:
-            err(key, f"cannot invoke git check-ref-format: {e}")
-        if r.returncode != 0:
-            err(key, f"{value!r} is not a valid git branch name (git check-ref-format, §5.2)")
-
-    def check_host_path(key, value):
-        # §1.2a: host:/-anchored; canonical segment normalization; empty/./.. rejected
-        # BEFORE resolution; tilde rejected outright.
-        if not isinstance(value, str) or not value:
-            err(key, "must be a non-empty string")
-        if "~" in value:
-            err(key, "tilde-anchored path rejected (§1.2a: ~ binds to caller HOME)")
-        if not value.startswith("host:/"):
-            err(key, "must be host:/-anchored (§1.2a)")
-        rest = value[len("host:/"):]
-        if rest == "":
-            err(key, "no segments after host:/")
-        segments = rest.split("/")
-        for seg in segments:
-            if seg == "":
-                err(key, f"empty segment in {value!r} (canonical normalization, §1.2a)")
-            if seg in (".", ".."):
-                err(key, f"dot segment {seg!r} rejected before resolution (§1.2a)")
-        return segments
-
-    # ---- version ----
-    sv = doc.get("schema_version")
-    if "schema_version" in doc:
-        if not isinstance(sv, int) or isinstance(sv, bool):
-            err("schema_version", "must be an integer")
-        if sv not in (1, 2):
-            err("schema_version", f"unknown schema_version {sv} — treated as ABSENT per keep-list K3; update tooling")
-        version = sv
-    else:
-        version = 1
-        warn("schema_version absent → v1 compatibility mode (two keys only)")
-
-    if REQUIRE_V2 and version != 2:
-        err("schema_version", "CI authoring rule: new or edited declarations must declare schema_version 2")
-
-    # ---- v1 ----
-    if version == 1:
-        for k in V1_KEYS:
-            check_branch(k, doc.get(k))
-        extra = set(doc) - V1_KEYS
-        if extra:
-            err("x_extensions", f"unknown top-level keys in v1: {sorted(extra)}")
-        print("OK (v1)")
-        sys.exit(0)
-
-    # ---- v2 required ----
-    for k in V2_REQUIRED:
-        if k not in doc:
-            err(k, "required for v2 (§1.2)")
-
-    check_branch("integration_trunk", doc["integration_trunk"])
-    check_branch("release_branch", doc["release_branch"])
-
-    # type-check BEFORE membership (F3: list-typed enums must not traceback)
-    if not isinstance(doc["flow"], str) or doc["flow"] not in ENUM_FLOW:
-        err("flow", f"must be one of {sorted(ENUM_FLOW)} (§1.2, required — no defaulting, R7)")
-
-    unknown = set(doc) - set(V2_REQUIRED) - V2_OPTIONAL
-    if unknown:
-        err("x_extensions", f"unknown top-level keys {sorted(unknown)} — place extensions inside x_extensions")
-
-    if "worktree_policy" in doc and (not isinstance(doc["worktree_policy"], str)
-                                     or doc["worktree_policy"] not in ENUM_POLICY):
-        err("worktree_policy", f"must be one of {sorted(ENUM_POLICY)}")
-    if "notes" in doc and not isinstance(doc["notes"], str):
-        err("notes", "must be a string")
-    if "x_extensions" in doc and not isinstance(doc["x_extensions"], dict):
-        err("x_extensions", "must be an object")
-    for strkey in ("canonical_remote", "canonical_clone", "worktree_root"):
-        if strkey in doc and not isinstance(doc[strkey], str):
-            err(strkey, "must be a string")
-
-    # ---- remote (§5.3) ----
-    if not isinstance(doc["canonical_remote"], str):
-        err("canonical_remote", "must be a string")
-    else:
-        normalize_remote(doc["canonical_remote"])
-
-    # ---- paths (§1.2a) ----
-    canonical_segments = check_host_path("canonical_clone", doc["canonical_clone"])
-    wt_segments = None
-    if "worktree_root" in doc:
-        wt_segments = check_host_path("worktree_root", doc["worktree_root"])
-
-    # ---- cross-field (§5.2) ----
-    trunk, rel, flow = doc["integration_trunk"], doc["release_branch"], doc["flow"]
-    if flow == "direct" and trunk != rel:
-        err("flow", "direct requires integration_trunk == release_branch (§5.2)")
-    if flow == "trunk-release" and trunk == rel:
-        err("flow", "trunk-release requires integration_trunk != release_branch (§5.2)")
-
-    # ---- root gate (§1.2a fail-closed; T51P2R1 F1) ----
-    # Every v2 declaration consumes a path (canonical_clone is required), so
-    # managed mode cannot proceed without a provable host anchor. Display mode
-    # warns and omits root-dependent resolution only.
-    if not HOST_ROOT:
-        if MODE == "managed":
-            err("MOSAIC_HOST_ROOT",
-                "unset or empty — managed validation of a v2 declaration consumes paths "
-                "(canonical_clone required); fail closed (§1.2a, DR3 X2b)")
-        else:
-            warn("host root unset; root-dependent resolution omitted (display mode, §1.2a)")
-
-    if doc.get("worktree_policy") == "tool-managed":
-        if "worktree_root" not in doc:
-            err("worktree_policy", "tool-managed requires worktree_root (containment provable, §4.5)")
-        if HOST_ROOT:
-            root_real = os.path.realpath(HOST_ROOT)
-            # B3 fix: containment is tested on the LEXICAL normalized path, not
-            # on realpath of the joined result — a child symlink under the host
-            # root can no longer fake outside-ness. host:/ segments are always
-            # lexically under the root, so tool-managed fails universally until
-            # the anchor scheme grows a real outside-root form (J3 charter).
-            resolved = os.path.normpath(os.path.join(root_real, *wt_segments))
-            if resolved == root_real or resolved.startswith(root_real + os.sep):
-                err("worktree_policy",
-                    f"tool-managed worktree_root resolves inside MOSAIC_HOST_ROOT (§4.5: outside-root requirement)")
-        # no-root case: managed mode already failed at the gate above; display warned
-
-    print("OK")
-
-try:
-    main()
-except SystemExit:
-    raise
-except Exception as e:  # F3: no traceback may ever escape the contract
-    err("internal", f"input rejected (unexpected condition: {type(e).__name__})")
-PYEOF

packages/mosaic/framework/tools/tmux/send-message.sh

@@ -32,9 +32,7 @@
 #   0  delivered (submitted) or queued (agent busy; will process when free)
 #   1  tmux target not found
 #   2  submission NOT confirmed — either still an unsubmitted draft, or the REPL
-#      input box could not be located to confirm the message actually landed.
+#      input prompt could not be located to confirm the message actually landed.
-#      Locating the box is runtime-specific; see locate_input_box() below, and
-#      add a shape there before pointing this tool at a new runtime.
 #      Delivery is NEVER inferred from absence of evidence: if we cannot positively
 #      see the input box clear of the message (or the queued banner), we fail loud
 #      so the sender learns immediately instead of a silent worker->lead stall.
@@ -99,50 +97,10 @@ printf '%s' "$MSG" | "${tmux_cmd[@]}" load-buffer -b "$BUF" -
 #   would otherwise accumulate forever.
 sleep 0.5
 
-# Locate the REPL input box in a captured pane. Prints the box's contents on
-# stdout and returns 0 when the box was FOUND; returns 1 when it could not be
-# located at all. Found-but-empty is a real, distinct answer (an empty input box
-# is what a submitted message leaves behind), so the caller must branch on the
-# return code, never on whether the output is empty.
-#
-# Two REPL shapes are recognised:
-#   * a prompt-glyph line — `❯`, a leading `>`, or `│ >`. Claude Code and most
-#     readline REPLs.
-#   * a box drawn as two horizontal `─` rules with the input between them and NO
-#     prompt glyph anywhere. pi renders this. Anchoring on the LAST rule pair is
-#     what makes it safe: agent output can contain its own rules, but nothing is
-#     drawn below the input box except the status line.
-#
-# Adding a runtime means adding its shape HERE. A shape that is missing does not
-# degrade gracefully: it turns every send to that runtime into a false
-# "may be UNDELIVERED", which is what #1362 measured on pi and #1257 on another
-# arm of the same probe.
-locate_input_box() {
-  local pane=$1 glyph_line rule_lines top bottom
-  glyph_line=$(printf '%s\n' "$pane" | grep -E '❯|^>|│ >' | tail -1)
-  if [ -n "$glyph_line" ]; then printf '%s\n' "$glyph_line"; return 0; fi
-  rule_lines=$(printf '%s\n' "$pane" | grep -nE '^[[:space:]]*─{4,}[[:space:]]*$' | cut -d: -f1 | tail -2)
-  [ -n "$rule_lines" ] || return 1
-  # Split the (at most two) captured line numbers with parameter expansion. Not
-  # `head -1`: piping into an early-exiting consumer SIGPIPEs the producer, which
-  # under `set -euo pipefail` aborts the caller with rc=141 and no output. The
-  # scripts/pipefail-early-exit.test.mjs guard reds on that shape, correctly.
-  # With one rule captured both halves resolve to the same value and the
-  # ordering test below rejects it, which is the answer we want anyway.
-  top=${rule_lines%%$'\n'*}
-  bottom=${rule_lines##*$'\n'}
-  [ "$top" != "$bottom" ] || return 1
-  [ "$bottom" -gt "$top" ] || return 1
-  # An empty range (adjacent rules) prints nothing and still returns 0: found,
-  # empty, which is the delivered shape.
-  printf '%s\n' "$pane" | sed -n "$((top + 1)),$((bottom - 1))p"
-  return 0
-}
-
 # 2) Submit, then POSITIVELY confirm submission; flush with another Enter if it is
 #    still a draft. Success requires positive evidence — the queued banner, OR the
 #    REPL input box located AND clear of our message tail. The historical bug was
-#    treating ABSENCE of a draft as delivery: if the input box was never located
+#    treating ABSENCE of a draft as delivery: if the prompt glyph was never matched
 #    (wrong pane / prompt-glyph drift), an unsubmitted message read as "delivered"
 #    and worker->lead relays stalled silently. We now default to UNCONFIRMED and only
 #    upgrade to delivered on positive evidence; anything we cannot confirm fails loud.
@@ -155,14 +113,15 @@ for attempt in $(seq 1 $((RETRIES + 1))); do
   if grep -qF "$QUEUED_RE" <<<"$pane"; then
     status="queued"; break
   fi
-  # If we cannot see the input box, we have NO evidence of submission state —
+  # Locate the REPL input box (prompt glyph). If we cannot see it, we have NO
-  # stay UNCONFIRMED and retry; never infer delivery.
+  # evidence of submission state — stay UNCONFIRMED and retry; never infer delivery.
-  if ! inputbox=$(locate_input_box "$pane"); then
+  promptline=$(printf '%s' "$pane" | grep -E '❯|^>|│ >' | tail -1)
+  if [ -z "$promptline" ]; then
     status="unconfirmed"; continue
   fi
   # Input box located AND still carrying our tail => unsubmitted draft. Flush + retry.
-  # (Submitted messages scroll up into history; a draft stays in the box.)
+  # (Submitted messages scroll up into history; a draft stays on the ❯ line.)
-  if [ -n "$snippet" ] && grep -qF "$snippet" <<<"$inputbox"; then
+  if [ -n "$snippet" ] && grep -qF "$snippet" <<<"$promptline"; then
     status="draft"; continue
   fi
   # Input box located AND clear of our tail => positively submitted. This is the
@@ -176,6 +135,6 @@ case "$status" in
   delivered)   echo "✓ delivered to $TARGET"; exit 0 ;;
   queued)      echo "✓ queued to $TARGET (agent busy — will process when it returns to prompt)"; exit 0 ;;
   draft)       echo "✗ still an unsubmitted draft on $TARGET after $RETRIES flush attempts" >&2; exit 2 ;;
-  unconfirmed) echo "✗ could not confirm submission on $TARGET: REPL input box not locatable after $((RETRIES + 1)) attempts — message may be UNDELIVERED (check target/pane, retry, or escalate)" >&2; exit 2 ;;
+  unconfirmed) echo "✗ could not confirm submission on $TARGET: REPL input prompt not locatable after $((RETRIES + 1)) attempts — message may be UNDELIVERED (check target/pane, retry, or escalate)" >&2; exit 2 ;;
   *)           echo "✗ could not confirm submission on $TARGET (unexpected state '$status')" >&2; exit 2 ;;
 esac

packages/mosaic/framework/tools/tmux/test-send-message-verdict.sh

@@ -10,13 +10,6 @@
 #                    "could not confirm submission").
 #   3. DRAFT       — a `❯ `-prompt pane that never submits (message stays on the
 #                    input line) => exit 2, stderr "unsubmitted draft".
-#   4. DELIVERED   — a pane whose input box is two `─` rules with NO prompt glyph
-#      (box shape)   anywhere (pi's shape) and which submits => exit 0. Pre-#1362
-#                    the glyph probe could not see this box at all, so EVERY send
-#                    to such a pane reported "may be UNDELIVERED" while landing.
-#   5. DRAFT       — the same glyphless box, holding our tail across every flush
-#      (box shape)   Enter => exit 2, stderr "unsubmitted draft". Pre-#1362 this
-#                    also reported unconfirmed, so the true state was invisible.
 set -uo pipefail
 
 HERE=$(cd -- "$(dirname -- "$0")" && pwd)
@@ -76,56 +69,6 @@ else
   fi
 fi
 
-# --- Fixtures 4 and 5: a pi-shaped pane. The input box is two `─` rules with the
-#     text between them and NO prompt glyph anywhere, so the glyph probe alone can
-#     never locate it and every send reports "may be UNDELIVERED" (#1362). The
-#     renderer below is the shape, not the runtime: MODE=clear submits (box empties),
-#     MODE=keep leaves the text sitting in the box.
-cat > "$TMP/pibox.sh" <<'PIBOX'
-#!/usr/bin/env bash
-MODE=${1:-clear}
-RULE=$(printf '─%.0s' $(seq 1 60))
-buf=""
-draw() {
-  printf '\033[H\033[2J'
-  printf 'fixture output line\n\n'
-  printf '%s\n' "$RULE"
-  printf '%s\n' "$buf"
-  printf '%s\n' "$RULE"
-  printf '~/fixture (main)\n'
-  printf 'tok 0 model fixture\n'
-}
-draw
-while IFS= read -r line; do
-  # keep: hold the tail across every flush Enter, which is what a stuck draft does.
-  if [ "$MODE" = keep ]; then [ -n "$line" ] && buf=$line; else buf=""; fi
-  draw
-done
-PIBOX
-chmod +x "$TMP/pibox.sh"
-
-tmux -L "$SOCKET" new-session -d -s pibox -c "$TMP" "exec bash '$TMP/pibox.sh' clear"
-sleep 0.3
-out=$("$SEND" -L "$SOCKET" -t "=pibox" -m "pi fixture four delivered ok" 2>"$TMP/e4"); rc=$?
-if [ "$rc" -eq 0 ] && grep -qF "✓ delivered" <<<"$out"; then
-  ok "delivered: glyphless box-drawn REPL that submits => exit 0 ✓ delivered"
-else
-  no "delivered: glyphless box-drawn REPL that submits => exit 0 ✓ delivered" "rc=$rc out=[$out] err=[$(cat "$TMP/e4")]"
-fi
-
-tmux -L "$SOCKET" new-session -d -s piboxdraft -c "$TMP" "exec bash '$TMP/pibox.sh' keep"
-sleep 0.3
-if out=$("$SEND" -L "$SOCKET" -t "=piboxdraft" -r 1 -m "pi fixture five stuck in the box" 2>"$TMP/e5"); then
-  no "draft: glyphless box-drawn pane holding our tail must NOT report success" "expected exit 2, got 0 (out=[$out])"
-else
-  rc=$?
-  if [ "$rc" -eq 2 ] && grep -qF "unsubmitted draft" "$TMP/e5"; then
-    ok "draft: message left in a glyphless box => exit 2 + 'unsubmitted draft'"
-  else
-    no "draft: message left in a glyphless box => exit 2 + stderr" "rc=$rc err=[$(cat "$TMP/e5")]"
-  fi
-fi
-
 echo "---"
 echo "PASS=$PASS FAIL=$FAIL"
 [ "$FAIL" -eq 0 ]

packages/mosaic/package.json

@@ -25,7 +25,7 @@
     "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 framework/tools/quality/scripts/test-framework-drift-check.py && bash framework/tools/quality/scripts/test-framework-drift-doctor.sh && bash framework/systemd/user/test-fleet-units.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/lease-broker/revoke_noop_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-edit.sh && bash framework/tools/git/test-pr-create-fallback-default-base.sh && bash framework/tools/git/test-repo-decl-consumption.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-no-status.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-ci-queue-wait-no-ci-expected.sh && bash framework/tools/git/test-pr-merge-queue-branch.sh && bash framework/tools/git/test-pr-merge-no-ci-expected.sh && bash framework/tools/git/test-pr-merge-fork-ci-status.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/git/test-explain-diagnostic-status-neutral.sh && bash framework/tools/git/test-detect-platform-outside-repo.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 && bash framework/tools/_scripts/test-brain-home-check.sh && bash framework/tools/_scripts/test-structure-anchor-check.sh && bash framework/tools/fleet/test-agent-session-broker-preflight.sh && bash framework/tools/fleet/test-agent-session-legacy-socket-guard.sh"
+    "test:framework-shell": "bash framework/tools/quality/scripts/check-test-enumeration.sh && bash framework/tools/quality/scripts/test-check-test-enumeration.sh && python3 framework/tools/quality/scripts/test-framework-drift-check.py && bash framework/tools/quality/scripts/test-framework-drift-doctor.sh && bash framework/systemd/user/test-fleet-units.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/lease-broker/revoke_noop_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-edit.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-no-status.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-fork-ci-status.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/git/test-explain-diagnostic-status-neutral.sh && bash framework/tools/git/test-detect-platform-outside-repo.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 && bash framework/tools/_scripts/test-brain-home-check.sh && bash framework/tools/fleet/test-agent-session-broker-preflight.sh"
   },
   "dependencies": {
     "@mosaicstack/brain": "workspace:*",

packages/mosaic/src/commands/fleet-roster-v2-dispatch.spec.ts

@@ -211,23 +211,12 @@ describe('mosaic fleet install — roster v2', (): void => {
 describe('[email protected]', (): void => {
   const unitPath = resolve(process.cwd(), 'framework', 'systemd', 'user', '[email protected]');
 
-  /**
+  /** The single `ConditionPathExists=` value declared by the unit template. */
-   * Every `ConditionPathExists=` value declared by the unit template, in file
+  async function conditionPath(): Promise<string> {
-   * order, `|` triggering prefix included.
-   *
-   * Until #1410 this helper pinned `toHaveLength(1)` — a count assertion, not
-   * a content assertion, and the count pin was itself the defect: when #1408
-   * required a second triggering line (the `%h/.mosaic` brain-home shape),
-   * this spec was a second consumer of the unit template that the shell suite
-   * and the enumeration guard could not see, so the fix failed here first
-   * (CI 2651 — the installation-documentation.spec.ts lesson again). Assert
-   * content per line, never count.
-   */
-  async function conditionPaths(): Promise<string[]> {
     const unit = await readFile(unitPath, 'utf8');
     const matches = unit.match(/^ConditionPathExists=(.+)$/gm) ?? [];
-    expect(matches.length).toBeGreaterThan(0);
+    expect(matches).toHaveLength(1);
-    return matches.map((line) => line.slice('ConditionPathExists='.length).trim());
+    return matches[0]!.slice('ConditionPathExists='.length).trim();
   }
 
   it('will not attempt a seat before the reconciler has written its env', async (): Promise<void> => {
@@ -235,26 +224,7 @@ describe('[email protected]', (): void => {
     // unit (WantedBy=default.target) but does not start it, so without this
     // condition a reboot between `install` and the first `apply` would run
     // ExecStart against an absent env file and fail every seat unit.
-    //
+    expect(await conditionPath()).toBe('%h/.config/mosaic/fleet/agents/%i.env.generated');
-    // Two lines since #1408: the env projection lives under %h/.config/mosaic
-    // on framework-home hosts and under %h/.mosaic on brain-home hosts. Both
-    // carry the `|` triggering prefix — systemd ANDs same-type conditions
-    // unless every line is triggering (then they OR), and a bare spelling
-    // would demand BOTH home shapes on one host, which is never true, so
-    // every seat would silently skip.
-    expect(await conditionPaths()).toEqual([
-      '|%h/.config/mosaic/fleet/agents/%i.env.generated',
-      '|%h/.mosaic/fleet/agents/%i.env.generated',
-    ]);
-  });
-
-  it('refuses the bare ANDed spelling on every condition line', async (): Promise<void> => {
-    // Invariant ported from test-fleet-units.sh, held separately from the
-    // literal pin above so it survives future edits to the path set: every
-    // ConditionPathExists line must stay triggering (`|`).
-    for (const value of await conditionPaths()) {
-      expect(value.startsWith('|')).toBe(true);
-    }
   });
 
   /**
@@ -276,18 +246,10 @@ describe('[email protected]', (): void => {
    */
   it('guards exactly the file the fleet writes, so the two cannot drift apart', async (): Promise<void> => {
     const mosaicHome = await v2Home();
-    const rendered = (await conditionPaths()).map((value) =>
+    const rendered = (await conditionPath()).replace('%h', tempHome!).replace('%i', 'coder0');
-      value.replace(/^\|/, '').replace('%h', tempHome!).replace('%i', 'coder0'),
-    );
 
-    // Per home shape, the guard must render to exactly the file the
+    // The path an installed fleet actually places for this agent.
-    // reconciler writes there: mosaicHome (%h/.config/mosaic) on
+    expect(rendered).toBe(join(mosaicHome, 'fleet', 'agents', 'coder0.env.generated'));
-    // framework-home hosts, %h/.mosaic on brain-home hosts (#1408) — each
-    // line pinned to its file, not merely present.
-    expect(rendered).toEqual([
-      join(mosaicHome, 'fleet', 'agents', 'coder0.env.generated'),
-      join(tempHome!, '.mosaic', 'fleet', 'agents', 'coder0.env.generated'),
-    ]);
   });
 
   it('guards a real failure — the launcher rejects an absent generated env', async (): Promise<void> => {

packages/mosaic/src/commands/gateway/install.ts

@@ -15,7 +15,6 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { ClackPrompter } from '../../prompter/clack-prompter.js';
-import type { VerifyResult } from './verify.js';
 import type { WizardState } from '../../types.js';
 
 interface InstallOpts {
@@ -90,23 +89,13 @@ export async function runInstall(opts: InstallOpts): Promise<void> {
     prompter.log(`  Logs:      mosaic gateway logs`);
     prompter.log(`  Status:    mosaic gateway status`);
 
-    // Post-install verification (CU-07-03). Health/token/bootstrap failures
+    // Post-install verification (CU-07-03) — non-fatal.
-    // stay non-fatal (courtesy checks), but a FAILED database schema check is
-    // fatal (#1392): an install that reports success over an empty/partial
-    // database is the exact T63 failure this command must never reproduce.
-    let verifyResult: VerifyResult | undefined;
     try {
       const { runPostInstallVerification } = await import('./verify.js');
-      verifyResult = await runPostInstallVerification(configResult.host, configResult.port);
+      await runPostInstallVerification(configResult.host, configResult.port);
     } catch {
       // Non-fatal — verification is a courtesy
     }
-    if (verifyResult && verifyResult.schemaMigrated === false) {
-      prompter.warn(
-        'Gateway install ABORTED: database schema verification failed (remediation above).',
-      );
-      process.exit(1);
-    }
   } catch (err) {
     // Stages normally return structured results for expected failures.
     // Anything that reaches here is an unexpected runtime error — render a

packages/mosaic/src/commands/gateway/schema-check.spec.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  checkDatabaseSchema,
-  SCHEMA_FAIL_REMEDIATION,
-  type SchemaCheckDeps,
-} from './schema-check.js';
-
-/* ------------------------------------------------------------------ */
-/*  Fixture config                                                     */
-/* ------------------------------------------------------------------ */
-
-const tmpDirs: string[] = [];
-
-function writeConfig(cfg: Record<string, unknown>): string {
-  const dir = mkdtempSync(join(tmpdir(), 'schema-check-'));
-  tmpDirs.push(dir);
-  const path = join(dir, 'mosaic.config.json');
-  writeFileSync(path, JSON.stringify(cfg));
-  return path;
-}
-
-const STANDALONE_CFG = {
-  tier: 'standalone',
-  storage: { type: 'postgres', url: 'postgresql://u:p@localhost:5434/x' },
-  queue: { type: 'bullmq', url: 'redis://localhost:6380' },
-  memory: { type: 'keyword' },
-};
-
-const LOCAL_CFG = {
-  tier: 'local',
-  storage: { type: 'pglite', dataDir: '.mosaic/storage-pglite' },
-  queue: { type: 'local', dataDir: '.mosaic/queue' },
-  memory: { type: 'keyword' },
-};
-
-function deps(overrides: Partial<SchemaCheckDeps> = {}): SchemaCheckDeps {
-  return {
-    runMigrations: vi.fn().mockResolvedValue(undefined),
-    getMigrationStatus: vi.fn().mockResolvedValue({
-      appliedCount: 17,
-      expectedCount: 17,
-      expectedLastTag: '0016_x',
-      complete: true,
-    }),
-    ...overrides,
-  };
-}
-
-/* ------------------------------------------------------------------ */
-/*  Tests                                                              */
-/* ------------------------------------------------------------------ */
-
-describe('checkDatabaseSchema', () => {
-  beforeEach(() => {
-    process.env['MOSAIC_CONFIG'] = '';
-    vi.stubEnv('DATABASE_URL', 'postgresql://env:env@localhost:9999/env');
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-    for (const d of tmpDirs.splice(0)) rmSync(d, { recursive: true, force: true });
-  });
-
-  it('passes when the ledger matches the shipped journal', async () => {
-    const cfg = writeConfig(STANDALONE_CFG);
-    const d = deps();
-    const result = await checkDatabaseSchema(d, cfg);
-    expect(result.status).toBe('ok');
-    expect(result.detail).toContain('17/17');
-    expect(d.runMigrations).toHaveBeenCalledWith(STANDALONE_CFG.storage.url);
-    expect(d.getMigrationStatus).toHaveBeenCalledWith(STANDALONE_CFG.storage.url);
-  });
-
-  it('FAILS when the ledger is incomplete — the #1389 empty-database signature', async () => {
-    const cfg = writeConfig(STANDALONE_CFG);
-    const d = deps({
-      getMigrationStatus: vi.fn().mockResolvedValue({
-        appliedCount: 0,
-        expectedCount: 17,
-        expectedLastTag: '0016_x',
-        complete: false,
-      }),
-    });
-    const result = await checkDatabaseSchema(d, cfg);
-    expect(result.status).toBe('fail');
-    if (result.status !== 'fail') throw new Error('expected fail');
-    expect(result.detail).toContain('0/17');
-    expect(result.remediation).toBe(SCHEMA_FAIL_REMEDIATION);
-    expect(result.remediation).toContain('#1389');
-  });
-
-  it('FAILS when the ledger is only PARTIALLY migrated (#1402 upgrade case)', async () => {
-    const cfg = writeConfig(STANDALONE_CFG);
-    const d = deps({
-      getMigrationStatus: vi.fn().mockResolvedValue({
-        appliedCount: 9,
-        expectedCount: 17,
-        expectedLastTag: '0016_x',
-        complete: false,
-      }),
-    });
-    const result = await checkDatabaseSchema(d, cfg);
-    expect(result.status).toBe('fail');
-    expect(result.detail).toContain('9/17');
-  });
-
-  it('FAILS (never crashes) when the migration run itself throws', async () => {
-    const cfg = writeConfig(STANDALONE_CFG);
-    const d = deps({
-      runMigrations: vi.fn().mockRejectedValue(new Error('connection refused')),
-    });
-    const result = await checkDatabaseSchema(d, cfg);
-    expect(result.status).toBe('fail');
-    expect(result.detail).toContain('connection refused');
-  });
-
-  it('skips the local tier (gateway migrates its own PGlite at startup)', async () => {
-    const cfg = writeConfig(LOCAL_CFG);
-    const d = deps();
-    const result = await checkDatabaseSchema(d, cfg);
-    expect(result.status).toBe('skipped');
-    expect(d.runMigrations).not.toHaveBeenCalled();
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  Config resolution priority                                         */
-/* ------------------------------------------------------------------ */
-
-describe('resolveSchemaCheckConfigPath', () => {
-  it('prefers the daemon-written gateway config over cwd copies', async () => {
-    const { resolveSchemaCheckConfigPath } = await import('./schema-check.js');
-    const cwdCfg = writeConfig(STANDALONE_CFG); // in a temp dir
-    const daemonDir = mkdtempSync(join(tmpdir(), 'schema-check-daemon-'));
-    tmpDirs.push(daemonDir);
-    const daemonHome = join(daemonDir, '.config', 'mosaic', 'gateway');
-    mkdirSync(daemonHome, { recursive: true });
-    writeFileSync(join(daemonHome, 'mosaic.config.json'), JSON.stringify(LOCAL_CFG));
-
-    const prevHome = process.env['HOME'];
-    vi.stubEnv('HOME', daemonDir);
-    vi.stubEnv('MOSAIC_CONFIG', '');
-    try {
-      const resolved = resolveSchemaCheckConfigPath();
-      // Must NOT pick the cwd copy (cwd is the vitest project dir, not our
-      // temp dir — so the only resolvable candidates are daemon + $HOME/.mosaic).
-      expect(resolved).toBe(join(daemonHome, 'mosaic.config.json'));
-      void cwdCfg;
-    } finally {
-      if (prevHome !== undefined) vi.stubEnv('HOME', prevHome);
-    }
-  });
-});

packages/mosaic/src/commands/gateway/schema-check.ts

@@ -1,107 +0,0 @@
-/**
- * Install-time database schema verification (#1392).
- *
- * Fresh standalone (postgres) installs once ended "healthy" with a completely
- * empty database: the resolved dependency set shipped no migrations at all
- * (#1389), the gateway started fine, and nothing failed until the first real
- * query. The issue's own conclusion: the installer must "instruct and verify".
- *
- * This check runs AFTER migrations have been (re-)applied, so the only way it
- * fails is a genuinely broken migration set or database — which is exactly
- * when install must not report success. Failure is fatal by design (fast-fail
- * STANDARDS); callers print the remediation text and exit non-zero.
- */
-
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { loadConfig } from '@mosaicstack/config';
-
-export interface SchemaStatusCounts {
-  appliedCount: number;
-  expectedCount: number;
-  expectedLastTag: string;
-  complete: boolean;
-}
-
-/** Injectable migration surface — keeps this unit-testable without a DB. */
-export interface SchemaCheckDeps {
-  runMigrations(url: string): Promise<void>;
-  getMigrationStatus(url: string): Promise<SchemaStatusCounts>;
-}
-
-export type SchemaCheckResult =
-  | { status: 'ok'; detail: string }
-  | { status: 'skipped'; detail: string }
-  | { status: 'fail'; detail: string; remediation: string };
-
-export const SCHEMA_FAIL_REMEDIATION = [
-  'The gateway database does not carry the full schema.',
-  'Causes seen in the wild: dependency set resolved without migrations (#1389), or a partially-migrated database (#1402).',
-  'Remediation:',
-  '  1. Re-run: mosaic gateway install  (applies migrations and verifies again)',
-  '  2. Check the resolved @mosaicstack/db version is the same pipeline as the gateway (npm ls -g @mosaicstack/db)',
-  '  3. Manual apply: run runMigrations() from @mosaicstack/db against the storage URL, then re-verify',
-].join('\n');
-
-/**
- * Resolve the config the INSTALLED gateway would use — same priority the
- * daemon applies (apps/gateway/src/env.ts resolveGatewayConfigPath), minus
- * the source-tree anchors that do not exist on an installed host. Verifying
- * against any other config could green-light a database the daemon never
- * reads (#1392: verify what runs, not what happens to lie in cwd).
- */
-export function resolveSchemaCheckConfigPath(explicit?: string): string | undefined {
-  if (explicit) return resolve(explicit);
-  const candidates = [
-    process.env['MOSAIC_CONFIG'],
-    join(homedir(), '.config', 'mosaic', 'gateway', 'mosaic.config.json'), // daemon-written
-    resolve(process.cwd(), 'mosaic.config.json'),
-    join(homedir(), '.mosaic', 'mosaic.config.json'),
-  ];
-  for (const c of candidates) {
-    if (c && existsSync(c)) return c;
-  }
-  return undefined; // loadConfig falls back to env-var detection
-}
-
-export async function checkDatabaseSchema(
-  deps: SchemaCheckDeps,
-  configPath?: string,
-): Promise<SchemaCheckResult> {
-  const config = loadConfig(resolveSchemaCheckConfigPath(configPath));
-
-  // Local tier: the gateway itself runs PGlite migrations at startup (see
-  // DatabaseModule.onModuleInit), and a broken local tier fails the health
-  // check instead. Nothing for the installer to verify here.
-  if (config.storage.type !== 'postgres') {
-    return {
-      status: 'skipped',
-      detail: 'database schema (local tier — migrated by gateway at startup)',
-    };
-  }
-
-  const url = config.storage.url;
-  try {
-    await deps.runMigrations(url);
-    const status = await deps.getMigrationStatus(url);
-    if (status.complete) {
-      return {
-        status: 'ok',
-        detail: `database schema (${status.appliedCount.toString()}/${status.expectedCount.toString()} migrations)`,
-      };
-    }
-    return {
-      status: 'fail',
-      detail: `database schema incomplete (${status.appliedCount.toString()}/${status.expectedCount.toString()} applied, last expected: ${status.expectedLastTag})`,
-      remediation: SCHEMA_FAIL_REMEDIATION,
-    };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return {
-      status: 'fail',
-      detail: `database schema check errored: ${msg}`,
-      remediation: SCHEMA_FAIL_REMEDIATION,
-    };
-  }
-}

packages/mosaic/src/commands/gateway/verify.ts

@@ -44,8 +44,6 @@ export interface VerifyResult {
   gatewayHealthy: boolean;
   adminTokenOnFile: boolean;
   bootstrapReachable: boolean;
-  /** False only on a FAILED postgres schema check; true when ok or skipped. */
-  schemaMigrated: boolean;
   allPassed: boolean;
 }
 
@@ -91,36 +89,7 @@ export async function runPostInstallVerification(
     fail('bootstrap endpoint reach', 'Run: mosaic gateway status  /  mosaic gateway logs');
   }
 
-  // ─── Check 4: Database schema migrated (#1392) ────────────────────────────
+  const allPassed = gatewayHealthy && adminTokenOnFile && bootstrapReachable;
-  // Fatal-on-failure for install: the #1389 failure mode was an install that
-  // reported success over an empty database. Local tiers skip (the gateway
-  // migrates its own PGlite at startup and would fail health if it couldn't).
-  let schemaMigrated = true;
-  try {
-    const { checkDatabaseSchema } = await import('./schema-check.js');
-    const { runMigrations, getMigrationStatus } = await import('@mosaicstack/db');
-    const result = await checkDatabaseSchema(
-      { runMigrations, getMigrationStatus },
-      process.env['MOSAIC_CONFIG'],
-    );
-    if (result.status === 'ok') {
-      ok(result.detail);
-    } else if (result.status === 'skipped') {
-      ok(result.detail);
-    } else {
-      fail(result.detail, result.remediation);
-      schemaMigrated = false;
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    fail(
-      `database schema check errored: ${msg}`,
-      'See #1392/#1389; re-run: mosaic gateway install',
-    );
-    schemaMigrated = false;
-  }
-
-  const allPassed = gatewayHealthy && adminTokenOnFile && bootstrapReachable && schemaMigrated;
 
   if (!allPassed) {
     console.log(
@@ -129,7 +98,7 @@ export async function runPostInstallVerification(
     );
   }
 
-  return { gatewayHealthy, adminTokenOnFile, bootstrapReachable, schemaMigrated, allPassed };
+  return { gatewayHealthy, adminTokenOnFile, bootstrapReachable, allPassed };
 }
 
 /**

packages/mosaic/src/fleet/comms-onboarding.spec.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   chmodSync,
   mkdtempSync,
@@ -16,7 +16,6 @@ import {
   renderPeerReach,
   readFleetCommsBlock,
   resolveCommsBlock,
-  resolveFleetIdentity,
   resolvePeerCommand,
   renderToolsContractStatus,
 } from './comms-onboarding.js';
@@ -62,68 +61,6 @@ describe('shared fleet roster v1 resolver', () => {
     });
   });
 
-  // stack#1380 verification unblock: the fleet's own roster-v2 tooling writes
-  // the v1 body plus a generation fence and seat lifecycle/launch envelopes.
-  // The parser tolerates exactly that envelope (validated, opaque to comms).
-  const V2_ROSTER = [
-    'version: 2',
-    'generation: 8',
-    'transport: tmux',
-    'tmux:',
-    '  socket_name: mosaic-fleet',
-    'defaults:',
-    '  working_directory: ~/.mosaic',
-    '  runtime: claude',
-    'agents:',
-    '  - name: orch-01',
-    '    runtime: claude',
-    '    class: orchestrator',
-    '    model: opus',
-    '    reasoning: high',
-    '    lifecycle:',
-    '      enabled: true',
-    '      desired_state: running',
-    '    launch:',
-    '      yolo: false',
-    '',
-  ].join('\n');
-
-  it('accepts the roster-v2 envelope (generation + lifecycle/launch) on the v1 body', () => {
-    const resolved = parseFleetRosterV1(V2_ROSTER, 'yaml');
-    expect(resolved.tmux.socketName).toBe('mosaic-fleet');
-    expect(resolved.agents[0]?.name).toBe('orch-01');
-  });
-
-  it('rejects a non-integer generation', () => {
-    expect(() =>
-      parseFleetRosterV1(V2_ROSTER.replace('generation: 8', 'generation: eight'), 'yaml'),
-    ).toThrow(/generation must be a non-negative integer/);
-  });
-
-  it('rejects an invalid lifecycle desired_state', () => {
-    expect(() =>
-      parseFleetRosterV1(
-        V2_ROSTER.replace('desired_state: running', 'desired_state: paused'),
-        'yaml',
-      ),
-    ).toThrow(/desired_state must be running\|stopped/);
-  });
-
-  it('rejects unknown fields inside the lifecycle envelope', () => {
-    expect(() =>
-      parseFleetRosterV1(
-        V2_ROSTER.replace('      enabled: true', '      enabled: true\n      surprise: 1'),
-        'yaml',
-      ),
-    ).toThrow(/lifecycle has unknown field/);
-  });
-
-  it('rejects a non-boolean launch.yolo', () => {
-    expect(() =>
-      parseFleetRosterV1(V2_ROSTER.replace('yolo: false', 'yolo: sometimes'), 'yaml'),
-    ).toThrow(/launch\.yolo must be a boolean/);
-  });
-
   it('rejects unknown fields instead of leniently constructing a second roster view', () => {
     expect(() => parseFleetRosterV1(`${ROSTER}\nunknown: value\n`, 'yaml')).toThrow(
       /unknown field/i,
@@ -556,11 +493,6 @@ describe('resolvePeerCommand', () => {
 describe('readFleetCommsBlock — spawned-agent context', () => {
   let home: string;
   beforeEach(() => {
-    // Hermetic helper fallback (stack#1380): the resolver probes
-    // $HOME/.config/mosaic when mosaicHome itself carries no helper — point
-    // HOME at a sandbox parent so tests never see the real host install.
-    vi.stubEnv('HOME', mkdtempSync(join(tmpdir(), 'mosaic-homeless-')));
-    vi.stubEnv('MOSAIC_HOME', '');
     home = mkdtempSync(join(tmpdir(), 'mosaic-comms-'));
     mkdirSync(join(home, 'fleet'), { recursive: true });
     mkdirSync(join(home, 'tools', 'tmux'), { recursive: true });
@@ -569,10 +501,7 @@ describe('readFleetCommsBlock — spawned-agent context', () => {
     writeFileSync(helper, '#!/bin/sh\n');
     chmodSync(helper, 0o755);
   });
-  afterEach(() => {
+  afterEach(() => rmSync(home, { recursive: true, force: true }));
-    vi.unstubAllEnvs();
-    rmSync(home, { recursive: true, force: true });
-  });
 
   it('uses the authoritative self host and global socket from the shared roster resolver', () => {
     const result = readFleetCommsBlock(home, 'enhancer', 'process-host-must-not-win');
@@ -635,27 +564,23 @@ describe('readFleetCommsBlock — spawned-agent context', () => {
       },
     ],
     [
-      'symlink escaping the install home',
+      'symlink',
       () => {
         const helper = join(home, 'tools', 'tmux', 'agent-send.sh');
         rmSync(helper);
-        const outside = mkdtempSync(join(tmpdir(), 'mosaic-helper-outside-'));
+        writeFileSync(join(home, 'real-send.sh'), '#!/bin/sh\n');
-        writeFileSync(join(outside, 'real-send.sh'), '#!/bin/sh\n', { mode: 0o755 });
+        symlinkSync(join(home, 'real-send.sh'), helper);
-        symlinkSync(join(outside, 'real-send.sh'), helper);
       },
     ],
     ['non-executable', () => chmodSync(join(home, 'tools', 'tmux', 'agent-send.sh'), 0o644)],
-  ])(
+  ])('fails closed for a %s helper with deterministic repair guidance', (_case, mutate) => {
-    'fails closed for a %s helper with deterministic guidance (no forbidden remedy)',
+    mutate();
-    (_case, mutate) => {
+    const result = readFleetCommsBlock(home, 'enhancer', 'w-jarvis');
-      mutate();
+    expect(result.ok).toBe(false);
-      const result = readFleetCommsBlock(home, 'enhancer', 'w-jarvis');
+    expect(result.output).toBe('');
-      expect(result.ok).toBe(false);
+    expect(result.error).toContain('mosaic update --repair-tools');
-      expect(result.output).toBe('');
+    expect(result.error).toContain('no active context or session was rewritten');
-      expect(result.error).not.toContain('--repair-tools'); // stack#1380 M5a
+  });
-      expect(result.error).toContain('no active context or session was rewritten');
-    },
-  );
 
   it('does not rewrite the roster while resolving context', () => {
     const path = join(home, 'fleet', 'roster.yaml');
@@ -678,11 +603,11 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
   });
   afterEach(() => rmSync(home, { recursive: true, force: true }));
 
-  it('names operator-verified recovery instead of a forbidden remedy when installed TOOLS.md is missing', () => {
+  it('uses the supported repair command when installed TOOLS.md is missing', () => {
     const status = renderToolsContractStatus(home);
-    expect(status).toContain('authorized operator');
+    expect(status).toContain('mosaic update --repair-tools');
-    expect(status).not.toContain('--repair-tools'); // stack#1380 M5a
     expect(status).not.toContain('--reseed');
+    expect(status).toContain('authorized operator');
   });
 
   it('reports stale preserved content without rewriting it', () => {
@@ -691,8 +616,8 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
     writeFileSync(path, stale);
     const status = renderToolsContractStatus(home);
     expect(status).toContain('fleet-comms-contract: 1');
-    expect(status).toContain('authorized operator');
+    expect(status).toContain('digest-qualified backup');
-    expect(status).not.toContain('--repair-tools'); // stack#1380 M5a
+    expect(status).toContain('mosaic update --repair-tools');
     expect(status).toContain('active context was not rewritten');
     expect(readFileSync(path, 'utf8')).toBe(stale);
   });
@@ -723,7 +648,7 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
     expect(renderToolsContractStatus(home)).not.toBe('');
   });
 
-  it('reads an installed TOOLS.md symlink whose validated target diverges (stack#1380 resolve-then-validate)', () => {
+  it('treats installed TOOLS.md symlinks as stale without following or rewriting them', () => {
     const external = join(home, 'external-tools.md');
     const externalContent = '# external\n<!-- fleet-comms-contract: 1 -->\n';
     writeFileSync(external, externalContent);
@@ -731,23 +656,24 @@ describe('renderToolsContractStatus — non-mutating install drift', () => {
 
     const status = renderToolsContractStatus(home);
 
-    expect(status).toContain('does not byte-match');
+    expect(status).toContain('unavailable');
+    expect(status).toContain('mosaic update --repair-tools');
     expect(readFileSync(external, 'utf8')).toBe(externalContent);
   });
 
-  it('treats a source TOOLS.md symlink escaping the install home as unavailable', () => {
+  it('treats source TOOLS.md symlinks as unavailable without following them', () => {
-    const outside = mkdtempSync(join(tmpdir(), 'mosaic-source-outside-'));
+    const external = join(home, 'external-source.md');
     const content = '# authoritative tools\n<!-- fleet-comms-contract: 1 -->\n';
-    writeFileSync(join(outside, 'external-source.md'), content);
+    writeFileSync(external, content);
     rmSync(join(home, 'defaults', 'TOOLS.md'));
-    symlinkSync(join(outside, 'external-source.md'), join(home, 'defaults', 'TOOLS.md'));
+    symlinkSync(external, join(home, 'defaults', 'TOOLS.md'));
     writeFileSync(join(home, 'TOOLS.md'), content);
 
     const status = renderToolsContractStatus(home);
 
     expect(status).toContain('source contract');
     expect(status).toContain('unavailable');
-    expect(readFileSync(join(outside, 'external-source.md'), 'utf8')).toBe(content);
+    expect(readFileSync(external, 'utf8')).toBe(content);
   });
 
   it('accepts byte-equal bounded source and installed contracts', () => {
@@ -804,91 +730,3 @@ describe('resolveCommsBlock — mosaic agent comms-block', () => {
     expect(result.error).toContain('requires');
   });
 });
-
-describe('resolveFleetIdentity — stack#1380 split-home layouts', () => {
-  // Brain-shaped mosaicHome (fleet state, NO tools/tmux) + framework config
-  // home carrying the helper, roster unified by the framework-created symlink
-  // <configHome>/fleet/roster.yaml -> <brain>/fleet/roster.yaml. This is the
-  // host layout that was down; all probes are POSITIONAL per the #1380
-  // verification protocol (an object arg proves nothing — M5b). HOME is
-  // stubbed so the config-default fallback stays inside the sandbox.
-  let brain: string;
-  let configHome: string;
-
-  beforeEach(() => {
-    const parent = mkdtempSync(join(tmpdir(), 'mosaic-i1380-parent-'));
-    brain = join(parent, 'brain');
-    // Framework home at the stubbed DEFAULT location so the fallback derives
-    // exactly as in production ($HOME/.config/mosaic), not by coincidence.
-    configHome = join(parent, 'home', '.config', 'mosaic');
-    vi.stubEnv('HOME', join(parent, 'home'));
-    vi.stubEnv('MOSAIC_HOME', '');
-    mkdirSync(join(brain, 'fleet'), { recursive: true });
-    writeFileSync(join(brain, 'fleet', 'roster.yaml'), ROSTER, { mode: 0o600 });
-    mkdirSync(join(configHome, 'fleet'), { recursive: true });
-    symlinkSync(join(brain, 'fleet', 'roster.yaml'), join(configHome, 'fleet', 'roster.yaml'));
-    mkdirSync(join(configHome, 'tools', 'tmux'), { recursive: true });
-    writeFileSync(join(configHome, 'tools', 'tmux', 'agent-send.sh'), '#!/bin/sh\n', {
-      mode: 0o755,
-    });
-    process.env['MOSAIC_BRAIN_HOME'] = brain;
-  });
-
-  afterEach(() => {
-    delete process.env['MOSAIC_BRAIN_HOME'];
-    vi.unstubAllEnvs();
-    rmSync(join(brain, '..'), { recursive: true, force: true });
-  });
-
-  it('resolves a member through the roster symlink under the config home', () => {
-    const result = resolveFleetIdentity(configHome, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.identity?.member.name).toBe('orchestrator');
-    expect(result.identity?.agentSendPath).toBe(join(configHome, 'tools', 'tmux', 'agent-send.sh'));
-  });
-
-  it('resolves a member when mosaicHome is the brain (helper found under the framework home)', () => {
-    const result = resolveFleetIdentity(brain, 'enhancer', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.identity?.member.name).toBe('enhancer');
-    expect(result.identity?.agentSendPath).toBe(join(configHome, 'tools', 'tmux', 'agent-send.sh'));
-  });
-
-  it('no-name control stays a quiet no-op', () => {
-    expect(resolveFleetIdentity(configHome, undefined, 'w-jarvis')).toEqual({ ok: true });
-    expect(resolveFleetIdentity(brain, undefined, 'w-jarvis')).toEqual({ ok: true });
-  });
-
-  it('a nonce name fails naming membership, not the symlink or the helper', () => {
-    const result = resolveFleetIdentity(configHome, 'nonce-' + Date.now(), 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).not.toContain('symbolic link');
-    expect(result.error).not.toContain('helper');
-    expect(result.error).toContain('nonce-');
-  });
-
-  it('a non-member failure names membership, not the symlink (protocol control)', () => {
-    const result = resolveFleetIdentity(configHome, 'jarvis', 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).not.toContain('symbolic link');
-    expect(result.error).not.toContain('helper is unavailable');
-    expect(result.error).toContain('orchestrator'); // known-member listing
-  });
-
-  it('names every searched framework home when the helper is missing everywhere', () => {
-    rmSync(join(configHome, 'tools'), { recursive: true, force: true });
-    const result = resolveFleetIdentity(brain, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(false);
-    expect(result.error).toContain('agent-send.sh');
-    expect(result.error).toContain(join(brain, 'tools', 'tmux', 'agent-send.sh'));
-    expect(result.error).not.toContain('--repair-tools');
-  });
-
-  it('readFleetCommsBlock composes the full contract on the split-home layout', () => {
-    const result = readFleetCommsBlock(configHome, 'orchestrator', 'w-jarvis');
-    expect(result.ok).toBe(true);
-    expect(result.output).toContain(
-      'Helper: `' + join(configHome, 'tools', 'tmux', 'agent-send.sh'),
-    );
-  });
-});

packages/mosaic/src/fleet/comms-onboarding.ts

@@ -9,9 +9,8 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { homedir, hostname } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { readRegularFileSecure } from './secure-file.js';
-import { resolveBrainHome } from './brain-home.js';
 import {
   parseFleetRosterV1,
   resolveInstalledFleetRosterPath,
@@ -261,13 +260,7 @@ context and have an authorized operator relaunch only this exact roster member w
 
 function validateAgentSendHelper(path: string, mosaicHome: string): string | undefined {
   try {
-    readRegularFileSecure(path, {
+    readRegularFileSecure(path, { root: mosaicHome, executable: true });
-      root: mosaicHome,
-      executable: true,
-      // The helper tree may live under the framework config home while this
-      // caller's mosaicHome is the brain; both are framework-owned roots.
-      symlinkTargetRoots: [resolveBrainHome(mosaicHome)],
-    });
     return undefined;
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
@@ -275,48 +268,8 @@ function validateAgentSendHelper(path: string, mosaicHome: string): string | und
   }
 }
 
-/**
- * Framework install homes probed for tools/tmux/agent-send.sh (stack#1380 M2).
- * The helper ships with the FRAMEWORK install, which on split-home layouts is
- * the config home — not the brain (~/.mosaic carries fleet state, no tools).
- */
-function frameworkHelperHomes(mosaicHome: string): string[] {
-  const homes = [resolve(mosaicHome)];
-  const envHome = process.env['MOSAIC_HOME'];
-  if (envHome && envHome.trim() !== '' && resolve(envHome) !== resolve(mosaicHome)) {
-    homes.push(resolve(envHome));
-  }
-  const configDefault = join(homedir(), '.config', 'mosaic');
-  if (resolve(configDefault) !== resolve(mosaicHome)) homes.push(configDefault);
-  return homes;
-}
-
-function resolveAgentSendHelper(mosaicHome: string): { path: string; error?: string } {
-  const homes = frameworkHelperHomes(mosaicHome);
-  for (const home of homes) {
-    const helper = join(home, 'tools', 'tmux', 'agent-send.sh');
-    if (!existsSync(helper)) continue;
-    const error = validateAgentSendHelper(helper, home);
-    if (!error) return { path: helper };
-    // Present but unsafe: surface that verdict instead of silently probing on.
-    return { path: helper, error };
-  }
-  return {
-    path: join(resolve(mosaicHome), 'tools', 'tmux', 'agent-send.sh'),
-    error:
-      `fleet helper agent-send.sh was not found under any framework install home ` +
-      `(${homes.map((h) => join(h, 'tools', 'tmux', 'agent-send.sh')).join('; ')}). ` +
-      `Verify the framework install for this host (the helper ships with the framework ` +
-      `config home; the brain home carries fleet state, not tools) and have an authorized ` +
-      `operator restore it if missing.`,
-  };
-}
-
 function helperFailureGuidance(reason: string): string {
-  // stack#1380 M5a: `mosaic update --repair-tools` is a forbidden remedy on the
+  return `${reason}. Run \`mosaic update --repair-tools\` to restore the supported current-version helper and TOOLS contract, then retry exact-member composition; no active context or session was rewritten.`;
-  // affected estate (and wrong for a layout/missing-helper failure). Name the
-  // actual recovery shape instead.
-  return `${reason}. Verify the framework install provides tools/tmux/agent-send.sh under the framework config home and that the roster resolves (split-home layouts symlink the roster into the brain); contact the operator if it persists; no active context or session was rewritten.`;
 }
 
 export function resolveFleetIdentity(
@@ -325,15 +278,9 @@ export function resolveFleetIdentity(
   localHost: string = shortHostname(),
 ): FleetIdentityResult {
   if (!requestedName) return { ok: true };
-  const helper = resolveAgentSendHelper(mosaicHome);
+  const agentSendPath = join(mosaicHome, 'tools', 'tmux', 'agent-send.sh');
-  if (helper.error) return { ok: false, error: helperFailureGuidance(helper.error) };
+  const helperError = validateAgentSendHelper(agentSendPath, mosaicHome);
-  const agentSendPath = helper.path;
+  if (helperError) return { ok: false, error: helperFailureGuidance(helperError) };
-
-  // Split-home layouts unify the roster by symlinking
-  // <configHome>/fleet/roster.yaml -> <brain>/fleet/roster.yaml. The secure
-  // read resolves that framework-created symlink when the brain is a
-  // sanctioned target root (stack#1380 M1).
-  const rosterSymlinkRoots = [resolveBrainHome(mosaicHome)];
 
   let rosterPath: string;
   try {
@@ -354,10 +301,7 @@ export function resolveFleetIdentity(
   let roster: FleetRoster;
   try {
     roster = parseFleetRosterV1(
-      readRegularFileSecure(rosterPath, {
+      readRegularFileSecure(rosterPath, { root: mosaicHome }).content.toString('utf8'),
-        root: mosaicHome,
-        symlinkTargetRoots: rosterSymlinkRoots,
-      }).content.toString('utf8'),
       rosterPath.endsWith('.json') ? 'json' : 'yaml',
     );
   } catch (error) {
@@ -455,9 +399,7 @@ function boundedContractDigest(
 }
 
 function replacementGuidance(): string {
-  // stack#1380 M5a: never recommend the forbidden --repair-tools remedy from
+  return `Run \`mosaic update --repair-tools\` to make a digest-qualified backup and restore the supported current-version TOOLS contract, then have an authorized operator explicitly relaunch the exact roster member. The active context was not rewritten.`;
-  // error text; name the operator-verified recovery shape instead.
-  return `Verify the installed TOOLS contract against the framework source with an authorized operator (the installed file must byte-match the supported current version) and have the operator explicitly relaunch the exact roster member. The active context was not rewritten.`;
 }
 
 /** Detect preserved installed TOOLS.md drift without changing it. */

packages/mosaic/src/fleet/fleet-roster-v1.ts

@@ -7,7 +7,6 @@ import { canonicalizeRoleClass } from '../commands/fleet-personas.js';
 interface RawFleetRoster {
   version?: unknown;
   transport?: unknown;
-  generation?: unknown;
   tmux?: {
     socket_name?: unknown;
     socketName?: unknown;
@@ -42,10 +41,6 @@ interface RawFleetRoster {
     resetBetweenTasks?: unknown;
     kickstart_template?: unknown;
     kickstartTemplate?: unknown;
-    model?: unknown;
-    reasoning?: unknown;
-    lifecycle?: { enabled?: unknown; desired_state?: unknown };
-    launch?: { yolo?: unknown };
   }>;
   connector?: {
     kind?: unknown;
@@ -221,17 +216,7 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
     'runtimes',
     'agents',
     'connector',
-    // stack#1380 verification unblock: the fleet's own roster-v2 mutation
-    // tooling writes a `generation` fence on the same v1 body. Tolerated here
-    // as an opaque non-negative integer; comms semantics are unchanged.
-    'generation',
   ]);
-  if (
-    raw.generation !== undefined &&
-    (typeof raw.generation !== 'number' || !Number.isInteger(raw.generation) || raw.generation < 0)
-  ) {
-    throw new Error('Fleet roster generation must be a non-negative integer.');
-  }
   if (raw.tmux !== undefined) {
     assertObject(raw.tmux, 'Fleet roster tmux');
     assertKnownKeys(raw.tmux, 'Fleet roster tmux', [
@@ -246,8 +231,6 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
     assertKnownKeys(raw.defaults, 'Fleet roster defaults', [
       'working_directory',
       'workingDirectory',
-      // stack#1380 verification unblock: roster-v2 default runtime hint.
-      'runtime',
     ]);
   }
   if (raw.runtimes !== undefined) {
@@ -260,9 +243,7 @@ function normalizeFleetRosterV1Unchecked(raw: RawFleetRoster): FleetRoster {
       ]);
     }
   }
-  if (raw.version !== 1 && raw.version !== 2) {
+  if (raw.version !== 1) throw new Error('Fleet roster version must be 1.');
-    throw new Error('Fleet roster version must be 1 or 2.');
-  }
   if (raw.transport !== 'tmux') throw new Error('Fleet roster transport must be "tmux".');
   if (!Array.isArray(raw.agents) || raw.agents.length === 0) {
     throw new Error('Fleet roster must define at least one agent.');
@@ -337,52 +318,7 @@ function normalizeAgent(raw: NonNullable<RawFleetRoster['agents']>[number]): Fle
     'resetBetweenTasks',
     'kickstart_template',
     'kickstartTemplate',
-    // stack#1380 verification unblock: roster-v2 envelope fields written by
-    // the fleet's own mutation tooling. Validated, then opaque to comms.
-    'model',
-    'reasoning',
-    'lifecycle',
-    'launch',
   ]);
-  if (raw.model !== undefined && typeof raw.model !== 'string') {
-    throw new Error('Fleet roster agent model must be a string.');
-  }
-  if (raw.reasoning !== undefined && typeof raw.reasoning !== 'string') {
-    throw new Error('Fleet roster agent reasoning must be a string.');
-  }
-  const lifecycle = raw.lifecycle as { enabled?: unknown; desired_state?: unknown } | undefined;
-  if (lifecycle !== undefined) {
-    if (typeof lifecycle !== 'object' || lifecycle === null) {
-      throw new Error('Fleet roster agent lifecycle must be an object.');
-    }
-    const lifecycleKeys = Object.keys(lifecycle);
-    if (!lifecycleKeys.every((key) => key === 'enabled' || key === 'desired_state')) {
-      throw new Error('Fleet roster agent lifecycle has unknown field(s).');
-    }
-    if (lifecycle.enabled !== undefined && typeof lifecycle.enabled !== 'boolean') {
-      throw new Error('Fleet roster agent lifecycle.enabled must be a boolean.');
-    }
-    if (
-      lifecycle.desired_state !== undefined &&
-      (typeof lifecycle.desired_state !== 'string' ||
-        !['running', 'stopped'].includes(lifecycle.desired_state))
-    ) {
-      throw new Error('Fleet roster agent lifecycle.desired_state must be running|stopped.');
-    }
-  }
-  const launch = raw.launch as { yolo?: unknown } | undefined;
-  if (launch !== undefined) {
-    if (typeof launch !== 'object' || launch === null) {
-      throw new Error('Fleet roster agent launch must be an object.');
-    }
-    const launchKeys = Object.keys(launch);
-    if (!launchKeys.every((key) => key === 'yolo')) {
-      throw new Error('Fleet roster agent launch has unknown field(s).');
-    }
-    if (launch.yolo !== undefined && typeof launch.yolo !== 'boolean') {
-      throw new Error('Fleet roster agent launch.yolo must be a boolean.');
-    }
-  }
   const name = stringValue(raw.name, '', 'Fleet roster agent name');
   const runtime = stringValue(
     raw.runtime,

packages/mosaic/src/fleet/secure-file.spec.ts

@@ -10,14 +10,12 @@ import {
   type PathLike,
 } from 'node:fs';
 import type * as NodeFs from 'node:fs';
-import type { Stats } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 
 interface FilesystemRaceState {
   afterLstat?: (path: string) => void;
   afterOpen?: (path: string) => void;
-  afterStat?: (path: string, stats: Stats) => Stats;
 }
 
 const filesystemRaceState = vi.hoisted<FilesystemRaceState>(() => ({}));
@@ -31,10 +29,6 @@ vi.mock('node:fs', async (importOriginal) => {
       filesystemRaceState.afterLstat?.(String(path));
       return result;
     },
-    statSync: (path: PathLike) => {
-      const result = actual.statSync(path);
-      return filesystemRaceState.afterStat?.(String(path), result) ?? result;
-    },
     openSync: (path: PathLike, flags: string | number, mode?: number) => {
       const fd = actual.openSync(path, flags, mode);
       filesystemRaceState.afterOpen?.(String(path));
@@ -52,13 +46,11 @@ describe('secure file reads', () => {
     root = mkdtempSync(join(tmpdir(), 'mosaic-secure-file-'));
     filesystemRaceState.afterLstat = undefined;
     filesystemRaceState.afterOpen = undefined;
-    filesystemRaceState.afterStat = undefined;
   });
 
   afterEach(() => {
     filesystemRaceState.afterLstat = undefined;
     filesystemRaceState.afterOpen = undefined;
-    filesystemRaceState.afterStat = undefined;
     rmSync(root, { recursive: true, force: true });
   });
 
@@ -68,87 +60,25 @@ describe('secure file reads', () => {
     );
   });
 
-  // stack#1380: the guard resolves symlinks and validates the resolved target
+  it('rejects a symlink in a file ancestor', () => {
-  // instead of refusing any symlink component.
-  it('permits a symlink ancestor whose resolved target is inside the root', () => {
     const external = join(root, 'external');
     mkdirSync(external);
     writeFileSync(join(external, 'file'), 'external\n');
     symlinkSync(external, join(root, 'linked'));
 
-    const snapshot = readRegularFileSecure(join(root, 'linked', 'file'), { root });
+    expect(() => readRegularFileSecure(join(root, 'linked', 'file'), { root })).toThrow(
-    expect(snapshot.content.toString('utf8')).toBe('external\n');
+      'path ancestor is a symbolic link',
-  });
-
-  it('permits a symlinked file whose resolved target is inside the root', () => {
-    const external = join(root, 'external-file');
-    writeFileSync(external, 'external\n');
-    symlinkSync(external, join(root, 'linked-file'));
-
-    const snapshot = readRegularFileSecure(join(root, 'linked-file'), { root });
-    expect(snapshot.content.toString('utf8')).toBe('external\n');
-  });
-
-  it('permits a symlink resolving into an additional sanctioned root (split-home roster shape)', () => {
-    const brain = `${root}-brain`;
-    mkdirSync(join(brain, 'fleet'), { recursive: true });
-    writeFileSync(join(brain, 'fleet', 'roster.yaml'), 'roster\n', { mode: 0o600 });
-    mkdirSync(join(root, 'fleet'));
-    symlinkSync(join(brain, 'fleet', 'roster.yaml'), join(root, 'fleet', 'roster.yaml'));
-
-    const snapshot = readRegularFileSecure(join(root, 'fleet', 'roster.yaml'), {
-      root,
-      symlinkTargetRoots: [brain],
-    });
-    expect(snapshot.content.toString('utf8')).toBe('roster\n');
-  });
-
-  it('refuses a symlink whose resolved target escapes every sanctioned root', () => {
-    const outside = mkdtempSync(join(tmpdir(), 'mosaic-secure-outside-'));
-    try {
-      mkdirSync(join(root, 'fleet'), { recursive: true });
-      writeFileSync(join(outside, 'roster.yaml'), 'escaped\n', { mode: 0o600 });
-      symlinkSync(join(outside, 'roster.yaml'), join(root, 'fleet', 'roster.yaml'));
-
-      expect(() => readRegularFileSecure(join(root, 'fleet', 'roster.yaml'), { root })).toThrow(
-        /symlink target escapes managed roots/,
-      );
-    } finally {
-      rmSync(outside, { recursive: true, force: true });
-    }
-  });
-
-  it('refuses a group-writable symlink target', () => {
-    const loose = join(root, 'loose');
-    mkdirSync(loose);
-    chmodSync(loose, 0o770); // group-writable bit survives umask via explicit chmod
-    writeFileSync(join(loose, 'file'), 'loose\n');
-    symlinkSync(loose, join(root, 'linked-loose'));
-
-    expect(() => readRegularFileSecure(join(root, 'linked-loose', 'file'), { root })).toThrow(
-      /group- or world-writable/,
     );
   });
 
-  it('refuses a symlink target owned by another user', () => {
+  it('rejects a symlink target', () => {
-    const external = join(root, 'foreign');
+    const external = join(root, 'external');
-    mkdirSync(external);
+    writeFileSync(external, 'external\n');
-    writeFileSync(join(external, 'file'), 'foreign\n');
+    symlinkSync(external, join(root, 'linked-file'));
-    symlinkSync(external, join(root, 'linked-foreign'));
 
-    filesystemRaceState.afterStat = (path, stats): Stats => {
+    expect(() => readRegularFileSecure(join(root, 'linked-file'), { root })).toThrow(
-      if (resolve(path) === resolve(external)) {
+      'file is a symbolic link',
-        return { ...stats, uid: stats.uid + 4242 } as Stats;
+    );
-      }
-      return stats;
-    };
-    try {
-      expect(() => readRegularFileSecure(join(root, 'linked-foreign', 'file'), { root })).toThrow(
-        /not owned by the current user/,
-      );
-    } finally {
-      filesystemRaceState.afterStat = undefined;
-    }
   });
 
   it('keeps ancestor traversal bound when an opened directory is substituted', () => {

packages/mosaic/src/fleet/secure-file.ts

@@ -7,25 +7,14 @@ import {
   mkdirSync,
   openSync,
   readFileSync,
-  readlinkSync,
-  statSync,
 } from 'node:fs';
 import { platform } from 'node:os';
-import { basename, dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
 
 export interface SecureFileReadOptions {
   root: string;
   maxBytes?: number;
   executable?: boolean;
-  /**
-   * Additional roots a symlink component may resolve into (stack#1380).
-   * Default: only the managed root itself. Every symlink hop is validated —
-   * containment under the root or one of these roots, current-user ownership,
-   * no group/world-writable mode — and refusal stays the default for anything
-   * else. Callers that operate the split-home layout pass the brain home so
-   * the framework-created roster symlink resolves.
-   */
-  symlinkTargetRoots?: string[];
 }
 
 export interface SecureFileSnapshot {
@@ -99,57 +88,7 @@ function openDirectoryChain(absoluteDirectory: string): { fd: number; descriptor
   }
 }
 
-function containedUnder(root: string, target: string): boolean {
+function openFileBeneathRoot(root: string, target: string): { fd: number; descriptors: number[] } {
-  const rel = relative(resolve(root), resolve(target));
-  return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel) && rel !== '';
-}
-
-const MAX_SYMLINK_HOPS = 40;
-
-/**
- * Resolve every symlink on `lexical` component-wise, validating each hop
- * (stack#1380 resolve-then-validate): the hop target must stay under one of
- * the sanctioned roots, must be owned by the current user (or root), and must
- * not be group- or world-writable. Returns a symlink-free absolute path.
- */
-function resolveRealPath(lexical: string, sanctionedRoots: string[]): string {
-  const hopTargets: string[] = [];
-  let current: string = sep;
-  for (const piece of resolve(lexical).split(sep).filter(Boolean)) {
-    current = resolve(current, piece);
-    for (let hops = 0; lstatSync(current).isSymbolicLink(); ) {
-      if (++hops > MAX_SYMLINK_HOPS) {
-        throw new Error(`symlink chain exceeds ${MAX_SYMLINK_HOPS} hops: ${lexical}`);
-      }
-      const linkTarget = readlinkSync(current);
-      const absolute = resolve(dirname(current), linkTarget);
-      if (!sanctionedRoots.some((root) => containedUnder(root, absolute))) {
-        throw new Error(
-          `symlink target escapes managed roots [${sanctionedRoots.join(', ')}]: ${absolute}`,
-        );
-      }
-      hopTargets.push(absolute);
-      current = absolute;
-    }
-  }
-  const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
-  for (const hop of hopTargets) {
-    const stat = statSync(hop);
-    if (stat.uid !== uid && stat.uid !== 0) {
-      throw new Error(`symlink target is not owned by the current user: ${hop}`);
-    }
-    if (stat.mode & 0o022) {
-      throw new Error(`symlink target is group- or world-writable: ${hop}`);
-    }
-  }
-  return current;
-}
-
-function openFileBeneathRoot(
-  root: string,
-  target: string,
-  symlinkTargetRoots: string[] = [],
-): { fd: number; descriptors: number[] } {
   const canonicalRoot = resolve(root);
   const canonicalTarget = resolve(target);
   assertCanonicalContainment(canonicalRoot, canonicalTarget);
@@ -157,52 +96,39 @@ function openFileBeneathRoot(
   const fileName = components.pop();
   if (fileName === undefined) throw new Error('managed file path names the managed root');
 
-  // stack#1380: resolve-then-validate. The lexical path must name the managed
+  const rootChain = openDirectoryChain(canonicalRoot);
-  // root (above); symlink components are then resolved hop-by-hop under the
-  // sanctioned roots (validated per hop), and the descriptor traversal walks
-  // the symlink-free real path — keeping the O_NOFOLLOW chain as the race
-  // guard for anything substituted after resolution.
-  let realRoot: string;
-  try {
-    realRoot = resolveRealPath(canonicalRoot, [canonicalRoot]);
-  } catch (error) {
-    throw secureFilesystemError(
-      'secure descriptor traversal failed: symbolic link, unavailable, or not a directory',
-      error,
-    );
-  }
-  const sanctioned = [realRoot, ...symlinkTargetRoots.map((extra) => resolve(extra))];
-  let realTarget: string;
-  try {
-    realTarget = resolveRealPath(canonicalTarget, sanctioned);
-  } catch (error) {
-    if (error instanceof Error && !('code' in error)) throw error;
-    throw secureFilesystemError(
-      'secure descriptor traversal failed: symbolic link, unavailable, or not a directory',
-      error,
-    );
-  }
-  if (!sanctioned.some((sr) => containedUnder(sr, realTarget) || resolve(sr) === realTarget)) {
-    throw new Error(
-      `resolved path escapes managed roots [${sanctioned.join(', ')}]: ${realTarget}`,
-    );
-  }
-
-  const chain = openDirectoryChain(dirname(realTarget));
   try {
+    let parentFd = rootChain.fd;
+    for (const component of components) {
+      try {
+        parentFd = openSync(
+          procDescriptorPath(parentFd, component),
+          constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW,
+        );
+      } catch (error) {
+        throw secureFilesystemError(
+          'path ancestor is a symbolic link, unavailable, or not a directory',
+          error,
+        );
+      }
+      rootChain.descriptors.push(parentFd);
+      if (!fstatSync(parentFd).isDirectory()) {
+        throw new Error('path ancestor is a symbolic link or not a directory');
+      }
+    }
     let fd: number;
     try {
       fd = openSync(
-        procDescriptorPath(chain.fd, basename(realTarget)),
+        procDescriptorPath(parentFd, fileName),
         constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW,
       );
     } catch (error) {
       throw secureFilesystemError('file is a symbolic link or unavailable', error);
     }
-    chain.descriptors.push(fd);
+    rootChain.descriptors.push(fd);
-    return { fd, descriptors: chain.descriptors };
+    return { fd, descriptors: rootChain.descriptors };
   } catch (error) {
-    closeDescriptors(chain.descriptors);
+    closeDescriptors(rootChain.descriptors);
     if (error instanceof Error) throw error;
     throw new Error('secure managed file open failed');
   }
@@ -277,7 +203,7 @@ export function readRegularFileSecure(
   path: string,
   options: SecureFileReadOptions,
 ): SecureFileSnapshot {
-  const openedFile = openFileBeneathRoot(options.root, path, options.symlinkTargetRoots ?? []);
+  const openedFile = openFileBeneathRoot(options.root, path);
   try {
     const opened = fstatSync(openedFile.fd);
     if (!opened.isFile()) throw new Error('managed file is not a regular file');

packages/mosaic/src/runtime/update-checker.reseed.spec.ts

@@ -168,9 +168,7 @@ describe('repairFleetCommsTools', () => {
     const result = repairFleetCommsTools(framework, home);
 
     expect(result).toMatchObject({ ok: false, changed: false });
-    // stack#1380: resolve-then-validate — an escaping symlink is still
+    expect(result.reason).toContain('symbolic link');
-    // refused, with the new escape diagnostic.
-    expect(result.reason).toContain('symlink target escapes managed roots');
     expect(readFileSync(target, 'utf8')).toBe('do not touch\n');
     expect(lstatSync(join(home, 'tools', 'tmux', 'agent-send.sh')).isSymbolicLink()).toBe(true);
   });
@@ -224,10 +222,7 @@ describe('repairFleetCommsTools', () => {
       const result = repairFleetCommsTools(framework, targetHome);
 
       expect(result, testCase.name).toMatchObject({ ok: false, changed: false });
-      // stack#1380: escaping ancestor symlinks stay refused. The home case is
+      expect(result.reason, testCase.name).toContain('symbolic link');
-      // caught by the managed-root guard ('is a symbolic link'); deeper
-      // components by resolve-then-validate ('symlink target escapes').
-      expect(result.reason, testCase.name).toMatch(/symbolic link|symlink target escapes/);
       expect(readdirSync(external), testCase.name).toEqual([]);
     }
   });