fix(federation): harness round-2 — email validation + host-side URL rewrite

- Bug-1: replace whitespace in admin email local-part (was breaking @IsEmail)
- Bug-2: rewrite enrollment URL to use host-accessible base in seed.ts (in-cluster URL not resolvable from host)
- Bug-3: correct README Known Limitations section
- eslint.config.mjs: add tools/federation-harness/*.ts to allowDefaultProject so pre-commit hook can lint harness scripts

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.woodpecker/ci.yml

@@ -46,28 +46,18 @@ steps:
   test:
     image: *node_image
     environment:
-      # Avoid the namespace-level Woodpecker DB service named "postgres".
+      DATABASE_URL: postgresql://mosaic:mosaic@postgres:5432/mosaic
-      # The Kubernetes backend exposes service containers by step name.
-      DATABASE_URL: postgresql://mosaic:mosaic@ci-postgres:5432/mosaic
     commands:
       - *enable_pnpm
       # Install postgresql-client for pg_isready
       - apk add --no-cache postgresql-client
-      # Wait up to 60s for CI postgres to be ready; fail fast if it never comes up.
+      # Wait up to 30s for postgres to be ready
       - |
-        ready=0
+        for i in $(seq 1 30); do
-        for i in $(seq 1 60); do
+          pg_isready -h postgres -p 5432 -U mosaic && break
-          if pg_isready -h ci-postgres -p 5432 -U mosaic; then
+          echo "Waiting for postgres ($i/30)..."
-            ready=1
-            break
-          fi
-          echo "Waiting for ci-postgres ($i/60)..."
           sleep 1
         done
-        if [ "$ready" -ne 1 ]; then
-          echo "ci-postgres did not become ready" >&2
-          exit 1
-        fi
       # Run migrations (DATABASE_URL is set in environment above)
       - pnpm --filter @mosaicstack/db run db:migrate
       # Run all tests
@@ -76,7 +66,7 @@ steps:
       - typecheck
 
 services:
-  ci-postgres:
+  postgres:
     image: pgvector/pgvector:pg17
     environment:
       POSTGRES_USER: mosaic

.woodpecker/publish.yml

@@ -114,31 +114,6 @@ steps:
     depends_on:
       - build
 
-  build-appservice:
-    image: gcr.io/kaniko-project/executor:debug
-    environment:
-      REGISTRY_USER:
-        from_secret: gitea_username
-      REGISTRY_PASS:
-        from_secret: gitea_password
-      CI_COMMIT_BRANCH: ${CI_COMMIT_BRANCH}
-      CI_COMMIT_TAG: ${CI_COMMIT_TAG}
-      CI_COMMIT_SHA: ${CI_COMMIT_SHA}
-    commands:
-      - mkdir -p /kaniko/.docker
-      - echo "{\"auths\":{\"git.mosaicstack.dev\":{\"username\":\"$REGISTRY_USER\",\"password\":\"$REGISTRY_PASS\"}}}" > /kaniko/.docker/config.json
-      - |
-        DESTINATIONS="--destination git.mosaicstack.dev/mosaicstack/stack/appservice:sha-${CI_COMMIT_SHA:0:7}"
-        if [ "$CI_COMMIT_BRANCH" = "main" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaicstack/stack/appservice:latest"
-        fi
-        if [ -n "$CI_COMMIT_TAG" ]; then
-          DESTINATIONS="$DESTINATIONS --destination git.mosaicstack.dev/mosaicstack/stack/appservice:$CI_COMMIT_TAG"
-        fi
-        /kaniko/executor --context . --dockerfile docker/appservice.Dockerfile $DESTINATIONS
-    depends_on:
-      - build
-
   build-web:
     image: gcr.io/kaniko-project/executor:debug
     environment:

README.md

@@ -58,8 +58,6 @@ mosaic yolo pi               # Pi in yolo mode
 
 The launcher verifies your config, checks for `SOUL.md`, injects your `AGENTS.md` standards into the runtime, and forwards all arguments.
 
-Pi launches default to a token-lean skill posture: `mosaic pi` passes `--no-skills` so Pi does not preload every global skill description into the system prompt. Use `MOSAIC_PI_SKILL_MODE=all mosaic pi` for the legacy all-skills catalog, or `MOSAIC_PI_SKILL_MODE=discover mosaic pi` to let Pi use its native settings/project skill discovery.
-
 ### TUI & Gateway
 
 ```bash

apps/appservice/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "@mosaicstack/mosaic-as",
-  "version": "0.0.1",
-  "type": "module",
-  "private": true,
-  "repository": {
-    "type": "git",
-    "url": "https://git.mosaicstack.dev/mosaicstack/stack.git",
-    "directory": "apps/appservice"
-  },
-  "main": "dist/main.js",
-  "bin": {
-    "mosaic-as": "dist/main.js",
-    "mosaic-as-registration": "dist/registration-main.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "lint": "eslint src",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --passWithNoTests",
-    "dev": "tsx watch src/main.ts"
-  },
-  "dependencies": {
-    "@mosaicstack/appservice": "workspace:*"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.8.0",
-    "vitest": "^2.0.0"
-  },
-  "files": [
-    "dist"
-  ]
-}

apps/appservice/src/__tests__/server.test.ts

@@ -1,388 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { AppserviceDaemon } from '../server.js';
-import type { DaemonConfig, DaemonRequest } from '../server.js';
-
-const AGENTS_TYPE = 'org.uscllc.mosaic_as.agents';
-
-const cfg: DaemonConfig = {
-  homeserverUrl: 'https://hs.example',
-  domain: 'hs.example',
-  asToken: 'as-secret',
-  hsToken: 'hs-secret',
-  bridgeTokens: ['bridge-secret'],
-};
-
-const jsonResponse = (status: number, body: unknown): Response =>
-  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
-
-const request = (overrides: Partial<DaemonRequest>): DaemonRequest => ({
-  method: 'GET',
-  path: '/',
-  searchParams: new URLSearchParams(),
-  body: undefined,
-  ...overrides,
-});
-
-const makeDaemon = () => {
-  const fetchMock = vi.fn(async (_input: URL | string) => jsonResponse(200, { event_id: '$sent' }));
-  const daemon = new AppserviceDaemon(cfg, fetchMock as unknown as typeof fetch, () => {});
-  return { daemon, fetchMock };
-};
-
-describe('AppserviceDaemon routing', () => {
-  it('serves health unauthenticated', async () => {
-    const { daemon } = makeDaemon();
-    expect((await daemon.handle(request({ path: '/health' }))).status).toBe(200);
-  });
-
-  it('404s unknown paths', async () => {
-    const { daemon } = makeDaemon();
-    expect((await daemon.handle(request({ path: '/nope' }))).status).toBe(404);
-  });
-
-  it('transactions require the hs_token', async () => {
-    const { daemon } = makeDaemon();
-    const bad = await daemon.handle(
-      request({
-        method: 'PUT',
-        path: '/_matrix/app/v1/transactions/t1',
-        authorizationHeader: 'Bearer wrong',
-        body: { events: [] },
-      }),
-    );
-    expect(bad.status).toBe(403);
-    const ok = await daemon.handle(
-      request({
-        method: 'PUT',
-        path: '/_matrix/app/v1/transactions/t1',
-        authorizationHeader: 'Bearer hs-secret',
-        body: { events: [{ type: 'm.room.message', event_id: '$e' }] },
-      }),
-    );
-    expect(ok.status).toBe(200);
-  });
-
-  it('bridge requires a bridge token (hs/as tokens do not work)', async () => {
-    const { daemon } = makeDaemon();
-    for (const token of [undefined, 'Bearer hs-secret', 'Bearer as-secret', 'Bearer nope']) {
-      const res = await daemon.handle(
-        request({
-          method: 'POST',
-          path: '/bridge/v1/messages',
-          authorizationHeader: token,
-          body: {},
-        }),
-      );
-      expect(res.status).toBe(403);
-    }
-  });
-
-  it('bridge message sends as the agent and returns the event id', async () => {
-    const { daemon, fetchMock } = makeDaemon();
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/messages',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { room_id: '!r:hs.example', agent: 'pi0-web1', body: 'hi', thread_root: '$req' },
-      }),
-    );
-    expect(res.status).toBe(200);
-    expect(res.body.event_id).toBe('$sent');
-    const sendCall = fetchMock.mock.calls
-      .map((c) => new URL(String(c[0])))
-      .find((u) => u.pathname.includes('/send/m.room.message/'));
-    expect(sendCall).toBeDefined();
-    expect(sendCall!.searchParams.get('user_id')).toBe('@agent-pi0-web1:hs.example');
-  });
-
-  it('bridge rejects invalid payloads with 400', async () => {
-    const { daemon } = makeDaemon();
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/messages',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { room_id: 'bad', agent: 'pi0', body: 'x' },
-      }),
-    );
-    expect(res.status).toBe(400);
-  });
-
-  it('bridge typing endpoint works', async () => {
-    const { daemon, fetchMock } = makeDaemon();
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/typing',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { room_id: '!r:hs.example', agent: 'pi0-web1', typing: true },
-      }),
-    );
-    expect(res.status).toBe(200);
-    const typingCall = fetchMock.mock.calls
-      .map((c) => new URL(String(c[0])))
-      .find((u) => u.pathname.includes('/typing/'));
-    expect(typingCall).toBeDefined();
-  });
-
-  it('authenticated unknown bridge sub-paths return 405, never fall through', async () => {
-    const { daemon } = makeDaemon();
-    const res = await daemon.handle(
-      request({
-        method: 'GET',
-        path: '/bridge/v1/unknown',
-        authorizationHeader: 'Bearer bridge-secret',
-      }),
-    );
-    expect(res.status).toBe(405);
-  });
-
-  it('provisions a room as the AS sender with space linking', async () => {
-    const calls: Array<{ url: URL; body: unknown }> = [];
-    const fetchMock = vi.fn(async (input: URL | string, init?: RequestInit) => {
-      const url = new URL(String(input));
-      calls.push({ url, body: init?.body ? JSON.parse(String(init.body)) : undefined });
-      if (url.pathname.endsWith('/createRoom'))
-        return jsonResponse(200, { room_id: '!new:hs.example' });
-      return jsonResponse(200, {});
-    });
-    const daemon = new AppserviceDaemon(cfg, fetchMock as unknown as typeof fetch, () => {});
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/provision/rooms',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: {
-          name: 'proj-x',
-          alias: 'mosaic-proj-x',
-          invite: ['@jason.woltje:hs.example'],
-          space_id: '!space:hs.example',
-        },
-      }),
-    );
-    expect(res.status).toBe(200);
-    expect(res.body.room_id).toBe('!new:hs.example');
-    expect(res.body.space_linked).toBe(true);
-    const create = calls.find((c) => c.url.pathname.endsWith('/createRoom'));
-    expect(create!.url.searchParams.get('user_id')).toBe('@mosaic-as:hs.example');
-    const body = create!.body as Record<string, unknown>;
-    expect(body.room_alias_name).toBe('mosaic-proj-x');
-    expect((body.power_level_content_override as Record<string, unknown>).users).toEqual({
-      '@mosaic-as:hs.example': 100,
-    });
-    expect(calls.some((c) => c.url.pathname.includes('/state/m.space.child/'))).toBe(true);
-    expect(calls.some((c) => c.url.pathname.includes('/state/m.space.parent/'))).toBe(true);
-  });
-
-  it('space-link failure still returns the room id (no orphan)', async () => {
-    const fetchMock = vi.fn(async (input: URL | string) => {
-      const url = new URL(String(input));
-      if (url.pathname.endsWith('/createRoom'))
-        return jsonResponse(200, { room_id: '!new:hs.example' });
-      if (url.pathname.includes('/state/m.space.child/'))
-        return jsonResponse(403, { errcode: 'M_FORBIDDEN', error: 'no PL in space' });
-      return jsonResponse(200, {});
-    });
-    const daemon = new AppserviceDaemon(cfg, fetchMock as unknown as typeof fetch, () => {});
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/provision/rooms',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { name: 'proj-x', space_id: '!space:hs.example' },
-      }),
-    );
-    expect(res.status).toBe(200);
-    expect(res.body.room_id).toBe('!new:hs.example');
-    expect(res.body.space_linked).toBe(false);
-    expect(String(res.body.space_error)).toContain('403');
-  });
-
-  it('invite list cap enforced', async () => {
-    const { daemon } = makeDaemon();
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/provision/rooms',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { name: 'x', invite: Array.from({ length: 51 }, (_, i) => `@u${i}:hs`) },
-      }),
-    );
-    expect(res.status).toBe(400);
-  });
-
-  it('provision rejects bad payloads and requires auth', async () => {
-    const { daemon } = makeDaemon();
-    const noAuth = await daemon.handle(
-      request({ method: 'POST', path: '/bridge/v1/provision/rooms', body: { name: 'x' } }),
-    );
-    expect(noAuth.status).toBe(403);
-    const bad = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/provision/rooms',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { name: '', alias: 'BAD ALIAS' },
-      }),
-    );
-    expect(bad.status).toBe(400);
-  });
-
-  // A daemon whose fetch mock backs account_data with a mutable in-test object,
-  // so register/verify/revoke round-trip through the (faked) homeserver.
-  const makeAgentDaemon = () => {
-    const accountData: { value: Record<string, unknown> | null } = { value: null };
-    const fetchMock = vi.fn(async (input: URL | string, init?: RequestInit) => {
-      const url = new URL(String(input));
-      const path = url.pathname;
-      if (path.includes(`/account_data/${AGENTS_TYPE}`)) {
-        if (init?.method === 'PUT') {
-          accountData.value = JSON.parse(String(init.body)) as Record<string, unknown>;
-          return jsonResponse(200, {});
-        }
-        if (accountData.value === null) {
-          return jsonResponse(404, { errcode: 'M_NOT_FOUND', error: 'not found' });
-        }
-        return jsonResponse(200, accountData.value);
-      }
-      if (path.endsWith('/register')) return jsonResponse(200, { user_id: 'whatever' });
-      if (path.includes('/send/m.room.message/')) return jsonResponse(200, { event_id: '$sent' });
-      return jsonResponse(200, {});
-    });
-    const daemon = new AppserviceDaemon(cfg, fetchMock as unknown as typeof fetch, () => {});
-    return { daemon, fetchMock };
-  };
-
-  const registerAgent = async (
-    daemon: AppserviceDaemon,
-    body: Record<string, unknown> = { alias: 'pi0', host: 'web1' },
-  ) =>
-    daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/agents',
-        authorizationHeader: 'Bearer bridge-secret',
-        body,
-      }),
-    );
-
-  it('host token registers an agent and returns agent_user_id + bridge_token', async () => {
-    const { daemon, fetchMock } = makeAgentDaemon();
-    const res = await registerAgent(daemon, { alias: 'pi0', host: 'web1' });
-    expect(res.status).toBe(200);
-    expect(res.body.agent_user_id).toBe('@agent-pi0-web1:hs.example');
-    expect(String(res.body.bridge_token).startsWith('magt_')).toBe(true);
-    const registerCall = fetchMock.mock.calls
-      .map((c) => new URL(String(c[0])))
-      .find((u) => u.pathname.endsWith('/register'));
-    expect(registerCall).toBeDefined();
-  });
-
-  it('register requires a HOST token (agent token and no token are 403)', async () => {
-    const { daemon } = makeAgentDaemon();
-    const minted = await registerAgent(daemon);
-    const agentToken = String(minted.body.bridge_token);
-
-    const asAgent = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/agents',
-        authorizationHeader: `Bearer ${agentToken}`,
-        body: { alias: 'pi1', host: 'web2' },
-      }),
-    );
-    expect(asAgent.status).toBe(403);
-
-    const noAuth = await daemon.handle(
-      request({ method: 'POST', path: '/bridge/v1/agents', body: { alias: 'pi1', host: 'web2' } }),
-    );
-    expect(noAuth.status).toBe(403);
-  });
-
-  it('agent-scoped token may send as itself but not as another agent', async () => {
-    const { daemon } = makeAgentDaemon();
-    const minted = await registerAgent(daemon, { alias: 'pi0', host: 'web1' });
-    const agentToken = String(minted.body.bridge_token);
-
-    const self = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/messages',
-        authorizationHeader: `Bearer ${agentToken}`,
-        body: { room_id: '!r:hs.example', agent: 'pi0-web1', body: 'hi' },
-      }),
-    );
-    expect(self.status).toBe(200);
-
-    const other = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/messages',
-        authorizationHeader: `Bearer ${agentToken}`,
-        body: { room_id: '!r:hs.example', agent: 'pi9-web9', body: 'hi' },
-      }),
-    );
-    expect(other.status).toBe(403);
-    expect(other.body.error).toBe('token not scoped to this agent');
-  });
-
-  it('revoked agent token is rejected on messages', async () => {
-    const { daemon } = makeAgentDaemon();
-    const minted = await registerAgent(daemon, { alias: 'pi0', host: 'web1' });
-    const agentToken = String(minted.body.bridge_token);
-
-    const revoke = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/agents/revoke',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: { agent_user_id: '@agent-pi0-web1:hs.example' },
-      }),
-    );
-    expect(revoke.status).toBe(200);
-    expect(revoke.body.revoked).toBe(1);
-
-    const afterRevoke = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/messages',
-        authorizationHeader: `Bearer ${agentToken}`,
-        body: { room_id: '!r:hs.example', agent: 'pi0-web1', body: 'hi' },
-      }),
-    );
-    expect(afterRevoke.status).toBe(403);
-  });
-
-  it('GET /bridge/v1/agents lists registered agents (host only)', async () => {
-    const { daemon } = makeAgentDaemon();
-    await registerAgent(daemon, { alias: 'pi0', host: 'web1', display_name: 'Pi Zero' });
-
-    const res = await daemon.handle(
-      request({
-        method: 'GET',
-        path: '/bridge/v1/agents',
-        authorizationHeader: 'Bearer bridge-secret',
-      }),
-    );
-    expect(res.status).toBe(200);
-    const agents = res.body.agents as Array<Record<string, unknown>>;
-    expect(agents).toHaveLength(1);
-    expect(agents[0]?.agent_user_id).toBe('@agent-pi0-web1:hs.example');
-    expect(agents[0]?.display_name).toBe('Pi Zero');
-  });
-
-  it('empty bridge token list denies everything', async () => {
-    const daemon = new AppserviceDaemon({ ...cfg, bridgeTokens: [] }, undefined, () => {});
-    const res = await daemon.handle(
-      request({
-        method: 'POST',
-        path: '/bridge/v1/typing',
-        authorizationHeader: 'Bearer bridge-secret',
-        body: {},
-      }),
-    );
-    expect(res.status).toBe(403);
-  });
-});

apps/appservice/src/config.ts

@@ -1,23 +0,0 @@
-import type { DaemonConfig } from './server.js';
-
-const required = (name: string): string => {
-  const value = process.env[name];
-  if (!value) throw new Error(`missing required env var ${name}`);
-  return value;
-};
-
-export function configFromEnv(): DaemonConfig & { port: number } {
-  return {
-    homeserverUrl: required('MOSAIC_AS_HOMESERVER_URL'),
-    domain: required('MOSAIC_AS_DOMAIN'),
-    asToken: required('MOSAIC_AS_TOKEN'),
-    hsToken: required('MOSAIC_HS_TOKEN'),
-    userPrefix: process.env.MOSAIC_AS_USER_PREFIX ?? 'agent-',
-    senderLocalpart: process.env.MOSAIC_AS_SENDER_LOCALPART ?? 'mosaic-as',
-    bridgeTokens: (process.env.MOSAIC_AS_BRIDGE_TOKENS ?? '')
-      .split(',')
-      .map((t) => t.trim())
-      .filter(Boolean),
-    port: Number(process.env.MOSAIC_AS_PORT ?? 8008),
-  };
-}

apps/appservice/src/main.ts

@@ -1,67 +0,0 @@
-import http from 'node:http';
-
-import { configFromEnv } from './config.js';
-import { AppserviceDaemon } from './server.js';
-
-const cfg = configFromEnv();
-const daemon = new AppserviceDaemon(cfg);
-
-const MAX_BODY_BYTES = 1024 * 1024;
-
-const server = http.createServer((req, res) => {
-  const chunks: Buffer[] = [];
-  let received = 0;
-  let rejected = false;
-  req.on('data', (chunk: Buffer) => {
-    received += chunk.length;
-    if (received > MAX_BODY_BYTES) {
-      rejected = true;
-      res.writeHead(413, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ errcode: 'M_TOO_LARGE', error: 'request body too large' }));
-      req.destroy();
-      return;
-    }
-    chunks.push(chunk);
-  });
-  req.on('end', () => {
-    if (rejected) return;
-    void (async () => {
-      const url = new URL(req.url ?? '/', 'http://localhost');
-      let body: unknown;
-      try {
-        const raw = Buffer.concat(chunks).toString();
-        body = raw ? JSON.parse(raw) : undefined;
-      } catch {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ errcode: 'M_NOT_JSON', error: 'invalid json' }));
-        return;
-      }
-      const result = await daemon.handle({
-        method: req.method ?? 'GET',
-        path: url.pathname,
-        searchParams: url.searchParams,
-        authorizationHeader: req.headers.authorization,
-        body,
-      });
-      res.writeHead(result.status, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result.body));
-    })().catch((error: unknown) => {
-      console.error('request failed:', error);
-      if (res.headersSent) {
-        res.destroy();
-        return;
-      }
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'internal error' }));
-    });
-  });
-});
-
-server.listen(cfg.port, () => {
-  console.log(
-    `mosaic-as listening on :${cfg.port} (homeserver ${cfg.homeserverUrl}, domain ${cfg.domain})`,
-  );
-  if (cfg.bridgeTokens.length === 0) {
-    console.warn('WARNING: MOSAIC_AS_BRIDGE_TOKENS is empty — bridge API will deny all requests');
-  }
-});

apps/appservice/src/registration-main.ts

@@ -1,10 +0,0 @@
-import { buildRegistration, registrationToYaml } from '@mosaicstack/appservice';
-
-import { configFromEnv } from './config.js';
-
-// Prints the Synapse registration YAML (mosaic-as.yaml) for the current env.
-// Usage: MOSAIC_AS_URL=http://mosaic-as:8008 mosaic-as-registration > mosaic-as.yaml
-const cfg = configFromEnv();
-const url = process.env.MOSAIC_AS_URL;
-if (!url) throw new Error('missing required env var MOSAIC_AS_URL');
-process.stdout.write(registrationToYaml(buildRegistration(cfg, { url })));

apps/appservice/src/server.ts

@@ -1,225 +0,0 @@
-import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
-
-import {
-  AgentTokenStore,
-  AppserviceIntent,
-  TransactionHandler,
-  validateBridgeMessage,
-  validateBridgeTyping,
-  validateProvisionRoom,
-  validateRegisterAgent,
-  validateRevokeAgent,
-} from '@mosaicstack/appservice';
-import type { AppserviceConfig, MatrixEvent } from '@mosaicstack/appservice';
-
-export interface DaemonConfig extends AppserviceConfig {
-  /** Bearer tokens accepted on /bridge/v1/* (one per agent-comms host daemon). */
-  bridgeTokens: string[];
-}
-
-export interface DaemonRequest {
-  method: string;
-  /** URL path without query string. */
-  path: string;
-  searchParams: URLSearchParams;
-  authorizationHeader?: string;
-  body: unknown;
-}
-
-export interface DaemonResponse {
-  status: number;
-  body: Record<string, unknown>;
-}
-
-// Compare equal-length HMAC digests so neither content nor LENGTH of the
-// stored secret is observable through timing.
-const HMAC_KEY = randomBytes(32);
-const digest = (value: string): Buffer => createHmac('sha256', HMAC_KEY).update(value).digest();
-
-const safeEqual = (a: string, b: string): boolean => timingSafeEqual(digest(a), digest(b));
-
-const TXN_PATH = /^\/_matrix\/app\/v1\/transactions\/([^/]+)$/;
-
-/**
- * Resolved identity for an authenticated /bridge/v1/* caller. Host principals
- * (the agent-comms host daemons) are unrestricted; agent principals are scoped
- * to a single virtual user and may only act as themselves.
- */
-export type BridgePrincipal = { kind: 'host' } | { kind: 'agent'; agentUserId: string } | null;
-
-/**
- * HTTP-framework-agnostic request router for the mosaic-as daemon: the
- * Application Service transactions endpoint (Synapse-facing) plus the
- * internal bridge API v1 (agent-comms daemon-facing). main.ts binds this to
- * node:http; tests drive it directly.
- */
-export class AppserviceDaemon {
-  readonly intent: AppserviceIntent;
-  private readonly transactions: TransactionHandler;
-  private readonly agents: AgentTokenStore;
-
-  constructor(
-    private readonly cfg: DaemonConfig,
-    fetchImpl?: typeof fetch,
-    private readonly log: (line: string) => void = (line) => console.log(line),
-  ) {
-    this.intent = new AppserviceIntent(cfg, fetchImpl);
-    this.agents = new AgentTokenStore(this.intent);
-    this.transactions = new TransactionHandler({
-      hsToken: cfg.hsToken,
-      onEvent: (event) => this.onEvent(event),
-      onError: (error, txnId) => this.log(`txn ${txnId} handler error: ${String(error)}`),
-    });
-  }
-
-  /** v1: the daemon only observes; room logic lives in the agent-comms daemons. */
-  private onEvent(event: MatrixEvent): void {
-    if (event.type === 'm.room.message') {
-      this.log(
-        `event ${event.event_id ?? '?'} in ${event.room_id ?? '?'} from ${event.sender ?? '?'}`,
-      );
-    }
-  }
-
-  /** Resolve the calling principal, or null when unauthorized. Fail-closed:
-   * host tokens win (timing-safe compare); otherwise a magt_* bearer is looked
-   * up in the agent token store; anything else is rejected. */
-  private async bridgeAuthorized(
-    authorizationHeader: string | undefined,
-  ): Promise<BridgePrincipal> {
-    if (!authorizationHeader?.startsWith('Bearer ')) return null;
-    const presented = authorizationHeader.slice('Bearer '.length);
-    if (this.cfg.bridgeTokens.some((token) => safeEqual(presented, token))) {
-      return { kind: 'host' };
-    }
-    const agentUserId = await this.agents.verifyToken(presented);
-    if (agentUserId) return { kind: 'agent', agentUserId };
-    return null;
-  }
-
-  async handle(req: DaemonRequest): Promise<DaemonResponse> {
-    if (req.method === 'GET' && req.path === '/health') {
-      return { status: 200, body: { ok: true } };
-    }
-
-    const txnMatch = req.method === 'PUT' ? TXN_PATH.exec(req.path) : null;
-    if (txnMatch?.[1] !== undefined) {
-      return this.transactions.handle(txnMatch[1], req.body, {
-        authorizationHeader: req.authorizationHeader,
-        accessTokenParam: req.searchParams.get('access_token') ?? undefined,
-      });
-    }
-
-    if (req.path.startsWith('/bridge/v1/')) {
-      const principal = await this.bridgeAuthorized(req.authorizationHeader);
-      if (!principal) {
-        return { status: 403, body: { errcode: 'M_FORBIDDEN', error: 'bad bridge token' } };
-      }
-      try {
-        if (req.method === 'POST' && req.path === '/bridge/v1/agents') {
-          if (principal.kind !== 'host') {
-            return {
-              status: 403,
-              body: { errcode: 'M_FORBIDDEN', error: 'agents cannot register agents' },
-            };
-          }
-          validateRegisterAgent(req.body);
-          const { agentUserId, token } = await this.agents.register({
-            alias: req.body.alias,
-            host: req.body.host,
-            displayName: req.body.display_name,
-          });
-          this.log(`registered agent ${agentUserId}`);
-          return { status: 200, body: { agent_user_id: agentUserId, bridge_token: token } };
-        }
-        if (req.method === 'POST' && req.path === '/bridge/v1/agents/revoke') {
-          if (principal.kind !== 'host') {
-            return {
-              status: 403,
-              body: { errcode: 'M_FORBIDDEN', error: 'agents cannot revoke agents' },
-            };
-          }
-          validateRevokeAgent(req.body);
-          const revoked = await this.agents.revoke(req.body.agent_user_id);
-          this.log(`revoked ${revoked} token(s) for ${req.body.agent_user_id}`);
-          return { status: 200, body: { revoked } };
-        }
-        if (req.method === 'GET' && req.path === '/bridge/v1/agents') {
-          if (principal.kind !== 'host') {
-            return {
-              status: 403,
-              body: { errcode: 'M_FORBIDDEN', error: 'agents cannot list agents' },
-            };
-          }
-          const agents = await this.agents.list();
-          return { status: 200, body: { agents } };
-        }
-        if (req.method === 'POST' && req.path === '/bridge/v1/messages') {
-          validateBridgeMessage(req.body);
-          if (
-            principal.kind === 'agent' &&
-            this.intent.agentUserId(req.body.agent) !== principal.agentUserId
-          ) {
-            return {
-              status: 403,
-              body: { errcode: 'M_FORBIDDEN', error: 'token not scoped to this agent' },
-            };
-          }
-          const eventId = await this.intent.sendAsAgent({
-            roomId: req.body.room_id,
-            agent: req.body.agent,
-            body: req.body.body,
-            threadRoot: req.body.thread_root,
-            msgtype: req.body.msgtype,
-            extraContent: req.body.extra_content,
-          });
-          return { status: 200, body: { event_id: eventId ?? null } };
-        }
-        if (req.method === 'POST' && req.path === '/bridge/v1/typing') {
-          validateBridgeTyping(req.body);
-          if (
-            principal.kind === 'agent' &&
-            this.intent.agentUserId(req.body.agent) !== principal.agentUserId
-          ) {
-            return {
-              status: 403,
-              body: { errcode: 'M_FORBIDDEN', error: 'token not scoped to this agent' },
-            };
-          }
-          await this.intent.setTyping(req.body.room_id, req.body.agent, req.body.typing);
-          return { status: 200, body: {} };
-        }
-        if (req.method === 'POST' && req.path === '/bridge/v1/provision/rooms') {
-          validateProvisionRoom(req.body);
-          const result = await this.intent.createRoom({
-            name: req.body.name,
-            alias: req.body.alias,
-            topic: req.body.topic,
-            invite: req.body.invite,
-            spaceId: req.body.space_id,
-          });
-          this.log(
-            `provisioned room ${result.roomId} (${req.body.name}) space_linked=${result.spaceLinked}`,
-          );
-          return {
-            status: 200,
-            body: {
-              room_id: result.roomId,
-              space_linked: result.spaceLinked,
-              ...(result.spaceError ? { space_error: result.spaceError } : {}),
-            },
-          };
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.log(`bridge error ${req.method} ${req.path}: ${message}`);
-        return { status: 400, body: { error: message } };
-      }
-      // Explicit: never fall out of the authenticated bridge block, so future
-      // sub-paths cannot accidentally route around the auth guard above.
-      return { status: 405, body: { error: 'unsupported bridge method/path' } };
-    }
-
-    return { status: 404, body: { error: 'not found' } };
-  }
-}

apps/appservice/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

apps/gateway/package.json

@@ -73,7 +73,6 @@
     "rxjs": "^7.8.0",
     "socket.io": "^4.8.0",
     "uuid": "^11.0.0",
-    "undici": "^7.24.6",
     "zod": "^4.3.6"
   },
   "devDependencies": {

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

@@ -1,21 +1,8 @@
 import { mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import {
+import { Global, Inject, Module, type OnApplicationShutdown } from '@nestjs/common';
-  Global,
+import { createDb, createPgliteDb, type Db, type DbHandle } from '@mosaicstack/db';
-  Inject,
-  Logger,
-  Module,
-  type OnApplicationShutdown,
-  type OnModuleInit,
-} from '@nestjs/common';
-import {
-  createDb,
-  createPgliteDb,
-  runPgliteMigrations,
-  type Db,
-  type DbHandle,
-} from '@mosaicstack/db';
 import { createStorageAdapter, type StorageAdapter } from '@mosaicstack/storage';
 import type { MosaicConfig } from '@mosaicstack/config';
 import { MOSAIC_CONFIG } from '../config/config.module.js';
@@ -52,37 +39,12 @@ export const STORAGE_ADAPTER = 'STORAGE_ADAPTER';
   ],
   exports: [DB, STORAGE_ADAPTER],
 })
-export class DatabaseModule implements OnApplicationShutdown, OnModuleInit {
+export class DatabaseModule implements OnApplicationShutdown {
-  private readonly logger = new Logger(DatabaseModule.name);
-
   constructor(
     @Inject(DB_HANDLE) private readonly handle: DbHandle,
     @Inject(STORAGE_ADAPTER) private readonly storageAdapter: StorageAdapter,
-    @Inject(MOSAIC_CONFIG) private readonly config: MosaicConfig,
   ) {}
 
-  // Migrations must complete before any module that injects DB starts serving
-  // requests. NestJS awaits onModuleInit before app.listen(), and modules that
-  // inject DB are initialized after this one — so all DB-dependent code sees a
-  // populated schema before the first HTTP request lands.
-  //
-  // Local (PGlite) tier: we run gateway-DB migrations explicitly here. The
-  // storage adapter writes to a separate PGlite directory and only manages its
-  // own KV tables, so we still call its migrate() afterwards.
-  //
-  // Postgres tier: PostgresAdapter.migrate() already calls runMigrations() on
-  // 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.
-  async onModuleInit(): Promise<void> {
-    if (this.config.tier === 'local') {
-      this.logger.log('Applying PGlite schema migrations...');
-      await runPgliteMigrations(this.handle);
-    }
-    this.logger.log(`Initializing storage adapter (${this.storageAdapter.name})...`);
-    await this.storageAdapter.migrate();
-  }
-
   async onApplicationShutdown(): Promise<void> {
     await Promise.all([this.handle.close(), this.storageAdapter.close()]);
   }

apps/gateway/src/federation/client/__tests__/federation-client.service.spec.ts

@@ -1,553 +0,0 @@
-/**
- * Unit tests for FederationClientService (FED-M3-08).
- *
- * HTTP mocking strategy:
- *   undici MockAgent is used to intercept outbound HTTP requests.  The service
- *   uses `undici.fetch` with a `dispatcher` option, so MockAgent is set as the
- *   global dispatcher and all requests flow through it.
- *
- *   Because the service builds one `undici.Agent` per peer and passes it as
- *   the dispatcher on every fetch call, we cannot intercept at the Agent level
- *   in unit tests without significant refactoring.  Instead, we set the global
- *   dispatcher to a MockAgent and override the service's `doRequest` indirection
- *   by spying on the internal fetch call.
- *
- *   For the cert/key wiring, we use the real `sealClientKey` function from
- *   peer-key.util.ts with a test secret — no stubs.
- *
- * Sealed-key setup:
- *   Each test (or beforeAll) calls `sealClientKey(TEST_PRIVATE_KEY_PEM)` with
- *   BETTER_AUTH_SECRET set to a deterministic test value so that
- *   `unsealClientKey` in the service recovers the original PEM.
- */
-
-import 'reflect-metadata';
-import { describe, it, expect, vi, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
-import { MockAgent, setGlobalDispatcher, getGlobalDispatcher } from 'undici';
-import type { Dispatcher } from 'undici';
-import { writeFileSync, unlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import type { Db } from '@mosaicstack/db';
-import { FederationClientService, FederationClientError } from '../federation-client.service.js';
-import { sealClientKey } from '../../peer-key.util.js';
-
-// ---------------------------------------------------------------------------
-// Test constants
-// ---------------------------------------------------------------------------
-
-const TEST_SECRET = 'test-secret-for-federation-client-spec-only';
-const PEER_ID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa';
-const ENDPOINT = 'https://peer.example.com';
-
-// Minimal valid RSA/EC private key PEM — does NOT need to be a real key for
-// unit tests because we only verify it round-trips through seal/unseal, not
-// that it actually negotiates TLS (MockAgent handles that).
-const TEST_PRIVATE_KEY_PEM = `-----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDummyKeyForTests
------END PRIVATE KEY-----`;
-
-// Minimal self-signed cert PEM (dummy — only used for mTLS Agent construction)
-const TEST_CERT_PEM = `-----BEGIN CERTIFICATE-----
-MIIBdummyCertForFederationClientTests==
------END CERTIFICATE-----`;
-
-const TEST_CERT_SERIAL = 'ABCDEF1234567890';
-
-// ---------------------------------------------------------------------------
-// Sealed key (computed once in beforeAll)
-// ---------------------------------------------------------------------------
-
-let SEALED_KEY: string;
-
-// Path to a stub Step-CA root cert file written in beforeAll. The cert is never
-// actually used to negotiate TLS in unit tests (MockAgent + spy on resolveEntry
-// short-circuit the network), but loadStepCaRoot() requires the file to exist.
-const STUB_CA_PEM_PATH = join(tmpdir(), 'federation-client-spec-ca.pem');
-const STUB_CA_PEM = `-----BEGIN CERTIFICATE-----
-MIIBdummyCAforFederationClientSpecOnly==
------END CERTIFICATE-----
-`;
-
-// ---------------------------------------------------------------------------
-// Peer row factory
-// ---------------------------------------------------------------------------
-
-function makePeerRow(overrides: Partial<Record<string, unknown>> = {}) {
-  return {
-    id: PEER_ID,
-    commonName: 'peer-example-com',
-    displayName: 'Test Peer',
-    certPem: TEST_CERT_PEM,
-    certSerial: TEST_CERT_SERIAL,
-    certNotAfter: new Date('2030-01-01T00:00:00Z'),
-    clientKeyPem: SEALED_KEY,
-    state: 'active' as const,
-    endpointUrl: ENDPOINT,
-    lastSeenAt: null,
-    createdAt: new Date('2026-01-01T00:00:00Z'),
-    revokedAt: null,
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Mock DB builder
-// ---------------------------------------------------------------------------
-
-function makeDb(selectRows: unknown[] = [makePeerRow()]): Db {
-  const limitSelect = vi.fn().mockResolvedValue(selectRows);
-  const whereSelect = vi.fn().mockReturnValue({ limit: limitSelect });
-  const fromSelect = vi.fn().mockReturnValue({ where: whereSelect });
-  const selectMock = vi.fn().mockReturnValue({ from: fromSelect });
-
-  return {
-    select: selectMock,
-    insert: vi.fn(),
-    update: vi.fn(),
-    delete: vi.fn(),
-    transaction: vi.fn(),
-  } as unknown as Db;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers for MockAgent HTTP interception
-// ---------------------------------------------------------------------------
-
-/**
- * Create a MockAgent + MockPool for the peer endpoint, set it as the global
- * dispatcher, and return both for per-test configuration.
- */
-function makeMockAgent() {
-  const mockAgent = new MockAgent({ connections: 1 });
-  mockAgent.disableNetConnect();
-  setGlobalDispatcher(mockAgent);
-  const pool = mockAgent.get(ENDPOINT);
-  return { mockAgent, pool };
-}
-
-/**
- * Build a FederationClientService with a mock DB and a spy on the internal
- * fetch so we can intercept at the HTTP layer via MockAgent.
- *
- * The service calls `fetch(url, { dispatcher: agent })` where `agent` is the
- * mTLS undici.Agent built from the peer's cert+key.  To make MockAgent work,
- * we need the fetch dispatcher to be the MockAgent, not the per-peer Agent.
- *
- * Strategy: we replace the private `resolveEntry` result's `agent` field with
- * the MockAgent's pool, so fetch uses our interceptor.  We do this by spying
- * on `resolveEntry` and returning a controlled entry.
- */
-function makeService(db: Db, mockPool: Dispatcher): FederationClientService {
-  const svc = new FederationClientService(db);
-
-  // Override resolveEntry to inject MockAgent pool as the dispatcher
-  vi.spyOn(
-    svc as unknown as { resolveEntry: (peerId: string) => Promise<unknown> },
-    'resolveEntry',
-  ).mockImplementation(async (_peerId: string) => {
-    // Still call DB (via the real logic) to exercise peer validation,
-    // but return mock pool as the agent.
-    // For simplicity in unit tests, directly return a controlled entry.
-    return {
-      agent: mockPool,
-      endpointUrl: ENDPOINT,
-      certPem: TEST_CERT_PEM,
-      certSerial: TEST_CERT_SERIAL,
-    };
-  });
-
-  return svc;
-}
-
-// ---------------------------------------------------------------------------
-// Test setup
-// ---------------------------------------------------------------------------
-
-let originalDispatcher: Dispatcher;
-
-beforeAll(() => {
-  // Seal the test key once — requires BETTER_AUTH_SECRET
-  const saved = process.env['BETTER_AUTH_SECRET'];
-  process.env['BETTER_AUTH_SECRET'] = TEST_SECRET;
-  try {
-    SEALED_KEY = sealClientKey(TEST_PRIVATE_KEY_PEM);
-  } finally {
-    if (saved === undefined) {
-      delete process.env['BETTER_AUTH_SECRET'];
-    } else {
-      process.env['BETTER_AUTH_SECRET'] = saved;
-    }
-  }
-  writeFileSync(STUB_CA_PEM_PATH, STUB_CA_PEM, 'utf8');
-});
-
-afterAll(() => {
-  try {
-    unlinkSync(STUB_CA_PEM_PATH);
-  } catch {
-    // best-effort cleanup
-  }
-});
-
-beforeEach(() => {
-  originalDispatcher = getGlobalDispatcher();
-  process.env['BETTER_AUTH_SECRET'] = TEST_SECRET;
-  process.env['STEP_CA_ROOT_CERT_PATH'] = STUB_CA_PEM_PATH;
-});
-
-afterEach(() => {
-  setGlobalDispatcher(originalDispatcher);
-  vi.restoreAllMocks();
-  delete process.env['BETTER_AUTH_SECRET'];
-  delete process.env['STEP_CA_ROOT_CERT_PATH'];
-});
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Successful list response body */
-const LIST_BODY = {
-  items: [{ id: '1', title: 'Task One' }],
-  nextCursor: undefined,
-  _partial: false,
-};
-
-/** Successful get response body */
-const GET_BODY = {
-  item: { id: '1', title: 'Task One' },
-  _partial: false,
-};
-
-/** Successful capabilities response body */
-const CAP_BODY = {
-  resources: ['tasks'],
-  excluded_resources: [],
-  max_rows_per_query: 100,
-  supported_verbs: ['list', 'get', 'capabilities'] as const,
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('FederationClientService', () => {
-  // ─── Successful verb calls ─────────────────────────────────────────────────
-
-  describe('list()', () => {
-    it('returns parsed typed response on success', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool
-        .intercept({
-          path: '/api/federation/v1/list/tasks',
-          method: 'POST',
-        })
-        .reply(200, LIST_BODY, { headers: { 'content-type': 'application/json' } });
-
-      const result = await svc.list(PEER_ID, 'tasks', {});
-
-      expect(result.items).toHaveLength(1);
-      expect(result.items[0]).toMatchObject({ id: '1', title: 'Task One' });
-
-      await mockAgent.close();
-    });
-  });
-
-  describe('get()', () => {
-    it('returns parsed typed response on success', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool
-        .intercept({
-          path: '/api/federation/v1/get/tasks/1',
-          method: 'POST',
-        })
-        .reply(200, GET_BODY, { headers: { 'content-type': 'application/json' } });
-
-      const result = await svc.get(PEER_ID, 'tasks', '1', {});
-
-      expect(result.item).toMatchObject({ id: '1', title: 'Task One' });
-
-      await mockAgent.close();
-    });
-  });
-
-  describe('capabilities()', () => {
-    it('returns parsed capabilities response on success', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool
-        .intercept({
-          path: '/api/federation/v1/capabilities',
-          method: 'GET',
-        })
-        .reply(200, CAP_BODY, { headers: { 'content-type': 'application/json' } });
-
-      const result = await svc.capabilities(PEER_ID);
-
-      expect(result.resources).toContain('tasks');
-      expect(result.max_rows_per_query).toBe(100);
-
-      await mockAgent.close();
-    });
-  });
-
-  // ─── HTTP error surfaces ──────────────────────────────────────────────────
-
-  describe('non-2xx responses', () => {
-    it('surfaces 403 as FederationClientError({ status: 403, code: "FORBIDDEN" })', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool.intercept({ path: '/api/federation/v1/list/tasks', method: 'POST' }).reply(
-        403,
-        { error: { code: 'forbidden', message: 'Access denied' } },
-        {
-          headers: { 'content-type': 'application/json' },
-        },
-      );
-
-      await expect(svc.list(PEER_ID, 'tasks', {})).rejects.toMatchObject({
-        status: 403,
-        code: 'FORBIDDEN',
-        peerId: PEER_ID,
-      });
-
-      await mockAgent.close();
-    });
-
-    it('surfaces 404 as FederationClientError({ status: 404, code: "HTTP_404" })', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool.intercept({ path: '/api/federation/v1/get/tasks/999', method: 'POST' }).reply(
-        404,
-        { error: { code: 'not_found', message: 'Not found' } },
-        {
-          headers: { 'content-type': 'application/json' },
-        },
-      );
-
-      await expect(svc.get(PEER_ID, 'tasks', '999', {})).rejects.toMatchObject({
-        status: 404,
-        code: 'HTTP_404',
-        peerId: PEER_ID,
-      });
-
-      await mockAgent.close();
-    });
-  });
-
-  // ─── Network error ─────────────────────────────────────────────────────────
-
-  describe('network errors', () => {
-    it('surfaces network error as FederationClientError({ code: "NETWORK" })', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool
-        .intercept({ path: '/api/federation/v1/capabilities', method: 'GET' })
-        .replyWithError(new Error('ECONNREFUSED'));
-
-      await expect(svc.capabilities(PEER_ID)).rejects.toMatchObject({
-        code: 'NETWORK',
-        peerId: PEER_ID,
-      });
-
-      await mockAgent.close();
-    });
-  });
-
-  // ─── Invalid response body ─────────────────────────────────────────────────
-
-  describe('invalid response body', () => {
-    it('surfaces as FederationClientError({ code: "INVALID_RESPONSE" }) when body shape is wrong', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      // capabilities returns wrong shape (missing required fields)
-      pool
-        .intercept({ path: '/api/federation/v1/capabilities', method: 'GET' })
-        .reply(200, { totally: 'wrong' }, { headers: { 'content-type': 'application/json' } });
-
-      await expect(svc.capabilities(PEER_ID)).rejects.toMatchObject({
-        code: 'INVALID_RESPONSE',
-        peerId: PEER_ID,
-      });
-
-      await mockAgent.close();
-    });
-  });
-
-  // ─── Peer DB validation ────────────────────────────────────────────────────
-
-  describe('peer validation (without resolveEntry spy)', () => {
-    /**
-     * These tests exercise the real `resolveEntry` path — no spy on resolveEntry.
-     */
-
-    it('throws PEER_NOT_FOUND when peer is not in DB', async () => {
-      // DB returns empty array (peer not found)
-      const db = makeDb([]);
-      const svc = new FederationClientService(db);
-
-      await expect(svc.capabilities(PEER_ID)).rejects.toMatchObject({
-        code: 'PEER_NOT_FOUND',
-        peerId: PEER_ID,
-      });
-    });
-
-    it('throws PEER_INACTIVE when peer state is not "active"', async () => {
-      const db = makeDb([makePeerRow({ state: 'suspended' })]);
-      const svc = new FederationClientService(db);
-
-      await expect(svc.capabilities(PEER_ID)).rejects.toMatchObject({
-        code: 'PEER_INACTIVE',
-        peerId: PEER_ID,
-      });
-    });
-  });
-
-  // ─── Cache behaviour ───────────────────────────────────────────────────────
-
-  describe('cache behaviour', () => {
-    it('hits cache on second call — only one DB lookup happens', async () => {
-      // Verify cache by calling the private resolveEntry directly twice and
-      // asserting the DB was queried only once. This avoids the HTTP layer,
-      // which would require either a real network or per-peer Agent rewiring
-      // that the cache invariant doesn't depend on.
-      const db = makeDb();
-      const selectSpy = vi.spyOn(db, 'select');
-      const svc = new FederationClientService(db);
-      const resolveEntry = (
-        svc as unknown as { resolveEntry: (peerId: string) => Promise<unknown> }
-      ).resolveEntry.bind(svc);
-
-      const first = await resolveEntry(PEER_ID);
-      const second = await resolveEntry(PEER_ID);
-
-      expect(first).toBe(second);
-      expect(selectSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('serializes concurrent resolveEntry calls — only one DB lookup', async () => {
-      const db = makeDb();
-      const selectSpy = vi.spyOn(db, 'select');
-      const svc = new FederationClientService(db);
-      const resolveEntry = (
-        svc as unknown as {
-          resolveEntry: (peerId: string) => Promise<unknown>;
-        }
-      ).resolveEntry.bind(svc);
-
-      const [a, b] = await Promise.all([resolveEntry(PEER_ID), resolveEntry(PEER_ID)]);
-      expect(a).toBe(b);
-      expect(selectSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('flushPeer destroys the evicted Agent so old TLS connections close', async () => {
-      const db = makeDb();
-      const svc = new FederationClientService(db);
-      const resolveEntry = (
-        svc as unknown as {
-          resolveEntry: (peerId: string) => Promise<{ agent: { destroy: () => Promise<void> } }>;
-        }
-      ).resolveEntry.bind(svc);
-
-      const entry = await resolveEntry(PEER_ID);
-      const destroySpy = vi.spyOn(entry.agent, 'destroy').mockResolvedValue();
-
-      svc.flushPeer(PEER_ID);
-      expect(destroySpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('flushPeer() invalidates cache — next call re-reads DB', async () => {
-      const db = makeDb();
-      const { mockAgent, pool } = makeMockAgent();
-      const svc = makeService(db, pool);
-
-      pool
-        .intercept({ path: '/api/federation/v1/capabilities', method: 'GET' })
-        .reply(200, CAP_BODY, { headers: { 'content-type': 'application/json' } })
-        .times(2);
-
-      // First call — populates cache (via mock resolveEntry)
-      await svc.capabilities(PEER_ID);
-
-      // Flush the cache
-      svc.flushPeer(PEER_ID);
-
-      // The spy on resolveEntry is still active — check it's called again after flush
-      const resolveEntrySpy = vi.spyOn(
-        svc as unknown as { resolveEntry: (peerId: string) => Promise<unknown> },
-        'resolveEntry',
-      );
-
-      // Second call after flush — should call resolveEntry again
-      await svc.capabilities(PEER_ID);
-
-      // resolveEntry should have been called once after we started spying (post-flush)
-      expect(resolveEntrySpy).toHaveBeenCalledTimes(1);
-
-      await mockAgent.close();
-    });
-  });
-
-  // ─── loadStepCaRoot env-var guard ─────────────────────────────────────────
-
-  describe('loadStepCaRoot() env-var guard', () => {
-    it('throws PEER_MISCONFIGURED when STEP_CA_ROOT_CERT_PATH is not set', async () => {
-      delete process.env['STEP_CA_ROOT_CERT_PATH'];
-      const db = makeDb();
-      const svc = new FederationClientService(db);
-      const resolveEntry = (
-        svc as unknown as {
-          resolveEntry: (peerId: string) => Promise<unknown>;
-        }
-      ).resolveEntry.bind(svc);
-
-      await expect(resolveEntry(PEER_ID)).rejects.toMatchObject({
-        code: 'PEER_MISCONFIGURED',
-      });
-    });
-  });
-
-  // ─── FederationClientError class ──────────────────────────────────────────
-
-  describe('FederationClientError', () => {
-    it('is instanceof Error and FederationClientError', () => {
-      const err = new FederationClientError({
-        code: 'PEER_NOT_FOUND',
-        message: 'test',
-        peerId: PEER_ID,
-      });
-      expect(err).toBeInstanceOf(Error);
-      expect(err).toBeInstanceOf(FederationClientError);
-      expect(err.name).toBe('FederationClientError');
-    });
-
-    it('carries status, code, and peerId', () => {
-      const err = new FederationClientError({
-        status: 403,
-        code: 'FORBIDDEN',
-        message: 'forbidden',
-        peerId: PEER_ID,
-      });
-      expect(err.status).toBe(403);
-      expect(err.code).toBe('FORBIDDEN');
-      expect(err.peerId).toBe(PEER_ID);
-    });
-  });
-});

apps/gateway/src/federation/client/federation-client.service.ts

@@ -1,500 +0,0 @@
-/**
- * FederationClientService — outbound mTLS client for federation requests (FED-M3-08).
- *
- * Dials peer gateways over mTLS using the cert+sealed-key stored in `federation_peers`,
- * invokes federation verbs (list / get / capabilities), and surfaces all failure modes
- * as typed `FederationClientError` instances.
- *
- * ## Error code taxonomy
- *
- * | Code               | When                                                          |
- * | ------------------ | ------------------------------------------------------------- |
- * | PEER_NOT_FOUND     | No row in federation_peers for the given peerId               |
- * | PEER_INACTIVE      | Peer row exists but state !== 'active'                        |
- * | PEER_MISCONFIGURED | Peer row is active but missing endpointUrl or clientKeyPem    |
- * | NETWORK            | undici threw a connection / TLS / timeout error               |
- * | HTTP_{status}      | Peer returned a non-2xx response (e.g. HTTP_403, HTTP_404)    |
- * | FORBIDDEN          | Peer returned 403 (convenience alias alongside HTTP_403)      |
- * | INVALID_RESPONSE   | Response body failed Zod schema validation                    |
- *
- * ## Cache strategy
- *
- * Per-peer `undici.Agent` instances are cached in a `Map<peerId, AgentCacheEntry>` for
- * the lifetime of the service instance.  The cache is keyed on peerId (UUID).
- *
- * Cache invalidation:
- *  - `flushPeer(peerId)` — removes the entry immediately.  M5/M6 MUST call this on
- *    cert rotation or peer revocation events so the next request re-reads the DB and
- *    builds a fresh TLS Agent with the new cert material.
- *  - On cache miss: re-reads the DB, checks state === 'active', rebuilds Agent.
- *
- * Cache does NOT auto-expire.  The service is expected to be a singleton scoped to the
- * NestJS application lifecycle; flushing on revocation/rotation is the only invalidation
- * path by design (avoids redundant DB round-trips on the hot path).
- */
-
-import { Injectable, Inject, Logger } from '@nestjs/common';
-import { readFileSync } from 'node:fs';
-import { Agent, fetch as undiciFetch } from 'undici';
-import type { Dispatcher } from 'undici';
-import { z } from 'zod';
-import { type Db, eq, federationPeers } from '@mosaicstack/db';
-import {
-  FederationListResponseSchema,
-  FederationGetResponseSchema,
-  FederationCapabilitiesResponseSchema,
-  FederationErrorEnvelopeSchema,
-  type FederationListResponse,
-  type FederationGetResponse,
-  type FederationCapabilitiesResponse,
-} from '@mosaicstack/types';
-import { DB } from '../../database/database.module.js';
-import { unsealClientKey } from '../peer-key.util.js';
-
-// ---------------------------------------------------------------------------
-// Error taxonomy
-// ---------------------------------------------------------------------------
-
-/**
- * Client-side error code set.  Distinct from the server-side `FederationErrorCode`
- * (which lives in `@mosaicstack/types`) because the client has additional failure
- * modes (PEER_NOT_FOUND, PEER_INACTIVE, PEER_MISCONFIGURED, NETWORK) that the
- * server never emits.
- */
-export type FederationClientErrorCode =
-  | 'PEER_NOT_FOUND'
-  | 'PEER_INACTIVE'
-  | 'PEER_MISCONFIGURED'
-  | 'NETWORK'
-  | 'FORBIDDEN'
-  | 'INVALID_RESPONSE'
-  | `HTTP_${number}`;
-
-export interface FederationClientErrorOptions {
-  status?: number;
-  code: FederationClientErrorCode;
-  message: string;
-  peerId: string;
-  cause?: unknown;
-}
-
-/**
- * Thrown by FederationClientService on every failure path.
- * Callers can dispatch on `error.code` for programmatic handling.
- */
-export class FederationClientError extends Error {
-  readonly status?: number;
-  readonly code: FederationClientErrorCode;
-  readonly peerId: string;
-  readonly cause?: unknown;
-
-  constructor(opts: FederationClientErrorOptions) {
-    super(opts.message);
-    this.name = 'FederationClientError';
-    this.status = opts.status;
-    this.code = opts.code;
-    this.peerId = opts.peerId;
-    this.cause = opts.cause;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Internal cache types
-// ---------------------------------------------------------------------------
-
-interface AgentCacheEntry {
-  agent: Agent;
-  endpointUrl: string;
-  certPem: string;
-  certSerial: string;
-}
-
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-
-@Injectable()
-export class FederationClientService {
-  private readonly logger = new Logger(FederationClientService.name);
-
-  /**
-   * Per-peer undici Agent cache.
-   * Key = peerId (UUID string).
-   *
-   * Values are either a resolved `AgentCacheEntry` or an in-flight
-   * `Promise<AgentCacheEntry>` (promise-cache pattern).  Storing the promise
-   * prevents duplicate DB lookups and duplicate key-unseal operations when two
-   * requests for the same peer arrive before the first build completes.
-   *
-   * Flush via `flushPeer(peerId)` on cert rotation / peer revocation (M5/M6).
-   */
-  private readonly cache = new Map<string, AgentCacheEntry | Promise<AgentCacheEntry>>();
-
-  /**
-   * Step-CA root cert PEM, loaded once from `STEP_CA_ROOT_CERT_PATH`.
-   * Used as the trust anchor for peer server certificates so federation TLS is
-   * pinned to our PKI, not the public trust store. Lazily loaded on first use
-   * so unit tests that don't exercise the agent path can run without the env var.
-   */
-  private cachedCaPem: string | null = null;
-
-  constructor(@Inject(DB) private readonly db: Db) {}
-
-  // -------------------------------------------------------------------------
-  // Public verb API
-  // -------------------------------------------------------------------------
-
-  /**
-   * Invoke the `list` verb on a remote peer.
-   *
-   * @param peerId   UUID of the peer row in `federation_peers`.
-   * @param resource Resource path, e.g. "tasks".
-   * @param request  Free-form body sent as JSON in the POST body.
-   * @returns Parsed `FederationListResponse<T>`.
-   */
-  async list<T>(
-    peerId: string,
-    resource: string,
-    request: Record<string, unknown>,
-  ): Promise<FederationListResponse<T>> {
-    const { endpointUrl, agent } = await this.resolveEntry(peerId);
-    const url = `${endpointUrl}/api/federation/v1/list/${encodeURIComponent(resource)}`;
-    const body = await this.doPost(peerId, url, agent, request);
-    return this.parseWith<FederationListResponse<T>>(
-      peerId,
-      body,
-      FederationListResponseSchema(z.unknown()),
-    );
-  }
-
-  /**
-   * Invoke the `get` verb on a remote peer.
-   *
-   * @param peerId   UUID of the peer row in `federation_peers`.
-   * @param resource Resource path, e.g. "tasks".
-   * @param id       Resource identifier.
-   * @param request  Free-form body sent as JSON in the POST body.
-   * @returns Parsed `FederationGetResponse<T>`.
-   */
-  async get<T>(
-    peerId: string,
-    resource: string,
-    id: string,
-    request: Record<string, unknown>,
-  ): Promise<FederationGetResponse<T>> {
-    const { endpointUrl, agent } = await this.resolveEntry(peerId);
-    const url = `${endpointUrl}/api/federation/v1/get/${encodeURIComponent(resource)}/${encodeURIComponent(id)}`;
-    const body = await this.doPost(peerId, url, agent, request);
-    return this.parseWith<FederationGetResponse<T>>(
-      peerId,
-      body,
-      FederationGetResponseSchema(z.unknown()),
-    );
-  }
-
-  /**
-   * Invoke the `capabilities` verb on a remote peer.
-   *
-   * @param peerId UUID of the peer row in `federation_peers`.
-   * @returns Parsed `FederationCapabilitiesResponse`.
-   */
-  async capabilities(peerId: string): Promise<FederationCapabilitiesResponse> {
-    const { endpointUrl, agent } = await this.resolveEntry(peerId);
-    const url = `${endpointUrl}/api/federation/v1/capabilities`;
-    const body = await this.doGet(peerId, url, agent);
-    return this.parseWith<FederationCapabilitiesResponse>(
-      peerId,
-      body,
-      FederationCapabilitiesResponseSchema,
-    );
-  }
-
-  // -------------------------------------------------------------------------
-  // Cache management
-  // -------------------------------------------------------------------------
-
-  /**
-   * Flush the cached Agent for a specific peer.
-   *
-   * M5/M6 MUST call this on:
-   *  - cert rotation events (so new cert material is picked up)
-   *  - peer revocation events (so future requests fail at PEER_INACTIVE)
-   *
-   * After flushing, the next call to `list`, `get`, or `capabilities` for
-   * this peer will re-read the DB and rebuild the Agent.
-   */
-  flushPeer(peerId: string): void {
-    const entry = this.cache.get(peerId);
-    if (entry === undefined) {
-      return;
-    }
-    this.cache.delete(peerId);
-    if (!(entry instanceof Promise)) {
-      // best-effort destroy; promise-cached entries skip destroy because
-      // the in-flight build owns its own Agent which will be GC'd when the
-      // owning request handles the rejection from the cache miss
-      entry.agent.destroy().catch(() => {
-        // intentionally ignored — destroy errors are not actionable
-      });
-    }
-    this.logger.log(`Cache flushed for peer ${peerId}`);
-  }
-
-  // -------------------------------------------------------------------------
-  // Internal helpers
-  // -------------------------------------------------------------------------
-
-  /**
-   * Load and cache the Step-CA root cert PEM from `STEP_CA_ROOT_CERT_PATH`.
-   * Throws `FederationClientError` if the env var is unset or the file cannot
-   * be read — mTLS to a peer without a pinned trust anchor would silently
-   * fall back to the public trust store.
-   */
-  private loadStepCaRoot(): string {
-    if (this.cachedCaPem !== null) {
-      return this.cachedCaPem;
-    }
-    const path = process.env['STEP_CA_ROOT_CERT_PATH'];
-    if (!path) {
-      throw new FederationClientError({
-        code: 'PEER_MISCONFIGURED',
-        message: 'STEP_CA_ROOT_CERT_PATH is not set; refusing to dial peer without pinned CA trust',
-        peerId: '',
-      });
-    }
-    try {
-      const pem = readFileSync(path, 'utf8');
-      this.cachedCaPem = pem;
-      return pem;
-    } catch (err) {
-      throw new FederationClientError({
-        code: 'PEER_MISCONFIGURED',
-        message: `Failed to read STEP_CA_ROOT_CERT_PATH (${path})`,
-        peerId: '',
-        cause: err,
-      });
-    }
-  }
-
-  /**
-   * Resolve the cache entry for a peer, reading DB on miss.
-   *
-   * Uses a promise-cache pattern: concurrent callers for the same uncached
-   * `peerId` all `await` the same in-flight `Promise<AgentCacheEntry>` so
-   * only one DB lookup and one key-unseal ever runs per peer per cache miss.
-   * The promise is replaced with the concrete entry on success, or deleted on
-   * rejection so a transient error does not poison the cache permanently.
-   *
-   * Throws `FederationClientError` with appropriate code if the peer is not
-   * found, is inactive, or is missing required fields.
-   */
-  private async resolveEntry(peerId: string): Promise<AgentCacheEntry> {
-    const cached = this.cache.get(peerId);
-    if (cached) {
-      return cached; // Promise or concrete entry — both are awaitable
-    }
-
-    const inflight = this.buildEntry(peerId).then(
-      (entry) => {
-        this.cache.set(peerId, entry); // replace promise with concrete value
-        return entry;
-      },
-      (err: unknown) => {
-        this.cache.delete(peerId); // don't poison the cache with a rejected promise
-        throw err;
-      },
-    );
-
-    this.cache.set(peerId, inflight);
-    return inflight;
-  }
-
-  /**
-   * Build the `AgentCacheEntry` for a peer by reading the DB, validating the
-   * peer's state, unsealing the private key, and constructing the mTLS Agent.
-   *
-   * Throws `FederationClientError` with appropriate code if the peer is not
-   * found, is inactive, or is missing required fields.
-   */
-  private async buildEntry(peerId: string): Promise<AgentCacheEntry> {
-    // DB lookup
-    const [peer] = await this.db
-      .select()
-      .from(federationPeers)
-      .where(eq(federationPeers.id, peerId))
-      .limit(1);
-
-    if (!peer) {
-      throw new FederationClientError({
-        code: 'PEER_NOT_FOUND',
-        message: `Federation peer ${peerId} not found`,
-        peerId,
-      });
-    }
-
-    if (peer.state !== 'active') {
-      throw new FederationClientError({
-        code: 'PEER_INACTIVE',
-        message: `Federation peer ${peerId} is not active (state: ${peer.state})`,
-        peerId,
-      });
-    }
-
-    if (!peer.endpointUrl || !peer.clientKeyPem) {
-      throw new FederationClientError({
-        code: 'PEER_MISCONFIGURED',
-        message: `Federation peer ${peerId} is missing endpointUrl or clientKeyPem`,
-        peerId,
-      });
-    }
-
-    // Unseal the private key
-    let privateKeyPem: string;
-    try {
-      privateKeyPem = unsealClientKey(peer.clientKeyPem);
-    } catch (err) {
-      throw new FederationClientError({
-        code: 'PEER_MISCONFIGURED',
-        message: `Failed to unseal client key for peer ${peerId}`,
-        peerId,
-        cause: err,
-      });
-    }
-
-    // Build mTLS agent — pin trust to Step-CA root so we never accept
-    // a peer cert signed by a public CA (defense against MITM with a
-    // publicly-trusted DV cert for the peer's hostname).
-    const agent = new Agent({
-      connect: {
-        cert: peer.certPem,
-        key: privateKeyPem,
-        ca: this.loadStepCaRoot(),
-        // rejectUnauthorized: true is the undici default for HTTPS
-      },
-    });
-
-    const entry: AgentCacheEntry = {
-      agent,
-      endpointUrl: peer.endpointUrl,
-      certPem: peer.certPem,
-      certSerial: peer.certSerial,
-    };
-
-    this.logger.log(`Agent cached for peer ${peerId} (serial: ${peer.certSerial})`);
-
-    return entry;
-  }
-
-  /**
-   * Execute a POST request with a JSON body.
-   * Returns the parsed response body as an unknown value.
-   * Throws `FederationClientError` on network errors and non-2xx responses.
-   */
-  private async doPost(
-    peerId: string,
-    url: string,
-    agent: Dispatcher,
-    body: Record<string, unknown>,
-  ): Promise<unknown> {
-    return this.doRequest(peerId, url, agent, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-  }
-
-  /**
-   * Execute a GET request.
-   * Returns the parsed response body as an unknown value.
-   * Throws `FederationClientError` on network errors and non-2xx responses.
-   */
-  private async doGet(peerId: string, url: string, agent: Dispatcher): Promise<unknown> {
-    return this.doRequest(peerId, url, agent, { method: 'GET' });
-  }
-
-  private async doRequest(
-    peerId: string,
-    url: string,
-    agent: Dispatcher,
-    init: { method: string; headers?: Record<string, string>; body?: string },
-  ): Promise<unknown> {
-    let response: Awaited<ReturnType<typeof undiciFetch>>;
-
-    try {
-      response = await undiciFetch(url, {
-        ...init,
-        dispatcher: agent,
-      });
-    } catch (err) {
-      throw new FederationClientError({
-        code: 'NETWORK',
-        message: `Network error calling peer ${peerId} at ${url}: ${err instanceof Error ? err.message : String(err)}`,
-        peerId,
-        cause: err,
-      });
-    }
-
-    const rawBody = await response.text().catch(() => '');
-
-    if (!response.ok) {
-      const status = response.status;
-
-      // Attempt to parse as federation error envelope
-      let serverMessage = `HTTP ${status}`;
-      try {
-        const json: unknown = JSON.parse(rawBody);
-        const result = FederationErrorEnvelopeSchema.safeParse(json);
-        if (result.success) {
-          serverMessage = result.data.error.message;
-        }
-      } catch {
-        // Not valid JSON or not a federation envelope — use generic message
-      }
-
-      // Specific code for 403 (most actionable for callers); generic HTTP_{n} for others
-      const code: FederationClientErrorCode = status === 403 ? 'FORBIDDEN' : `HTTP_${status}`;
-
-      throw new FederationClientError({
-        status,
-        code,
-        message: `Peer ${peerId} returned ${status}: ${serverMessage}`,
-        peerId,
-      });
-    }
-
-    try {
-      return JSON.parse(rawBody) as unknown;
-    } catch (err) {
-      throw new FederationClientError({
-        code: 'INVALID_RESPONSE',
-        message: `Peer ${peerId} returned non-JSON body`,
-        peerId,
-        cause: err,
-      });
-    }
-  }
-
-  /**
-   * Parse and validate a response body against a Zod schema.
-   *
-   * For list/get, callers pass the result of `FederationListResponseSchema(z.unknown())`
-   * so that the envelope structure is validated without requiring a concrete item schema
-   * at the client level.  The generic `T` provides compile-time typing.
-   *
-   * Throws `FederationClientError({ code: 'INVALID_RESPONSE' })` on parse failure.
-   */
-  private parseWith<T>(peerId: string, body: unknown, schema: z.ZodTypeAny): T {
-    const result = schema.safeParse(body);
-    if (!result.success) {
-      const issues = result.error.issues
-        .map((e: z.ZodIssue) => `[${e.path.join('.') || 'root'}] ${e.message}`)
-        .join('; ');
-      throw new FederationClientError({
-        code: 'INVALID_RESPONSE',
-        message: `Peer ${peerId} returned invalid response shape: ${issues}`,
-        peerId,
-      });
-    }
-    return result.data as T;
-  }
-}

apps/gateway/src/federation/client/index.ts

@@ -1,13 +0,0 @@
-/**
- * Federation client barrel — re-exports for FederationModule consumers.
- *
- * M3-09 (QuerySourceService) and future milestones should import from here,
- * not directly from the implementation file.
- */
-
-export {
-  FederationClientService,
-  FederationClientError,
-  type FederationClientErrorCode,
-  type FederationClientErrorOptions,
-} from './federation-client.service.js';

apps/gateway/src/federation/federation.module.ts

@@ -5,25 +5,10 @@ import { EnrollmentController } from './enrollment.controller.js';
 import { EnrollmentService } from './enrollment.service.js';
 import { FederationController } from './federation.controller.js';
 import { GrantsService } from './grants.service.js';
-import { FederationClientService } from './client/index.js';
-import { FederationAuthGuard } from './server/index.js';
 
 @Module({
   controllers: [EnrollmentController, FederationController],
-  providers: [
+  providers: [AdminGuard, CaService, EnrollmentService, GrantsService],
-    AdminGuard,
+  exports: [CaService, EnrollmentService, GrantsService],
-    CaService,
-    EnrollmentService,
-    GrantsService,
-    FederationClientService,
-    FederationAuthGuard,
-  ],
-  exports: [
-    CaService,
-    EnrollmentService,
-    GrantsService,
-    FederationClientService,
-    FederationAuthGuard,
-  ],
 })
 export class FederationModule {}

apps/gateway/src/federation/grants.service.ts

@@ -10,14 +10,12 @@
  */
 
 import { ConflictException, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { type Db, and, eq, federationGrants, federationPeers } from '@mosaicstack/db';
+import { type Db, and, eq, federationGrants } from '@mosaicstack/db';
 import { DB } from '../database/database.module.js';
 import { parseFederationScope } from './scope-schema.js';
 import type { CreateGrantDto, ListGrantsDto } from './grants.dto.js';
 
 export type Grant = typeof federationGrants.$inferSelect;
-export type Peer = typeof federationPeers.$inferSelect;
-export type GrantWithPeer = Grant & { peer: Peer };
 
 @Injectable()
 export class GrantsService {
@@ -62,33 +60,6 @@ export class GrantsService {
     return grant;
   }
 
-  /**
-   * Fetch a single grant by ID, joined with its associated peer row.
-   * Used by FederationAuthGuard to perform grant status + cert serial checks
-   * in a single DB round-trip.
-   *
-   * Throws NotFoundException if the grant does not exist.
-   * Throws NotFoundException if the associated peer row is missing (data integrity issue).
-   */
-  async getGrantWithPeer(id: string): Promise<GrantWithPeer> {
-    const rows = await this.db
-      .select()
-      .from(federationGrants)
-      .innerJoin(federationPeers, eq(federationGrants.peerId, federationPeers.id))
-      .where(eq(federationGrants.id, id))
-      .limit(1);
-
-    const row = rows[0];
-    if (!row) {
-      throw new NotFoundException(`Grant ${id} not found`);
-    }
-
-    return {
-      ...row.federation_grants,
-      peer: row.federation_peers,
-    };
-  }
-
   /**
    * List grants with optional filters for peerId, subjectUserId, and status.
    */

apps/gateway/src/federation/oid.util.ts

@@ -1,146 +0,0 @@
-/**
- * Shared OID extraction helpers for Mosaic federation certificates.
- *
- * Custom OID registry (PRD §6, docs/federation/SETUP.md):
- *   1.3.6.1.4.1.99999.1  — mosaic_grant_id
- *   1.3.6.1.4.1.99999.2  — mosaic_subject_user_id
- *
- * The encoding convention: each extension value is an OCTET STRING wrapping
- * an ASN.1 UTF8String TLV:
- *   0x0C (tag) + 1-byte length + UTF-8 bytes
- *
- * CaService encodes values this way via encodeUtf8String(), and this module
- * decodes them with the corresponding `.slice(2)` to skip tag + length byte.
- *
- * This module is intentionally pure — no NestJS, no DB, no network I/O.
- */
-
-import { X509Certificate } from '@peculiar/x509';
-
-// ---------------------------------------------------------------------------
-// OID constants
-// ---------------------------------------------------------------------------
-
-export const OID_MOSAIC_GRANT_ID = '1.3.6.1.4.1.99999.1';
-export const OID_MOSAIC_SUBJECT_USER_ID = '1.3.6.1.4.1.99999.2';
-
-// ---------------------------------------------------------------------------
-// Extraction result types
-// ---------------------------------------------------------------------------
-
-export interface MosaicOids {
-  grantId: string;
-  subjectUserId: string;
-}
-
-export type OidExtractionResult =
-  | { ok: true; value: MosaicOids }
-  | {
-      ok: false;
-      error: 'MISSING_GRANT_ID' | 'MISSING_SUBJECT_USER_ID' | 'PARSE_ERROR';
-      detail?: string;
-    };
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const decoder = new TextDecoder();
-
-/**
- * Decode an extension value encoded as ASN.1 UTF8String TLV
- * (tag 0x0C + 1-byte length + UTF-8 bytes).
- * Validates tag, length byte, and buffer bounds before decoding.
- * Throws a descriptive Error on malformed input; caller wraps in try/catch.
- */
-function decodeUtf8StringTlv(value: ArrayBuffer): string {
-  const bytes = new Uint8Array(value);
-
-  // Need at least tag + length bytes
-  if (bytes.length < 2) {
-    throw new Error(`UTF8String TLV too short: expected at least 2 bytes, got ${bytes.length}`);
-  }
-
-  // Tag byte must be 0x0C (ASN.1 UTF8String)
-  if (bytes[0] !== 0x0c) {
-    throw new Error(
-      `UTF8String TLV tag mismatch: expected 0x0C, got 0x${bytes[0]!.toString(16).toUpperCase()}`,
-    );
-  }
-
-  // Only single-byte length form is supported (values 0–127); long form not needed
-  // for OID strings of this length.
-  const declaredLength = bytes[1]!;
-  if (declaredLength > 127) {
-    throw new Error(
-      `UTF8String TLV uses long-form length (0x${declaredLength.toString(16).toUpperCase()}), which is not supported`,
-    );
-  }
-
-  // Declared length must match actual remaining bytes
-  if (declaredLength !== bytes.length - 2) {
-    throw new Error(
-      `UTF8String TLV length mismatch: declared ${declaredLength}, actual ${bytes.length - 2}`,
-    );
-  }
-
-  // Skip: tag (1 byte) + length (1 byte)
-  return decoder.decode(bytes.slice(2));
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Extract Mosaic custom OIDs (grantId, subjectUserId) from an X.509 certificate
- * already parsed via @peculiar/x509.
- *
- * Returns `{ ok: true, value: MosaicOids }` on success, or
- * `{ ok: false, error: <code>, detail? }` on any failure — never throws.
- */
-export function extractMosaicOids(cert: X509Certificate): OidExtractionResult {
-  try {
-    const grantIdExt = cert.getExtension(OID_MOSAIC_GRANT_ID);
-    if (!grantIdExt) {
-      return { ok: false, error: 'MISSING_GRANT_ID' };
-    }
-
-    const subjectUserIdExt = cert.getExtension(OID_MOSAIC_SUBJECT_USER_ID);
-    if (!subjectUserIdExt) {
-      return { ok: false, error: 'MISSING_SUBJECT_USER_ID' };
-    }
-
-    const grantId = decodeUtf8StringTlv(grantIdExt.value);
-    const subjectUserId = decodeUtf8StringTlv(subjectUserIdExt.value);
-
-    return {
-      ok: true,
-      value: { grantId, subjectUserId },
-    };
-  } catch (err) {
-    return {
-      ok: false,
-      error: 'PARSE_ERROR',
-      detail: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-/**
- * Parse a PEM-encoded certificate and extract Mosaic OIDs.
- * Returns an OidExtractionResult — never throws.
- */
-export function extractMosaicOidsFromPem(certPem: string): OidExtractionResult {
-  let cert: X509Certificate;
-  try {
-    cert = new X509Certificate(certPem);
-  } catch (err) {
-    return {
-      ok: false,
-      error: 'PARSE_ERROR',
-      detail: err instanceof Error ? err.message : String(err),
-    };
-  }
-  return extractMosaicOids(cert);
-}

apps/gateway/src/federation/server/__tests__/federation-auth.guard.spec.ts

@@ -1,521 +0,0 @@
-/**
- * Unit tests for FederationAuthGuard (FED-M3-03).
- *
- * Coverage:
- *  - Missing cert (no TLS socket / no getPeerCertificate) → 401
- *  - Cert parse failure (corrupt DER raw bytes) → 401
- *  - Missing grantId OID → 401
- *  - Missing subjectUserId OID → 401
- *  - Grant not found (GrantsService throws NotFoundException) → 403
- *  - Grant in `pending` status → 403
- *  - Grant in `revoked` status → 403
- *  - Grant in `expired` status → 403
- *  - Cert serial mismatch → 403
- *  - Happy path: active grant + matching cert serial → context attached, returns true
- */
-
-import 'reflect-metadata';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ExecutionContext } from '@nestjs/common';
-import { NotFoundException } from '@nestjs/common';
-import { FederationAuthGuard } from '../federation-auth.guard.js';
-import { makeMosaicIssuedCert } from '../../__tests__/helpers/test-cert.js';
-import type { GrantsService, GrantWithPeer } from '../../grants.service.js';
-
-// ---------------------------------------------------------------------------
-// Test constants
-// ---------------------------------------------------------------------------
-
-const GRANT_ID = 'a1111111-1111-1111-1111-111111111111';
-const USER_ID = 'b2222222-2222-2222-2222-222222222222';
-const PEER_ID = 'c3333333-3333-3333-3333-333333333333';
-
-// Node.js TLS serialNumber is uppercase hex (no colons)
-const CERT_SERIAL_HEX = '01';
-
-const VALID_SCOPE = { resources: ['tasks'], max_rows_per_query: 100 };
-
-// ---------------------------------------------------------------------------
-// Mock builders
-// ---------------------------------------------------------------------------
-
-/**
- * Build a minimal GrantWithPeer-shaped mock.
- */
-function makeGrantWithPeer(overrides: Partial<GrantWithPeer> = {}): GrantWithPeer {
-  return {
-    id: GRANT_ID,
-    peerId: PEER_ID,
-    subjectUserId: USER_ID,
-    scope: VALID_SCOPE,
-    status: 'active',
-    expiresAt: null,
-    createdAt: new Date('2026-01-01T00:00:00Z'),
-    revokedAt: null,
-    revokedReason: null,
-    peer: {
-      id: PEER_ID,
-      commonName: 'test-peer',
-      displayName: 'Test Peer',
-      certPem: '',
-      certSerial: CERT_SERIAL_HEX,
-      certNotAfter: new Date(Date.now() + 86_400_000),
-      clientKeyPem: null,
-      state: 'active',
-      endpointUrl: null,
-      lastSeenAt: null,
-      createdAt: new Date('2026-01-01T00:00:00Z'),
-      revokedAt: null,
-    },
-    ...overrides,
-  };
-}
-
-/**
- * Build a mock ExecutionContext with a pre-built TLS peer certificate.
- *
- * `certPem` — PEM string to present as the raw DER cert (converted to Buffer).
- *             Pass null to simulate "no cert presented".
- * `certSerialHex` — serialNumber string returned by the TLS socket.
- *                   Node.js returns uppercase hex.
- * `hasTlsSocket` — if false, raw.socket has no getPeerCertificate (plain HTTP).
- */
-function makeContext(opts: {
-  certPem: string | null;
-  certSerialHex?: string;
-  hasTlsSocket?: boolean;
-}): {
-  ctx: ExecutionContext;
-  statusMock: ReturnType<typeof vi.fn>;
-  sendMock: ReturnType<typeof vi.fn>;
-} {
-  const { certPem, certSerialHex = CERT_SERIAL_HEX, hasTlsSocket = true } = opts;
-
-  // Build peerCert object that Node.js TLS socket.getPeerCertificate() returns
-  let peerCert: Record<string, unknown>;
-  if (certPem === null) {
-    // Simulate no cert: Node.js returns object with empty string fields
-    peerCert = { raw: null, serialNumber: '' };
-  } else {
-    // Convert PEM to DER Buffer (strip headers + base64 decode)
-    const b64 = certPem
-      .replace(/-----BEGIN CERTIFICATE-----/, '')
-      .replace(/-----END CERTIFICATE-----/, '')
-      .replace(/\s+/g, '');
-    const raw = Buffer.from(b64, 'base64');
-    peerCert = { raw, serialNumber: certSerialHex };
-  }
-
-  const getPeerCertificate = vi.fn().mockReturnValue(peerCert);
-
-  const socket = hasTlsSocket ? { getPeerCertificate } : {}; // No getPeerCertificate → non-TLS
-
-  // Fastify reply mocks
-  const sendMock = vi.fn().mockReturnValue(undefined);
-  const headerMock = vi.fn().mockReturnValue({ send: sendMock });
-  const statusMock = vi.fn().mockReturnValue({ header: headerMock });
-
-  const request = {
-    raw: {
-      socket,
-    },
-  };
-
-  const reply = {
-    status: statusMock,
-  };
-
-  const ctx = {
-    switchToHttp: () => ({
-      getRequest: () => request,
-      getResponse: () => reply,
-    }),
-  } as unknown as ExecutionContext;
-
-  return { ctx, statusMock, sendMock };
-}
-
-/**
- * Build a mock GrantsService.
- */
-function makeGrantsService(
-  overrides: Partial<Pick<GrantsService, 'getGrantWithPeer'>> = {},
-): GrantsService {
-  return {
-    getGrantWithPeer: vi.fn().mockResolvedValue(makeGrantWithPeer()),
-    ...overrides,
-  } as unknown as GrantsService;
-}
-
-// ---------------------------------------------------------------------------
-// Test suite
-// ---------------------------------------------------------------------------
-
-describe('FederationAuthGuard', () => {
-  let certPem: string;
-
-  beforeEach(async () => {
-    // Generate a real Mosaic-issued cert with the standard OIDs
-    certPem = await makeMosaicIssuedCert({ grantId: GRANT_ID, subjectUserId: USER_ID });
-  });
-
-  // ── 401: No TLS socket ────────────────────────────────────────────────────
-
-  it('returns 401 when there is no TLS socket (plain HTTP connection)', async () => {
-    const { ctx, statusMock, sendMock } = makeContext({
-      certPem: certPem,
-      hasTlsSocket: false,
-    });
-
-    const guard = new FederationAuthGuard(makeGrantsService());
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(401);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'unauthorized', message: expect.any(String) }),
-      }),
-    );
-  });
-
-  // ── 401: Cert not presented ───────────────────────────────────────────────
-
-  it('returns 401 when the peer did not present a certificate', async () => {
-    const { ctx, statusMock, sendMock } = makeContext({ certPem: null });
-
-    const guard = new FederationAuthGuard(makeGrantsService());
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(401);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'unauthorized', message: expect.any(String) }),
-      }),
-    );
-  });
-
-  // ── 401: Cert parse failure ───────────────────────────────────────────────
-
-  it('returns 401 when the certificate DER bytes are corrupt', async () => {
-    // Build context with a cert that has garbage DER bytes
-    const corruptPem = '-----BEGIN CERTIFICATE-----\naW52YWxpZA==\n-----END CERTIFICATE-----';
-    const { ctx, statusMock, sendMock } = makeContext({ certPem: corruptPem });
-
-    const guard = new FederationAuthGuard(makeGrantsService());
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(401);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'unauthorized', message: expect.any(String) }),
-      }),
-    );
-  });
-
-  // ── 401: Missing grantId OID ─────────────────────────────────────────────
-
-  it('returns 401 when the cert is missing the grantId OID', async () => {
-    // makeSelfSignedCert produces a cert without any Mosaic OIDs
-    const { makeSelfSignedCert } = await import('../../__tests__/helpers/test-cert.js');
-    const plainCert = await makeSelfSignedCert();
-    const { ctx, statusMock, sendMock } = makeContext({ certPem: plainCert });
-
-    const guard = new FederationAuthGuard(makeGrantsService());
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(401);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'unauthorized', message: expect.any(String) }),
-      }),
-    );
-  });
-
-  // ── 401: Missing subjectUserId OID ───────────────────────────────────────
-
-  it('returns 401 when the cert has grantId OID but is missing subjectUserId OID', async () => {
-    // Build a cert with only the grantId OID by importing cert generator internals
-    const { webcrypto } = await import('node:crypto');
-    const {
-      X509CertificateGenerator,
-      Extension,
-      KeyUsagesExtension,
-      KeyUsageFlags,
-      BasicConstraintsExtension,
-      cryptoProvider,
-    } = await import('@peculiar/x509');
-
-    cryptoProvider.set(webcrypto as unknown as Parameters<typeof cryptoProvider.set>[0]);
-
-    const alg = { name: 'ECDSA', namedCurve: 'P-256', hash: 'SHA-256' } as const;
-    const keys = await webcrypto.subtle.generateKey(alg, false, ['sign', 'verify']);
-    const now = new Date();
-    const tomorrow = new Date(now.getTime() + 86_400_000);
-
-    // Encode grantId only — missing subjectUserId extension
-    const utf8 = new TextEncoder().encode(GRANT_ID);
-    const encoded = new Uint8Array(2 + utf8.length);
-    encoded[0] = 0x0c;
-    encoded[1] = utf8.length;
-    encoded.set(utf8, 2);
-
-    const cert = await X509CertificateGenerator.createSelfSigned({
-      serialNumber: '01',
-      name: 'CN=partial-oid-test',
-      notBefore: now,
-      notAfter: tomorrow,
-      signingAlgorithm: alg,
-      keys,
-      extensions: [
-        new BasicConstraintsExtension(false),
-        new KeyUsagesExtension(KeyUsageFlags.digitalSignature),
-        new Extension('1.3.6.1.4.1.99999.1', false, encoded), // grantId only
-      ],
-    });
-
-    const { ctx, statusMock, sendMock } = makeContext({ certPem: cert.toString('pem') });
-
-    const guard = new FederationAuthGuard(makeGrantsService());
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(401);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'unauthorized', message: expect.any(String) }),
-      }),
-    );
-  });
-
-  // ── 403: Grant not found ─────────────────────────────────────────────────
-
-  it('returns 403 when the grantId from the cert does not exist in DB', async () => {
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi
-        .fn()
-        .mockRejectedValue(new NotFoundException(`Grant ${GRANT_ID} not found`)),
-    });
-
-    const { ctx, statusMock, sendMock } = makeContext({ certPem });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── 403: Grant in `pending` status ───────────────────────────────────────
-
-  it('returns 403 when the grant is in pending status', async () => {
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi.fn().mockResolvedValue(makeGrantWithPeer({ status: 'pending' })),
-    });
-
-    const { ctx, statusMock, sendMock } = makeContext({ certPem });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── 403: Grant in `revoked` status ───────────────────────────────────────
-
-  it('returns 403 when the grant is in revoked status', async () => {
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi
-        .fn()
-        .mockResolvedValue(makeGrantWithPeer({ status: 'revoked', revokedAt: new Date() })),
-    });
-
-    const { ctx, statusMock, sendMock } = makeContext({ certPem });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── 403: Grant in `expired` status ───────────────────────────────────────
-
-  it('returns 403 when the grant is in expired status', async () => {
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi.fn().mockResolvedValue(makeGrantWithPeer({ status: 'expired' })),
-    });
-
-    const { ctx, statusMock, sendMock } = makeContext({ certPem });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── 403: Cert serial mismatch ─────────────────────────────────────────────
-
-  it('returns 403 when the cert serial does not match the registered peer cert serial', async () => {
-    // Return a grant whose peer has a different stored serial
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi.fn().mockResolvedValue(
-        makeGrantWithPeer({
-          peer: {
-            id: PEER_ID,
-            commonName: 'test-peer',
-            displayName: 'Test Peer',
-            certPem: '',
-            certSerial: 'DEADBEEF', // different from CERT_SERIAL_HEX='01'
-            certNotAfter: new Date(Date.now() + 86_400_000),
-            clientKeyPem: null,
-            state: 'active',
-            endpointUrl: null,
-            lastSeenAt: null,
-            createdAt: new Date('2026-01-01T00:00:00Z'),
-            revokedAt: null,
-          },
-        }),
-      ),
-    });
-
-    // Context presents cert with serial '01' but DB has 'DEADBEEF'
-    const { ctx, statusMock, sendMock } = makeContext({ certPem, certSerialHex: '01' });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── 403: subjectUserId cert/DB mismatch (CRIT-1 regression test) ─────────
-
-  it('returns 403 when the cert subjectUserId does not match the DB grant subjectUserId', async () => {
-    // Build a cert that claims an attacker's subjectUserId
-    const attackerSubjectUserId = 'attacker-user-id';
-    const attackerCertPem = await makeMosaicIssuedCert({
-      grantId: GRANT_ID,
-      subjectUserId: attackerSubjectUserId,
-    });
-
-    // DB returns a grant with the legitimate USER_ID
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi.fn().mockResolvedValue(makeGrantWithPeer({ subjectUserId: USER_ID })),
-    });
-
-    // Cert presents attacker-user-id but DB has USER_ID — should be rejected
-    const { ctx, statusMock, sendMock } = makeContext({
-      certPem: attackerCertPem,
-      certSerialHex: CERT_SERIAL_HEX,
-    });
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(false);
-    expect(statusMock).toHaveBeenCalledWith(403);
-    expect(sendMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        error: expect.objectContaining({ code: 'forbidden', message: 'Federation access denied' }),
-      }),
-    );
-  });
-
-  // ── Happy path ────────────────────────────────────────────────────────────
-
-  it('returns true and attaches federationContext on happy path', async () => {
-    const grant = makeGrantWithPeer({
-      status: 'active',
-      peer: {
-        id: PEER_ID,
-        commonName: 'test-peer',
-        displayName: 'Test Peer',
-        certPem: '',
-        certSerial: CERT_SERIAL_HEX,
-        certNotAfter: new Date(Date.now() + 86_400_000),
-        clientKeyPem: null,
-        state: 'active',
-        endpointUrl: null,
-        lastSeenAt: null,
-        createdAt: new Date('2026-01-01T00:00:00Z'),
-        revokedAt: null,
-      },
-    });
-
-    const grantsService = makeGrantsService({
-      getGrantWithPeer: vi.fn().mockResolvedValue(grant),
-    });
-
-    // Build context manually to capture what gets set on request.federationContext
-    const b64 = certPem
-      .replace(/-----BEGIN CERTIFICATE-----/, '')
-      .replace(/-----END CERTIFICATE-----/, '')
-      .replace(/\s+/g, '');
-    const raw = Buffer.from(b64, 'base64');
-    const peerCert = { raw, serialNumber: CERT_SERIAL_HEX };
-
-    const sendMock = vi.fn().mockReturnValue(undefined);
-    const headerMock = vi.fn().mockReturnValue({ send: sendMock });
-    const statusMock = vi.fn().mockReturnValue({ header: headerMock });
-
-    const request: Record<string, unknown> = {
-      raw: {
-        socket: { getPeerCertificate: vi.fn().mockReturnValue(peerCert) },
-      },
-    };
-
-    const reply = { status: statusMock };
-
-    const ctx = {
-      switchToHttp: () => ({
-        getRequest: () => request,
-        getResponse: () => reply,
-      }),
-    } as unknown as ExecutionContext;
-
-    const guard = new FederationAuthGuard(grantsService);
-    const result = await guard.canActivate(ctx);
-
-    expect(result).toBe(true);
-    expect(statusMock).not.toHaveBeenCalled();
-
-    // Verify the context was attached correctly
-    expect(request['federationContext']).toEqual({
-      grantId: GRANT_ID,
-      subjectUserId: USER_ID,
-      peerId: PEER_ID,
-      scope: VALID_SCOPE,
-    });
-  });
-});

apps/gateway/src/federation/server/federation-auth.guard.ts

@@ -1,212 +0,0 @@
-/**
- * FederationAuthGuard — NestJS CanActivate guard for inbound federation requests.
- *
- * Validates the mTLS client certificate presented by a peer gateway, extracts
- * custom OIDs to identify the grant + subject user, loads the grant from DB,
- * asserts it is active, and verifies the cert serial against the registered peer
- * cert serial as a defense-in-depth measure.
- *
- * On success, attaches `request.federationContext` for downstream verb controllers.
- * On failure, responds with the federation wire-format error envelope (not raw
- * NestJS exception JSON) to match the federation protocol contract.
- *
- * ## Cert-serial check decision
- * The guard validates that the inbound client cert's serial number matches the
- * `certSerial` stored on the associated `federation_peers` row. This is a
- * defense-in-depth measure: even if the mTLS handshake is compromised at the
- * transport layer (e.g. misconfigured TLS terminator that forwards arbitrary
- * client certs), an attacker cannot replay a cert with a different serial than
- * what was registered during enrollment. This check is NOT loosened because:
- *  1. It is O(1) — no additional DB round-trip (peerId is on the grant row,
- *     so we join to federationPeers in the same query).
- *  2. Cert renewal MUST update the stored serial — enforced by M6 scheduler.
- *  3. The OID-only path (without serial check) would allow any cert from the
- *     same CA bearing the same grantId OID to succeed after cert compromise.
- *
- * ## FastifyRequest typing path
- * NestJS + Fastify wraps the raw Node.js IncomingMessage in a FastifyRequest.
- * The underlying TLS socket is accessed via `request.raw.socket`, which is a
- * `tls.TLSSocket` when the server is listening on HTTPS. In development/test
- * the gateway may run over plain HTTP, in which case `getPeerCertificate` is
- * not available. The guard safely handles both cases by checking for the
- * method's existence before calling it.
- *
- * Note: The guard reads the peer certificate from the *already-completed*
- * TLS handshake via `socket.getPeerCertificate(detailed=true)`. This relies
- * on the server being configured with `requestCert: true` at the TLS level
- * so Fastify/Node.js requests the client cert during the handshake.
- * The guard does NOT verify the cert chain itself — that is handled by the
- * TLS layer (Node.js `rejectUnauthorized: true` with the CA cert pinned).
- */
-
-import {
-  type CanActivate,
-  type ExecutionContext,
-  Inject,
-  Injectable,
-  Logger,
-} from '@nestjs/common';
-import type { FastifyReply, FastifyRequest } from 'fastify';
-import * as tls from 'node:tls';
-import { X509Certificate } from '@peculiar/x509';
-import { FederationForbiddenError, FederationUnauthorizedError } from '@mosaicstack/types';
-import { extractMosaicOids } from '../oid.util.js';
-import { GrantsService } from '../grants.service.js';
-import type { FederationContext } from './federation-context.js';
-import './federation-context.js'; // side-effect import: applies FastifyRequest module augmentation
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Send a federation wire-format error response directly on the Fastify reply.
- * Returns false — callers return this value from canActivate.
- */
-function sendFederationError(
-  reply: FastifyReply,
-  error: FederationUnauthorizedError | FederationForbiddenError,
-): boolean {
-  const statusCode = error.code === 'unauthorized' ? 401 : 403;
-  void reply.status(statusCode).header('content-type', 'application/json').send(error.toEnvelope());
-  return false;
-}
-
-// ---------------------------------------------------------------------------
-// Guard
-// ---------------------------------------------------------------------------
-
-@Injectable()
-export class FederationAuthGuard implements CanActivate {
-  private readonly logger = new Logger(FederationAuthGuard.name);
-
-  constructor(@Inject(GrantsService) private readonly grantsService: GrantsService) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const http = context.switchToHttp();
-    const request = http.getRequest<FastifyRequest>();
-    const reply = http.getResponse<FastifyReply>();
-
-    // ── Step 1: Extract peer certificate from TLS socket ────────────────────
-    const rawSocket = request.raw.socket;
-
-    // Check TLS socket: getPeerCertificate is only available on TLS connections.
-    if (
-      !rawSocket ||
-      typeof (rawSocket as Partial<tls.TLSSocket>).getPeerCertificate !== 'function'
-    ) {
-      this.logger.warn('No TLS socket — client cert unavailable (non-mTLS connection)');
-      return sendFederationError(
-        reply,
-        new FederationUnauthorizedError('Client certificate required'),
-      );
-    }
-
-    const tlsSocket = rawSocket as tls.TLSSocket;
-    const peerCert = tlsSocket.getPeerCertificate(true);
-
-    // Node.js returns an object with empty string fields when no cert was presented.
-    if (!peerCert || !peerCert.raw) {
-      this.logger.warn('Peer certificate not presented (mTLS handshake did not supply cert)');
-      return sendFederationError(
-        reply,
-        new FederationUnauthorizedError('Client certificate required'),
-      );
-    }
-
-    // ── Step 2: Parse the DER-encoded certificate via @peculiar/x509 ────────
-    let cert: X509Certificate;
-    try {
-      // peerCert.raw is a Buffer containing the DER-encoded cert
-      cert = new X509Certificate(peerCert.raw);
-    } catch (err) {
-      this.logger.warn(
-        `Failed to parse peer certificate: ${err instanceof Error ? err.message : String(err)}`,
-      );
-      return sendFederationError(
-        reply,
-        new FederationUnauthorizedError('Client certificate could not be parsed'),
-      );
-    }
-
-    // ── Step 3: Extract Mosaic custom OIDs ──────────────────────────────────
-    const oidResult = extractMosaicOids(cert);
-
-    if (!oidResult.ok) {
-      const message =
-        oidResult.error === 'MISSING_GRANT_ID'
-          ? 'Client certificate is missing required OID: mosaic_grant_id (1.3.6.1.4.1.99999.1)'
-          : oidResult.error === 'MISSING_SUBJECT_USER_ID'
-            ? 'Client certificate is missing required OID: mosaic_subject_user_id (1.3.6.1.4.1.99999.2)'
-            : `Client certificate OID extraction failed: ${oidResult.detail ?? 'unknown error'}`;
-      this.logger.warn(`OID extraction failure [${oidResult.error}]: ${message}`);
-      return sendFederationError(reply, new FederationUnauthorizedError(message));
-    }
-
-    const { grantId, subjectUserId } = oidResult.value;
-
-    // ── Step 4: Load grant from DB ───────────────────────────────────────────
-    let grant: Awaited<ReturnType<GrantsService['getGrantWithPeer']>>;
-    try {
-      grant = await this.grantsService.getGrantWithPeer(grantId);
-    } catch {
-      // getGrantWithPeer throws NotFoundException when not found
-      this.logger.warn(`Grant not found: ${grantId}`);
-      return sendFederationError(reply, new FederationForbiddenError('Federation access denied'));
-    }
-
-    // ── Step 5: Assert grant is active ──────────────────────────────────────
-    if (grant.status !== 'active') {
-      this.logger.warn(`Grant ${grantId} is not active — status=${grant.status}`);
-      return sendFederationError(reply, new FederationForbiddenError('Federation access denied'));
-    }
-
-    // ── Step 5b: Validate cert-extracted subjectUserId against DB (CRIT-1) ──
-    // The cert claim is untrusted input; the DB row is authoritative.
-    if (subjectUserId !== grant.subjectUserId) {
-      this.logger.warn(`subjectUserId mismatch for grant ${grantId}`);
-      return sendFederationError(reply, new FederationForbiddenError('Federation access denied'));
-    }
-
-    // ── Step 6: Defense-in-depth — cert serial must match registered peer ───
-    // The serial number from Node.js TLS is upper-case hex without colons.
-    // The @peculiar/x509 serialNumber is decimal. We compare using the native
-    // Node.js crypto cert serial which is uppercase hex, matching DB storage.
-    // Both are derived from the peerCert.serialNumber Node.js provides.
-    const inboundSerial: string = peerCert.serialNumber ?? '';
-
-    if (!grant.peer.certSerial) {
-      // Peer row exists but has no stored serial — something is wrong with enrollment
-      this.logger.error(`Peer ${grant.peerId} has no stored certSerial — enrollment incomplete`);
-      return sendFederationError(reply, new FederationForbiddenError('Federation access denied'));
-    }
-
-    // Normalize both to uppercase for comparison (Node.js serialNumber is
-    // already uppercase hex; DB value was stored from extractSerial() which
-    // returns crypto.X509Certificate.serialNumber — also uppercase hex).
-    if (inboundSerial.toUpperCase() !== grant.peer.certSerial.toUpperCase()) {
-      this.logger.warn(
-        `Cert serial mismatch for grant ${grantId}: ` +
-          `inbound=${inboundSerial} registered=${grant.peer.certSerial}`,
-      );
-      return sendFederationError(reply, new FederationForbiddenError('Federation access denied'));
-    }
-
-    // ── Step 7: Attach FederationContext to request ──────────────────────────
-    // Use grant.subjectUserId from DB (authoritative) — not the cert-extracted value.
-    const federationContext: FederationContext = {
-      grantId,
-      subjectUserId: grant.subjectUserId,
-      peerId: grant.peerId,
-      scope: grant.scope as Record<string, unknown>,
-    };
-
-    request.federationContext = federationContext;
-
-    this.logger.debug(
-      `Federation auth OK — grantId=${grantId} peerId=${grant.peerId} subjectUserId=${grant.subjectUserId}`,
-    );
-
-    return true;
-  }
-}

apps/gateway/src/federation/server/federation-context.ts

@@ -1,39 +0,0 @@
-/**
- * FederationContext — attached to inbound federation requests after successful
- * mTLS + grant validation by FederationAuthGuard.
- *
- * Downstream verb controllers access this via `request.federationContext`.
- */
-
-/**
- * Augment FastifyRequest so TypeScript knows about the federation context
- * property that FederationAuthGuard attaches on success.
- */
-declare module 'fastify' {
-  interface FastifyRequest {
-    federationContext?: FederationContext;
-  }
-}
-
-/**
- * Typed context object attached to the request by FederationAuthGuard.
- * Carries all data extracted from the mTLS cert + grant DB row needed
- * by downstream federation verb handlers.
- */
-export interface FederationContext {
-  /** The federation grant ID extracted from OID 1.3.6.1.4.1.99999.1 */
-  grantId: string;
-
-  /** The local subject user whose data is accessible under this grant */
-  subjectUserId: string;
-
-  /** The peer gateway ID (from the grant's peerId FK) */
-  peerId: string;
-
-  /**
-   * Grant scope — determines which resources the peer may query.
-   * Typed as Record<string, unknown> because the full scope schema lives in
-   * scope-schema.ts; downstream handlers should narrow via parseFederationScope.
-   */
-  scope: Record<string, unknown>;
-}

apps/gateway/src/federation/server/index.ts

@@ -1,13 +0,0 @@
-/**
- * Federation server-side barrel — inbound request handling.
- *
- * Exports the mTLS auth guard and the FederationContext interface
- * for use by verb controllers (M3-05/06/07).
- *
- * Usage:
- *   import { FederationAuthGuard } from './server/index.js';
- *   @UseGuards(FederationAuthGuard)
- */
-
-export { FederationAuthGuard } from './federation-auth.guard.js';
-export type { FederationContext } from './federation-context.js';

docker/appservice.Dockerfile

@@ -1,28 +0,0 @@
-FROM node:22-alpine AS base
-ENV PNPM_HOME="/pnpm"
-ENV PATH="$PNPM_HOME:$PATH"
-RUN corepack enable
-
-FROM base AS builder
-WORKDIR /app
-# Copy workspace manifests first for layer-cached install
-COPY pnpm-workspace.yaml pnpm-lock.yaml package.json ./
-COPY apps/appservice/package.json ./apps/appservice/
-COPY packages/ ./packages/
-COPY plugins/ ./plugins/
-RUN pnpm install --frozen-lockfile
-COPY . .
-RUN pnpm turbo run build --filter @mosaicstack/mosaic-as...
-RUN pnpm --filter @mosaicstack/mosaic-as --prod deploy --legacy /deploy
-
-FROM base AS runner
-WORKDIR /app
-ENV NODE_ENV=production
-COPY --from=builder /deploy/node_modules ./node_modules
-COPY --from=builder /deploy/package.json ./package.json
-COPY --from=builder /app/apps/appservice/dist ./dist
-USER node
-EXPOSE 8008
-HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=5 \
-  CMD ["node", "-e", "require('http').get('http://127.0.0.1:8008/health',r=>process.exit(r.statusCode===200?0:1)).on('error',()=>process.exit(1))"]
-CMD ["node", "dist/main.js"]

docs/TASKS.md

@@ -23,14 +23,13 @@
 These are MVP-level checks that don't belong to any single workstream. Updated by the orchestrator at each session.
 
 | id      | status      | description                                                                                              | notes                                                                                   |
-| ---------- | ----------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| ------- | ----------- | -------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
 | MVP-T01 | done        | Author MVP-level manifest at `docs/MISSION-MANIFEST.md`                                                  | This session (2026-04-19); PR pending                                                   |
 | MVP-T02 | done        | Archive install-ux-v2 mission state to `docs/archive/missions/install-ux-v2-20260405/`                   | IUV-M03 retroactively closed (shipped via PR #446 + releases 0.0.27→0.0.29)             |
 | MVP-T03 | done        | Land federation v1 planning artifacts on `main`                                                          | PR #468 merged 2026-04-19 (commit `66512550`)                                           |
 | MVP-T04 | not-started | Sync `.mosaic/orchestrator/mission.json` MVP slot with this manifest (milestone enumeration, etc.)       | Coord state file; consider whether to repopulate via `mosaic coord` or accept hand-edit |
 | MVP-T05 | in-progress | Kick off W1 / FED-M1 — federated tier infrastructure                                                     | Session 16 (2026-04-19): FED-M1-01 in-progress on `feat/federation-m1-tier-config`      |
 | MVP-T06 | not-started | Declare additional workstreams (web dashboard, TUI/CLI parity, remote control, etc.) as scope solidifies | Track each new workstream by adding a row to the Workstream Rollup                      |
-| T-A292E96F | in-progress | Fix Mosaic Gitea PR metadata/login wrapper regression for U-Connect merge preflight                      | Kanban `t_a292e96f`; branch `fix/t-a292e96f-gitea-pr-metadata`; scratchpad `docs/scratchpads/t-a292e96f-gitea-pr-metadata.md` |
 
 ## Pointer to Active Workstream
 
@@ -39,9 +38,3 @@ Active workstream is **W1 — Federation v1**. Workers should:
 1. Read [docs/federation/MISSION-MANIFEST.md](./federation/MISSION-MANIFEST.md) for workstream scope
 2. Read [docs/federation/TASKS.md](./federation/TASKS.md) for the next pending task
 3. Follow per-task agent + tier guidance from the workstream manifest
-
-## Thin-core prompt diet (#528) — feat/contract-thin-core
-
-- Status: PR open, awaiting maintainer merge ratification (fleet-governing change).
-- Cut always-injected contract AGENTS+TOOLS+RUNTIME 8,827→4,122 tok (−53%); all 12 hard gates intact.
-- Validation: deterministic gate-checklist PASS; headless A/B thin 7/9 vs monolith 5/9. Detail: scratchpads/contract-thin-core.md.

docs/mission-control/BOARD.md

@@ -1,101 +0,0 @@
-# Mission Control Plane — Feature Board
-
-> Discussion board for the combined PRD / mission / Kanban workflow.
-> Use this to decide scope before implementation.
-
-## Board Legend
-
-- **Must-have** — required for the first usable version
-- **Should-have** — strongly preferred, but can ship after the core path
-- **Could-have** — valuable later if time permits
-- **Won't-have** — explicitly deferred
-
----
-
-## Feature Board
-
-| Feature Card                   | Need                                                          | Priority    | Decision / Notes                                                            |
-| ------------------------------ | ------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------- |
-| Canonical mission manifest     | One durable root object for goal, PRD, board, session         | Must-have   | Mission manifest becomes the anchor for all downstream state                |
-| PRD generator integration      | PRD should be generated from a feature idea and saved in docs | Must-have   | Use Mosaic PRDy format and keep the file human-reviewable                   |
-| Board atomization              | Break PRD into assignable tasks with dependencies             | Must-have   | Each user story should map to one or more tasks                             |
-| Short-cycle detector           | Detect compaction churn and repeated tool loops               | Must-have   | Coordinator should track churn score per session                            |
-| Handoff packet                 | Preserve actionable context across rotations                  | Must-have   | Use a compact structured summary, not a raw transcript                      |
-| Auto-resume workers            | Let new sessions read mission + board on start                | Should-have | Makes overnight autonomy realistic                                          |
-| Mission status view            | Show current phase, blockers, and active session              | Should-have | Expose through CLI first, dashboard later                                   |
-| Worktree root convention       | Keep worktrees off `/tmp` and on the larger persistent drive  | Should-have | Prefer `/src/<repo>-worktrees` for repo worktrees and long-lived agent work |
-| Review gate                    | Prevent autonomous work from shipping unreviewed              | Should-have | Use reviewer tasks before mission close                                     |
-| Rotation policy config         | Configure thresholds per mission/profile                      | Could-have  | Keep v1 simple, add tuning later                                            |
-| Goal decomposition suggestions | Suggest sub-goals from the PRD                                | Could-have  | Good for planning, not necessary for core path                              |
-| Cross-channel continuity       | Continue a mission across CLI/gateway/remote channels         | Could-have  | Important later, not required for MVP                                       |
-| Automatic board sync           | Mirror git docs into DB and back                              | Could-have  | Nice-to-have after the file-first flow stabilizes                           |
-| Fully autonomous closeout      | Let mission finish without human intervention                 | Won't-have  | Keep an operator-visible review step                                        |
-
----
-
-## Needs Discussion
-
-### 1) Canonical source of truth
-
-**Question:** Should the PRD, mission manifest, and board all live in git, or should one be the database source of truth?
-
-**Proposed answer:** Keep the human-readable artifacts in git and sync the mission runtime state to the database.
-
-### 2) Scope of automation
-
-**Question:** Should the first version auto-create the board from the PRD, or require a human/orchestrator to approve the split?
-
-**Proposed answer:** Auto-create a draft board, then let the orchestrator approve or adjust it.
-
-### 3) Rotation triggers
-
-**Question:** What should trigger a forced session rotation?
-
-**Candidate signals:**
-
-- repeated compaction
-- repeated prompts for permission
-- identical tool loops
-- no new file/task state after several turns
-- task blocked on a missing prerequisite
-
-**Proposed answer:** Use a weighted churn score with a small hard cap on repeated compactions.
-
-### 4) Handoff format
-
-**Question:** What should the next session receive?
-
-**Proposed answer:**
-
-- Mission ID
-- PRD path
-- Active board task
-- Completed work
-- Blockers
-- Next 3 actions
-- Non-negotiable constraints
-
-### 5) Operator control
-
-**Question:** Should the operator be able to force a rotation or pause the mission?
-
-**Proposed answer:** Yes. Human override should win.
-
----
-
-## Draft Decisions
-
-1. File-first artifacts, DB-backed runtime state.
-2. PRD-first planning, board-second execution.
-3. Auto-rotation on churn, but human override remains available.
-4. Structured handoff packets required on every rotation.
-5. Mission close requires a reviewer task.
-
----
-
-## Open Questions
-
-- What exact data fields belong in the mission manifest?
-- Should rotation thresholds vary by agent profile?
-- What is the minimum viable status surface for v1?
-- Should the board support milestones in addition to tasks?

docs/mission-control/MISSION-MANIFEST.md

@@ -1,95 +0,0 @@
-# Mission Manifest — Mosaic Mission Control Plane
-
-> Persistent document tracking scope, status, and handoff history for the combined PRD / mission / Kanban workflow.
-
-## Mission
-
-**ID:** mission-control-plane-20260506
-
-**Statement:** Combine Mosaic PRDy, coord, and Kanban into one durable workflow so an agent can move from feature idea to PRD to mission to task board and keep working across session rotation, compaction, and restarts with minimal context loss.
-
-**Phase:** planning — MC-01 complete, MC-02 next
-
-**Current Milestone:** MC-02
-
-**Progress:** 1 / 6 milestones
-
-**Status:** active
-
-**Last Updated:** 2026-05-06
-
-**Parent Mission:** None — new mission
-
----
-
-## Context
-
-This mission exists because overnight autonomy breaks when the working session short-cycles. The system needs durable artifacts and a mechanical coordinator that can:
-
-1. keep a canonical PRD,
-2. atomize the PRD into board tasks,
-3. track mission state separately from the chat session,
-4. detect churn or compaction pressure,
-5. rotate to a fresh session, and
-6. re-enter from a structured handoff.
-
-Operational convention: repo worktrees and long-lived working directories should use `/src/<repo>-worktrees` instead of `/tmp`.
-
-Design references:
-
-- `docs/mission-control/PRD.md` — product requirements
-- `docs/mission-control/BOARD.md` — feature discussion board
-- `docs/mission-control/TASKS.md` — atomized execution plan
-
----
-
-## Success Criteria
-
-- [ ] AC-1: A feature idea can be converted into a PRD, mission, and task board.
-- [ ] AC-2: The coordinator can load a mission and its board from durable storage.
-- [ ] AC-3: The coordinator can detect short-cycling and rotate sessions automatically.
-- [ ] AC-4: A rotated session can resume from a handoff packet without manual re-prompting.
-- [ ] AC-5: The board remains traceable back to the PRD user stories.
-- [ ] AC-6: Operators can inspect mission state, task state, and latest handoff from one place.
-- [ ] AC-7: The system can run overnight without losing the mission goal.
-
----
-
-## Milestones
-
-| #   | ID    | Name                                     | Status      | Branch                  | Started    | Completed |
-| --- | ----- | ---------------------------------------- | ----------- | ----------------------- | ---------- | --------- |
-| 1   | MC-01 | PRD + mission schema foundation          | in-progress | docs/mission-control-\* | 2026-05-06 | —         |
-| 2   | MC-02 | Mission runtime model                    | not-started | —                       | —          | —         |
-| 3   | MC-03 | Board atomization and task linkage       | not-started | —                       | —          | —         |
-| 4   | MC-04 | Short-cycle detector and rotation engine | not-started | —                       | —          | —         |
-| 5   | MC-05 | Handoff generation and re-entry          | not-started | —                       | —          | —         |
-| 6   | MC-06 | Operator surface and E2E validation      | not-started | —                       | —          | —         |
-
----
-
-## Budget
-
-| Milestone | Est. tokens | Parallelizable?    |
-| --------- | ----------- | ------------------ |
-| MC-01     | 16K         | No                 |
-| MC-02     | 20K         | No                 |
-| MC-03     | 24K         | Mostly after MC-01 |
-| MC-04     | 20K         | After MC-02        |
-| MC-05     | 18K         | After MC-04        |
-| MC-06     | 26K         | After MC-04/05     |
-| **Total** | **~124K**   |                    |
-
----
-
-## Session History
-
-| Session | Date       | Runtime | Outcome                                                                  |
-| ------- | ---------- | ------- | ------------------------------------------------------------------------ |
-| S1      | 2026-05-06 | hermes  | PRD, board, task plan, mission manifest, and worktree convention drafted |
-
----
-
-## Next Step
-
-Kick off MC-02: implement the durable mission runtime model and wire the mission state into the coordinator.

docs/mission-control/PRD.md

@@ -1,205 +0,0 @@
-# PRD: Mosaic Mission Control Plane
-
-## Metadata
-
-- **Owner:** Jason Woltje
-- **Date:** 2026-05-06
-- **Status:** draft
-- **Framework:** Mosaic PRDy + coord + Kanban
-- **Target Repo:** `git.mosaicstack.dev/mosaic/mosaic-stack`
-- **Primary Modules:** `packages/prdy`, `packages/coord`, `packages/queue`, `apps/gateway`, `packages/brain`, `packages/cli`
-
----
-
-## Problem Statement
-
-Mosaic already has the ingredients for durable agent work: PRD generation (`prdy`), mission coordination (`coord`), and task execution boards (`Kanban` / `TASKS.md`). Today those systems can still drift apart:
-
-- A PRD can exist without a mission record.
-- A mission can exist without a machine-readable execution board.
-- Agents can short-cycle or compact repeatedly without a durable handoff.
-- The next session may know the goal, but not the exact next step.
-
-The result is brittle overnight autonomy: work continues only as long as a single session remains healthy.
-
-This feature unifies those layers into one durable workflow so a mission can survive session rotation, compaction, and restarts with minimal state loss.
-
----
-
-## Goals
-
-1. Create one canonical pipeline from idea → PRD → mission → board → execution.
-2. Let `prdy` generate a PRD that is immediately usable as a mission input.
-3. Let `coord` own mission state, handoffs, and session rotation.
-4. Let the board hold atomized tasks with dependencies and assignees.
-5. Let agents read the mission and board to learn the next action without extra prompting.
-6. Detect short-cycling and rotate sessions before quality degrades.
-7. Preserve useful context across handoffs with a structured summary packet.
-8. Give operators a single place to see mission status, task state, and the current session.
-
----
-
-## Non-Goals
-
-1. Replacing the Mosaic agent runtime or gateway architecture.
-2. Rewriting `prdy` or `coord` from scratch.
-3. Turning the board into a general project-management system.
-4. Building a full Gantt/charting product.
-5. Removing human review or approval gates.
-6. Allowing agents to create arbitrary mission state without schema.
-
----
-
-## User Stories
-
-### US-001: Create a mission from a feature idea
-
-**Description:** As an orchestrator, I want to turn a feature idea into a PRD and mission so that agents can work from a durable spec instead of a chat transcript.
-
-**Acceptance Criteria:**
-
-- [ ] `prdy` can emit a PRD with goals, non-goals, and requirements.
-- [ ] The PRD is linked to a mission ID.
-- [ ] The mission manifest references the PRD path.
-- [ ] The mission is readable by downstream agent sessions.
-
-### US-002: Atomize work into a board
-
-**Description:** As an orchestrator, I want to split a PRD into board tasks so that work can be assigned to specialists.
-
-**Acceptance Criteria:**
-
-- [ ] Each user story can become one or more tasks.
-- [ ] Tasks have assignees, dependencies, and estimates.
-- [ ] Tasks are machine-readable and durable.
-- [ ] The board can be regenerated from the PRD without ambiguity.
-
-### US-003: Rotate sessions without losing the mission
-
-**Description:** As a coordinator, I want to restart or rotate a session when it short-cycles so that the mission continues with minimal loss.
-
-**Acceptance Criteria:**
-
-- [ ] The coordinator detects compaction pressure or repeated loops.
-- [ ] The coordinator writes a handoff summary before rotation.
-- [ ] A new session can resume from the handoff packet.
-- [ ] The mission state remains intact across the rotation.
-
-### US-004: Let workers read the next step automatically
-
-**Description:** As a worker agent, I want to read the mission and board at startup so I can do the next useful thing without waiting for a human prompt.
-
-**Acceptance Criteria:**
-
-- [ ] Startup loads the active mission manifest.
-- [ ] Startup loads the current board/task row.
-- [ ] Startup exposes the next action clearly in the prompt.
-- [ ] The agent can continue after compaction using the same mission context.
-
-### US-005: Observe mission health from one place
-
-**Description:** As an operator, I want a single view of mission health so that I can see progress, blocked tasks, and session churn.
-
-**Acceptance Criteria:**
-
-- [ ] Mission state shows current phase and progress.
-- [ ] Board state shows task status by assignee.
-- [ ] Short-cycle/rotation events are visible.
-- [ ] Handoffs are inspectable.
-
----
-
-## Functional Requirements
-
-FR-1. The system must represent a mission as a durable object with an ID, goal, current phase, PRD path, board path, and active session ID.
-
-FR-2. The system must represent a PRD as a markdown document with goals, user stories, functional requirements, non-goals, technical considerations, and success metrics.
-
-FR-3. The system must represent execution work as a board of atomized tasks with status, assignee, dependency, and estimate fields.
-
-FR-4. The coordinator must be able to derive a task board from a PRD.
-
-FR-5. The coordinator must be able to write a handoff packet that includes goal, current state, completed work, blocked work, next steps, and constraints.
-
-FR-6. The coordinator must detect short-cycling signals such as repeated compactions, repeated tool loops, repeated approval prompts, or no progress across several turns.
-
-FR-7. The coordinator must rotate the session when the short-cycle threshold is exceeded.
-
-FR-8. The coordinator must preserve mission continuity across session rotation.
-
-FR-9. The worker session must read the mission state and board state at startup.
-
-FR-10. The worker session must be able to resume from the last handoff summary without the operator rewriting the goal manually.
-
-FR-11. The operator must be able to inspect the mission state, PRD, board, and latest handoff from one place.
-
-FR-12. The mission system must keep a traceable link between PRD requirements and board tasks.
-
-FR-13. The system must not allow a task to become active without a valid mission context.
-
-FR-14. The system must keep durable history for rotation and handoff events.
-
----
-
-## Board Discussion: Features and Needs
-
-This is the feature discussion board that should drive the mission design.
-
-| Card                     | Need                                         | Why it matters                               | Proposed decision                                            |
-| ------------------------ | -------------------------------------------- | -------------------------------------------- | ------------------------------------------------------------ |
-| Canonical mission record | One source of truth for goal/state           | Prevents drift between chat, docs, and queue | Make mission manifest the durable root object                |
-| PRD → board derivation   | Break feature ideas into executable work     | Lets the plan be assigned and tracked        | Keep PRD as the spec, generate board tasks from user stories |
-| Session watchdog         | Detect churn/short-cycling                   | Keeps overnight runs productive              | Add short-cycle scoring and forced rotation                  |
-| Structured handoff       | Preserve context across session changes      | Minimizes restart loss                       | Use a compact JSON/MD handoff packet                         |
-| Worker auto-read         | Let agents resume without human re-prompting | Reduces operator overhead                    | Load mission + board on session start                        |
-| Status surface           | Show progress and blockers clearly           | Operators need confidence                    | Expose mission state via CLI and dashboard                   |
-| Review gate              | Keep quality high on autonomous work         | Prevents silent regressions                  | Require review tasks before close                            |
-| Recoverability           | Resume after failure or restart              | Mission should outlive a process             | Persist session and handoff history                          |
-
----
-
-## Design Considerations
-
-1. The PRD should stay human-readable markdown, because the board and mission references need to be reviewable in git.
-2. The board should be machine-readable enough for automation but still readable by humans.
-3. The mission manifest should point to the PRD and board, not duplicate them.
-4. Handoff packets should be compact and structured so they can be injected into a new session with minimal token cost.
-5. The coordinator should prefer rotation over forced context growth once the session is near the compaction threshold.
-6. Existing Mosaic commands should be extended, not replaced, wherever possible.
-7. The same mission should be resumable across CLI, gateway, and remote channels.
-
----
-
-## Technical Considerations
-
-- Likely storage split:
-  - PRD/board/manifest in git-backed docs
-  - mission/session state in the Mosaic data layer
-  - runtime health in queue/session state
-- Worktrees and long-lived agent working directories should live under `/src/<repo>-worktrees` rather than `/tmp` so they sit on the larger persistent drive and survive longer-running missions.
-- The coordinator needs a stable session identity, even if the active session changes.
-- Task dependencies must be enforced so workers do not start early.
-- The handoff packet should include the top 3 immediate actions and the strongest constraints.
-- Rotation triggers should be configurable per profile or per mission.
-- The initial version can be file-first, with dashboard sync added later.
-
----
-
-## Success Metrics
-
-- A mission can rotate sessions without losing the active goal.
-- A new session can resume from the latest handoff in under one turn.
-- Board tasks remain aligned to PRD user stories.
-- Short-cycling sessions are replaced before repeated compaction harms quality.
-- Operators can find mission state without spelunking across multiple chat logs.
-
----
-
-## Open Questions
-
-1. What should the canonical mission ID format be?
-2. Should the board live only in git, or also in the database?
-3. Should rotation be automatic by default, or opt-in per mission?
-4. What should the short-cycle threshold be initially?
-5. Should handoffs be pure text, structured JSON, or both?
-6. Which CLI command should be the primary mission entrypoint: `mosaic mission`, `mosaic coord`, or `mosaic prdy`?

docs/mission-control/TASKS.md

@@ -1,113 +0,0 @@
-# Tasks — Mosaic Mission Control Plane
-
-> Single-writer: orchestrator only. Workers read but never modify.
->
-> **Mission:** mission-control-plane-20260506
-> **Schema:** `| id | status | description | issue | agent | branch | depends_on | estimate | notes |`
-> **Status values:** `not-started` | `in-progress` | `done` | `blocked` | `failed` | `needs-qa`
-> **Agent values:** `codex` | `glm-5.1` | `haiku` | `sonnet` | `opus` | `—` (auto)
->
-> Scope: this file decomposes the combined PRD / mission / board workflow into atomized tasks.
-
----
-
-## Milestone 1 — PRD + mission schema foundation
-
-Goal: create the durable doc structure and the minimal mission metadata needed to keep PRD, board, and mission aligned.
-
-| id       | status      | description                                                                                              | issue | agent  | branch                        | depends_on         | estimate | notes                                       |
-| -------- | ----------- | -------------------------------------------------------------------------------------------------------- | ----- | ------ | ----------------------------- | ------------------ | -------- | ------------------------------------------- |
-| MC-01-01 | not-started | Write `docs/mission-control/PRD.md` with goals, non-goals, functional requirements, and success metrics. | —     | sonnet | docs/mission-control-prd      | —                  | 5K       | Human-readable PRD becomes the spec anchor. |
-| MC-01-02 | not-started | Write `docs/mission-control/BOARD.md` as a decision board for scope, priority, and open questions.       | —     | haiku  | docs/mission-control-board    | MC-01-01           | 3K       | Keeps discussion separate from the spec.    |
-| MC-01-03 | not-started | Write `docs/mission-control/MISSION-MANIFEST.md` linking PRD, board, tasks, and mission identity.        | —     | sonnet | docs/mission-control-manifest | MC-01-01, MC-01-02 | 4K       | Durable mission root object.                |
-| MC-01-04 | not-started | Write `docs/mission-control/TASKS.md` with the atomized execution plan and dependency graph.             | —     | sonnet | docs/mission-control-tasks    | MC-01-03           | 4K       | Board-backed execution plan.                |
-
-**Milestone 1 estimate:** ~16K tokens
-
----
-
-## Milestone 2 — Mission runtime model
-
-Goal: make missions first-class runtime objects that can survive session restarts and compaction.
-
-| id       | status      | description                                                                                                                               | issue                                                                                                                                  | agent | branch                                 | depends_on                         | estimate | notes                                      |
-| -------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----- | -------------------------------------- | ---------------------------------- | -------- | ------------------------------------------ | ---------------------------------------------------- |
-| MC-02-01 | not-started | Define mission schema in the data layer: mission ID, goal, phase, PRD path, board path, active session ID, last handoff, and churn score. | —                                                                                                                                      | codex | feat/mission-control-schema            | MC-01-03                           | 6K       | This is the durable root state.            |
-| MC-02-02 | not-started | Add mission read/write services to `packages/coord` so the coordinator can load and persist mission state.                                | —                                                                                                                                      | codex | feat/mission-control-coord-store       | MC-02-01                           | 6K       | Keep storage simple and explicit.          |
-| MC-02-03 | not-started | Add mission status reporting to `mosaic mission` and `mosaic coord status`.                                                               | —                                                                                                                                      | codex | feat/mission-control-status-cli        | MC-02-02                           | 4K       | Operators need one obvious status command. |
-| MC-02-04 | not-started | Add tests for mission persistence and recovery after restart.                                                                             | —                                                                                                                                      | haiku | feat/mission-control-persistence-tests | MC-02-02                           | 4K       | Verify mission survives process churn.     |
-|          | MC-02-05    | done                                                                                                                                      | Add a worktree-root convention to the mission runtime notes and startup guidance so agents prefer `/src/<repo>-worktrees` over `/tmp`. | —     | haiku                                  | docs/mission-control-worktree-root | MC-01-03 | 3K                                         | Keep long-lived work on the larger persistent drive. |
-
-**Milestone 2 estimate:** ~20K tokens
-
----
-
-## Milestone 3 — Board atomization and task linkage
-
-Goal: derive assignable tasks from the PRD and keep them linked to mission state.
-
-| id       | status      | description                                                                                 | issue | agent  | branch                           | depends_on         | estimate | notes                                       |
-| -------- | ----------- | ------------------------------------------------------------------------------------------- | ----- | ------ | -------------------------------- | ------------------ | -------- | ------------------------------------------- |
-| MC-03-01 | not-started | Add a PRD-to-task decomposition rule set: every user story maps to one or more board tasks. | —     | sonnet | feat/mission-control-decompose   | MC-01-01           | 5K       | Start simple and deterministic.             |
-| MC-03-02 | not-started | Implement board generation from the PRD in a machine-readable format.                       | —     | codex  | feat/mission-control-board-gen   | MC-03-01           | 6K       | Output should be usable by the coordinator. |
-| MC-03-03 | not-started | Add dependency validation so tasks cannot start before parent tasks complete.               | —     | codex  | feat/mission-control-deps        | MC-03-02           | 5K       | Enforces ordering.                          |
-| MC-03-04 | not-started | Add review-task support so a mission cannot close without a reviewer step.                  | —     | sonnet | feat/mission-control-review-gate | MC-03-03           | 4K       | Preserves quality.                          |
-| MC-03-05 | not-started | Add tests proving the board stays traceable back to the PRD user stories.                   | —     | haiku  | feat/mission-control-trace-tests | MC-03-02, MC-03-03 | 4K       | Traceability is the point.                  |
-
-**Milestone 3 estimate:** ~24K tokens
-
----
-
-## Milestone 4 — Short-cycle detector and rotation engine
-
-Goal: detect when a session is stuck and rotate to a fresh session before quality falls off.
-
-| id       | status      | description                                                                                                                         | issue | agent  | branch                              | depends_on | estimate | notes                                          |
-| -------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------------- | ----- | ------ | ----------------------------------- | ---------- | -------- | ---------------------------------------------- |
-| MC-04-01 | not-started | Define churn signals: repeated compaction, identical tool loops, repeated permission prompts, and no progress across several turns. | —     | sonnet | feat/mission-control-churn-signals  | MC-02-01   | 4K       | Keep the rules explicit.                       |
-| MC-04-02 | not-started | Implement churn scoring in the coordinator with configurable thresholds.                                                            | —     | codex  | feat/mission-control-churn-score    | MC-04-01   | 6K       | Weighted score makes tuning easier.            |
-| MC-04-03 | not-started | Implement automatic session rotation when churn crosses the threshold.                                                              | —     | codex  | feat/mission-control-rotate-session | MC-04-02   | 6K       | The session is disposable; the mission is not. |
-| MC-04-04 | not-started | Add tests for rotation triggers and for avoiding premature rotation.                                                                | —     | haiku  | feat/mission-control-rotation-tests | MC-04-03   | 4K       | Prevent flapping.                              |
-
-**Milestone 4 estimate:** ~20K tokens
-
----
-
-## Milestone 5 — Handoff generation and re-entry
-
-Goal: preserve the best context from the old session and inject it into the new session cleanly.
-
-| id       | status      | description                                                                                                          | issue | agent  | branch                              | depends_on         | estimate | notes                                    |
-| -------- | ----------- | -------------------------------------------------------------------------------------------------------------------- | ----- | ------ | ----------------------------------- | ------------------ | -------- | ---------------------------------------- |
-| MC-05-01 | not-started | Define the handoff packet schema: mission ID, session ID, completed work, blockers, next 3 actions, and constraints. | —     | sonnet | feat/mission-control-handoff-schema | MC-02-01           | 4K       | Keep it compact and structured.          |
-| MC-05-02 | not-started | Implement handoff packet writing during rotation.                                                                    | —     | codex  | feat/mission-control-handoff-write  | MC-05-01, MC-04-03 | 5K       | Persist before the old session exits.    |
-| MC-05-03 | not-started | Implement handoff packet loading at session startup.                                                                 | —     | codex  | feat/mission-control-handoff-load   | MC-05-01, MC-04-03 | 5K       | New session should know the next action. |
-| MC-05-04 | not-started | Add tests proving a rotated session can continue the mission without manual re-prompting.                            | —     | haiku  | feat/mission-control-handoff-tests  | MC-05-02, MC-05-03 | 4K       | Resume quality is the key metric.        |
-
-**Milestone 5 estimate:** ~18K tokens
-
----
-
-## Milestone 6 — Operator surface and E2E validation
-
-Goal: expose the whole workflow through commands and verify it end-to-end.
-
-| id       | status      | description                                                                                               | issue | agent  | branch                           | depends_on         | estimate | notes                                        |
-| -------- | ----------- | --------------------------------------------------------------------------------------------------------- | ----- | ------ | -------------------------------- | ------------------ | -------- | -------------------------------------------- |
-| MC-06-01 | not-started | Add a CLI command to inspect the active mission, PRD path, board path, task statuses, and latest handoff. | —     | codex  | feat/mission-control-inspect-cli | MC-02-03, MC-05-03 | 5K       | One place to inspect the whole stack.        |
-| MC-06-02 | not-started | Add a compact dashboard or TUI summary view for mission health.                                           | —     | codex  | feat/mission-control-summary-ui  | MC-06-01           | 6K       | Nice to have, but not before the core works. |
-| MC-06-03 | not-started | Build an E2E harness that simulates compaction / rotation and verifies the mission can continue.          | —     | sonnet | feat/mission-control-e2e-harness | MC-04-03, MC-05-03 | 8K       | This is the proof that the design works.     |
-| MC-06-04 | not-started | Add final docs for operators explaining how PRD, mission, and board fit together.                         | —     | haiku  | feat/mission-control-ops-docs    | MC-06-03           | 4K       | Make it usable by humans.                    |
-| MC-06-05 | not-started | Consolidate review findings and close the mission with a release note.                                    | —     | sonnet | chore/mission-control-close      | MC-06-04           | 3K       | Only after the E2E passes.                   |
-
-**Milestone 6 estimate:** ~26K tokens
-
----
-
-## Execution Notes
-
-- `sonnet` is best for planning, decomposition, and the review-gate tasks.
-- `codex` is best for schema, coordinator, and CLI implementation.
-- `haiku` is best for validation, traceability checks, and docs.
-- The first implementation pass should stay file-first and keep the runtime state thin.
-- The mission should not close until the PRD, board, mission manifest, and E2E harness all agree.

docs/plans/2026-05-06-hermes-mosaic-alignment.md

@@ -1,238 +0,0 @@
-# Hermes-Mosaic Alignment Plan
-
-> **For Hermes:** Use subagent-driven-development skill to implement this plan task-by-task.
-
-**Goal:** Package Mosaic's mechanical coordination primitives as a native Hermes toolset so any Hermes profile gets mission management, task decomposition, handoff, and session continuity without depending on the Mosaic gateway or OpenClaw runtime.
-
-**Architecture:** Extract the coordination logic from Mosaic's `packages/coord` (TypeScript, file-first) into a Hermes Python toolset that wraps the same file conventions. The Mosaic Stack repo remains the canonical upstream for the file formats (TASKS.md schema, mission.json schema, handoff packet schema). Hermes implements native Python tools that read/write those same files, plus tool-calls for churn detection and handoff generation that have no Mosaic equivalent today.
-
-**Tech Stack:** Python (Hermes toolset), SQLite (Hermes Kanban), JSON + Markdown (Mosaic file conventions)
-
----
-
-## Alignment Map
-
-### What Mosaic has that Hermes needs
-
-| Mosaic Component                 | What it does                                              | Natural Hermes home                          | Why                                                                                                                                                                              |
-| -------------------------------- | --------------------------------------------------------- | -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `packages/coord` (mission.ts)    | Mission CRUD, session tracking, milestone state           | **Hermes toolset: `mission`**                | Mission state is session-scoped, not gateway-scoped. Hermes sessions already have identity, process tracking, and context windows.                                               |
-| `packages/coord` (tasks-file.ts) | Parse/write TASKS.md tables                               | **Hermes toolset: `mission`** (same)         | Hermes already reads/writes files. The TASKS.md parser is ~300 lines of pure string manipulation — trivial Python port.                                                          |
-| `packages/coord` (runner.ts)     | Spawn claude/codex workers with continuation prompts      | **Already covered by `delegate_task`**       | Hermes delegate_task already does isolated subagent spawning with restricted toolsets. The runner's "find next task and build continuation prompt" logic moves into a tool-call. |
-| `packages/coord` (status.ts)     | Mission health, task progress, next task                  | **Hermes toolset: `mission`** (same)         | Status readout fits naturally as a tool-call. No gateway needed.                                                                                                                 |
-| `packages/prdy`                  | PRD generation wizard                                     | **Hermes skill: `prdy`**                     | PRD generation is a prompt + template problem, not infrastructure. A Hermes skill with templates is the right fit.                                                               |
-| `plugins/mosaic-framework`       | before_agent_start + subagent_spawning hooks              | **Hermes system prompt injection**           | Hermes already injects system context via skills and config. The framework preamble and worktree rules become standard Hermes skills loaded by the orchestrator profile.         |
-| `plugins/macp`                   | OpenClaw ACP bridge (spawn codex/claude)                  | **Already covered by `delegate_task` + ACP** | Hermes already has ACP support and delegate_task. The MACP bridge is redundant when running natively in Hermes.                                                                  |
-| Churn detection (planned)        | Detect compaction loops, repeated tool calls, no progress | **Hermes middleware**                        | This needs to live inside Hermes's turn loop where it can observe tool-call patterns. Mosaic can't see this from outside.                                                        |
-| Handoff packet (planned)         | Structured context summary for session rotation           | **Hermes toolset: `mission`**                | Handoff is a serialization of mission + session state. Hermes owns the session, so it should own the handoff.                                                                    |
-
-### What Hermes already has that replaces Mosaic infrastructure
-
-| Mosaic concept       | Hermes equivalent                     | Notes                                                                                                    |
-| -------------------- | ------------------------------------- | -------------------------------------------------------------------------------------------------------- |
-| Gateway (NestJS)     | Hermes gateway                        | Hermes already has a gateway with WebSocket, Discord, Telegram, CLI. No need for a second one.           |
-| Pi SDK agent runtime | Hermes agent loop                     | Hermes IS the agent runtime. OpenClaw's Pi SDK is a different runtime that Mosaic targets.               |
-| MACP ACP bridge      | `delegate_task` + ACP tools           | Same capability, already native.                                                                         |
-| Session identity     | Hermes session IDs + process_registry | Hermes already tracks session identity, PIDs, and background processes.                                  |
-| Task execution board | Hermes Kanban                         | Fully functional SQLite-backed Kanban with dispatcher, triage, events, comments.                         |
-| Worker spawning      | Hermes dispatcher + cron              | Kanban dispatcher + cron already handle this.                                                            |
-| Context injection    | Hermes skills + system prompt         | Skills are loaded at session start and injected into context. Exactly what mosaic-framework plugin does. |
-| File checkpoints     | Hermes checkpoint_manager             | Already tracks file mutations with shadow git.                                                           |
-
-### What Mosaic keeps as its own entity
-
-| Component             | Why it stays in Mosaic                              |
-| --------------------- | --------------------------------------------------- |
-| `apps/gateway`        | NestJS API surface — Mosaic's web platform offering |
-| `apps/web`            | Next.js dashboard — Mosaic's UI offering            |
-| `packages/types`      | Shared TS contracts for Mosaic gateway plugins      |
-| `packages/db`         | Drizzle ORM + PG — Mosaic's data layer              |
-| `packages/auth`       | BetterAuth — Mosaic's auth system                   |
-| `packages/brain`      | PG-backed data layer for Mosaic web app             |
-| `packages/queue`      | Valkey task queue for Mosaic gateway                |
-| `plugins/discord`     | OpenClaw Discord plugin                             |
-| `plugins/telegram`    | OpenClaw Telegram plugin                            |
-| `packages/mosaic` CLI | The `mosaic` CLI — Mosaic's own command surface     |
-
----
-
-## Architecture: `mission` Toolset for Hermes
-
-### New files under `/opt/hermes/tools/`
-
-```
-mission_tools.py      — Tool-call surface (mission_create, mission_status,
-                         mission_next_task, mission_update_task, mission_handoff,
-                         mission_resume)
-mission_state.py       — State management (read/write mission.json, parse TASKS.md,
-                         parse MISSION-MANIFEST.md)
-mission_churn.py       — Churn detection (tool-loop counter, compaction counter,
-                         progress scorer)
-mission_handoff.py     — Handoff packet generation and loading
-```
-
-### Tool-calls exposed to the agent
-
-| Tool                  | What it does                                                                      | When the agent calls it                     |
-| --------------------- | --------------------------------------------------------------------------------- | ------------------------------------------- |
-| `mission_create`      | Initialize mission.json + TASKS.md + MISSION-MANIFEST.md in a project dir         | When starting a new mission                 |
-| `mission_status`      | Read current mission state, milestone progress, next task, active session         | At session start, or when checking progress |
-| `mission_next_task`   | Find the next `not-started` task whose dependencies are met, return its full spec | When the agent needs work to do             |
-| `mission_update_task` | Update a task row status in TASKS.md                                              | When completing or blocking a task          |
-| `mission_handoff`     | Generate a handoff packet from current session context + mission state            | Before session rotation or at session end   |
-| `mission_resume`      | Load a handoff packet and inject it as context for the new session                | At session start after rotation             |
-
-### Toolset registration
-
-The `mission` toolset follows the same pattern as `kanban`:
-
-1. **Gating**: Tools are available when:
-   - The profile has `mission` in its toolsets config, OR
-   - A `HERMES_MISSION_DIR` env var is set (cron/dispatcher spawned workers)
-2. **File conventions**: The toolset reads/writes the same file formats as Mosaic `packages/coord`:
-   - `.mosaic/orchestrator/mission.json` — mission state
-   - `docs/TASKS.md` — task table
-   - `docs/MISSION-MANIFEST.md` — mission manifest
-   - `docs/scratchpads/<id>.md` — session scratchpad
-
-3. **Kanban bridge**: Optional bidirectional sync between mission TASKS.md rows and Kanban task cards, so the dashboard sees mission tasks.
-
-### Churn detection (middleware)
-
-Churn detection lives in Hermes's turn loop, NOT as a tool-call. It observes:
-
-- Repeated compaction events (context window pressure)
-- Identical tool-call sequences (loop detection)
-- No file state changes across N turns
-- Repeated permission denials
-
-When churn score exceeds threshold:
-
-1. `mission_handoff` is called automatically
-2. Session is rotated (fresh context window)
-3. `mission_resume` is called in the new session
-
-This is new infrastructure that only Hermes can provide (Mosaic runs outside the agent loop).
-
----
-
-## Implementation Tasks
-
-### Phase 1: Core state management (Python port of coord)
-
-| Task                                               | Files                         | Estimate |
-| -------------------------------------------------- | ----------------------------- | -------- |
-| 1.1 Port mission.json read/write to Python         | `mission_state.py`            | 2h       |
-| 1.2 Port TASKS.md parser to Python                 | `mission_state.py`            | 2h       |
-| 1.3 Port MISSION-MANIFEST.md reader to Python      | `mission_state.py`            | 1h       |
-| 1.4 Implement `mission_create` tool-call           | `mission_tools.py`            | 1h       |
-| 1.5 Implement `mission_status` tool-call           | `mission_tools.py`            | 1h       |
-| 1.6 Implement `mission_next_task` tool-call        | `mission_tools.py`            | 1h       |
-| 1.7 Implement `mission_update_task` tool-call      | `mission_tools.py`            | 1h       |
-| 1.8 Register `mission` toolset in Hermes registry  | `tools/registry.py`           | 30m      |
-| 1.9 Add `mission` to orchestrator profile toolsets | `config.yaml`                 | 10m      |
-| 1.10 Write unit tests for mission_state            | `tests/test_mission_state.py` | 2h       |
-| 1.11 Write unit tests for TASKS.md parser          | `tests/test_tasks_parser.py`  | 1h       |
-
-**Phase 1 estimate:** ~13h
-
-### Phase 2: Handoff and session continuity
-
-| Task                                              | Files                                    | Estimate |
-| ------------------------------------------------- | ---------------------------------------- | -------- |
-| 2.1 Define handoff packet schema (JSON)           | `mission_handoff.py`                     | 1h       |
-| 2.2 Implement `mission_handoff` tool-call         | `mission_handoff.py`, `mission_tools.py` | 2h       |
-| 2.3 Implement `mission_resume` tool-call          | `mission_handoff.py`, `mission_tools.py` | 2h       |
-| 2.4 Wire handoff into session start (auto-resume) | agent loop hook                          | 2h       |
-| 2.5 Write tests for handoff round-trip            | `tests/test_mission_handoff.py`          | 1h       |
-
-**Phase 2 estimate:** ~8h
-
-### Phase 3: Churn detection
-
-| Task                                                           | Files                         | Estimate |
-| -------------------------------------------------------------- | ----------------------------- | -------- |
-| 3.1 Define churn signal weights and thresholds                 | `mission_churn.py`            | 1h       |
-| 3.2 Implement tool-loop detector (consecutive identical calls) | `mission_churn.py`            | 2h       |
-| 3.3 Implement compaction pressure detector                     | `mission_churn.py`            | 1h       |
-| 3.4 Implement progress scorer (file state delta)               | `mission_churn.py`            | 2h       |
-| 3.5 Wire churn scoring into agent turn loop                    | agent loop middleware         | 2h       |
-| 3.6 Implement auto-rotation trigger                            | agent loop + handoff          | 2h       |
-| 3.7 Write tests for churn scoring                              | `tests/test_mission_churn.py` | 1h       |
-
-**Phase 3 estimate:** ~11h
-
-### Phase 4: Kanban bridge + CLI surface
-
-| Task                                                 | Files                    | Estimate |
-| ---------------------------------------------------- | ------------------------ | -------- |
-| 4.1 Implement TASKS.md → Kanban sync (one-way first) | `mission_kanban_sync.py` | 2h       |
-| 4.2 Add `hermes mission` CLI subcommand              | `mission_cli.py`         | 2h       |
-| 4.3 Add `hermes mission status` command              | `mission_cli.py`         | 1h       |
-| 4.4 Add `hermes mission init` command                | `mission_cli.py`         | 1h       |
-| 4.5 Add `hermes mission handoff` command             | `mission_cli.py`         | 1h       |
-| 4.6 Add `hermes mission resume` command              | `mission_cli.py`         | 1h       |
-
-**Phase 4 estimate:** ~8h
-
----
-
-## File Format Compatibility
-
-The Python implementation MUST read and write the exact same file formats as Mosaic's TypeScript `packages/coord`. This means:
-
-1. **mission.json** schema is identical to `Mission` type in `packages/coord/src/types.ts`
-2. **TASKS.md** table format is identical to what `packages/coord/src/tasks-file.ts` parses
-3. **MISSION-MANIFEST.md** is free-form markdown (no parser needed — just read the file)
-4. **Handoff packets** are a new JSON format defined in this toolset (Mosaic doesn't have them yet)
-
-This way a project can use Hermes mission tools OR Mosaic `mosaic coord` commands interchangeably. The files are the contract.
-
----
-
-## Relationship Diagram
-
-```
-Mosaic Stack (TypeScript)          Hermes Agent (Python)
-┌─────────────────────────┐        ┌─────────────────────────┐
-│  packages/coord          │        │  tools/mission_tools.py  │
-│  ├─ mission.ts           │◄──────►│  ├─ mission_state.py     │
-│  ├─ tasks-file.ts        │  same  │  ├─ mission_handoff.py   │
-│  ├─ status.ts            │  files │  ├─ mission_churn.py     │
-│  └─ runner.ts            │        │  └─ mission_tools.py     │
-│                          │        │                          │
-│  packages/prdy           │        │  skills/prdy/            │
-│  └─ templates, wizard    │◄──────►│  └─ SKILL.md + templates │
-│                          │        │                          │
-│  plugins/mosaic-framework│        │  skills/ (existing)      │
-│  └─ context injection    │◄──────►│  └─ kanban-orchestrator  │
-│                          │        │     + mosaic-coding-*     │
-│  plugins/macp            │        │  tools/delegate_task.py  │
-│  └─ ACP bridge           │◄──────►│  └─ already covers this  │
-│                          │        │                          │
-│  (stays in Mosaic)       │        │  tools/kanban_tools.py   │
-│  apps/gateway            │        │  └─ Hermes Kanban DB     │
-│  apps/web                │        │                          │
-│  packages/db             │        │  tools/cronjob_tools.py  │
-│  packages/queue          │        │  └─ already covers cron  │
-└─────────────────────────┘        └─────────────────────────┘
-```
-
----
-
-## Open Questions
-
-1. **Should the `mission` toolset ship with Hermes core, or as a plugin?**
-   - Recommendation: ship as a **built-in toolset** (like `kanban`) since mission coordination is a core agent capability, not an optional integration. The file formats are stable and the code is small.
-
-2. **Should churn detection be per-profile configurable?**
-   - Recommendation: yes. Add `mission.churn_threshold` and `mission.churn_weights` to profile config.yaml. Default threshold = 5 consecutive no-progress turns.
-
-3. **Should handoff packets live in the project dir or in Hermes home?**
-   - Recommendation: **project dir** (`.mosaic/handoffs/<session-id>.json`). This keeps them version-controlled and accessible regardless of which agent runtime picks up the project.
-
-4. **Bidirectional Kanban sync?**
-   - Recommendation: **one-way first** (TASKS.md → Kanban). Bidirectional adds conflict resolution complexity. Ship one-way, add reverse sync in v2 if needed.
-
-5. **PRD generation — skill or tool-call?**
-   - Recommendation: **skill** (`prdy`). PRD generation is a prompt engineering problem with templates. Skills already handle this pattern perfectly.

docs/plans/2026-05-07-coordination-resilience.md

@@ -1,236 +0,0 @@
-# Mosaic Stack ↔ Hermes Coordination Resilience
-
-> Purpose: document the self-healing coordination patterns that emerged while implementing the Hermes mission toolset, distress-card protocol, and auto-heal watchers, so the same mechanics can be reimplemented in Mosaic Stack or any similar agent platform.
-
-## Summary
-
-The coordination layer should be treated as a system of mechanical recovery loops rather than a single interactive agent session.
-
-## SIBKISS operational summary
-
-- mission on
-- heartbeat always
-- resume from packet
-- block with `[BLOCKED]`
-- reassign
-- keep tasks tiny
-- auto-heal dead workers
-
-The design has four parts:
-
-1. Atomic task decomposition — workers operate only within a small, explicit scope.
-2. Distress signaling — workers create a standardized `[BLOCKED]` card when they encounter a blocker outside their scope.
-3. Mechanical fallback — if the worker cannot phone home because of rate limits or dead context, a cron-style watcher synthesizes the distress card for them.
-4. Auto-heal / reassignment — stale workers are reaped, crash-loops are reset, and rate-limited work is reassigned to a different profile/provider.
-
-## Why this exists
-
-Observed failure modes:
-
-- Scope creep: a worker completes the target fix, then spends the rest of its budget chasing downstream cascade work.
-- Silent failure / dead worker: the worker PID is gone, but the task remains running or blocked.
-- Rate-limited worker: the worker is too constrained to create a help card itself, so it spins or fails without a clean handoff.
-
-The answer is not to raise iteration caps or ask the worker to keep trying longer. The answer is to make the coordination layer self-healing and the work items atomic.
-
-## Core workflow
-
-### 1) Atomic task boundaries
-
-Every task should have:
-
-- one concern
-- explicit files/packages in scope
-- explicit files/packages out of scope
-- a maximum file count if possible
-- a stated expected iteration budget
-
-When a worker discovers work outside scope, it must stop fixing it and hand off.
-
-### 2) Worker-authored distress card
-
-If the worker can still report status, it creates a card like:
-
-- Title: `[BLOCKED] t_<source_id> <blocker_type>`
-- Assignee: `tuesday` / orchestrator role
-- Status: `ready`
-- Body: standardized distress template with source task, blocker type, completed work, cannot-touch scope, and needed action
-
-The orchestrator receives the card, acts on it, and closes the loop.
-
-## Routing rules
-
-### Distress card routing
-
-- Title: `[BLOCKED] t_<source_id> <blocker_type>`
-- Assignee: `tuesday` / orchestrator role
-- Status: `ready`
-- Body: standardized distress template with source task, blocker type, completed work, cannot-touch scope, and needed action
-- Source task stays linked to the distress card so the recovery trail is auditable
-
-The orchestrator receives the card, acts on it, and closes the loop.
-
-### 3) Mechanical fallback for rate-limited workers
-
-If the worker is too rate-limited or unstable to create the distress card itself, a no-agent watcher must synthesize the card from the task row and failure metadata.
-
-That watcher should:
-
-- inspect running / blocked tasks
-- detect repeated 429 / 503 / overload errors
-- create the same standardized `[BLOCKED]` card on behalf of the worker
-- link the distress card to the source task
-- add a comment to the source task
-- allow the dispatcher to pick up the new card immediately
-
-This is the key fix for the logic issue: the worker does not need to be able to phone home if the watcher can do it mechanically.
-
-### 4) Auto-heal for dead workers
-
-A separate no-agent watcher should:
-
-- reap dead PIDs stuck in `running`
-- reset crash-loops whose failures are infrastructure-related
-- escalate tasks that have been reset too many times
-
-This watcher prevents stale tasks from clogging the board and keeps the dispatch queue moving.
-
-## Distress card contract
-
-### Canonical title
-
-```text
-[BLOCKED] t_<source_task_id> <blocker_type>
-```
-
-### Canonical blocker types
-
-- `scope_boundary`
-- `env_blocker`
-- `credential_failure`
-- `dependency`
-- `iteration_budget`
-- `rate_limited`
-
-### Canonical body
-
-```markdown
-## Distress Signal
-
-- Blocked task: t_xxx
-- Worker: <profile_name>
-- Branch: <git_branch_name>
-- Workspace: <path>
-- Blocker type: <type>
-- Completed: <what was done>
-- Cannot touch: <out-of-scope packages/files>
-- Needs: <what the orchestrator should do>
-- State: committed | uncommitted | stashed(<stash_name>)
-
-## Scope Guard
-
-DO NOT touch: anything outside diagnosing and remediating the blocker described above
-Only fix: assign, split, reassign, or unblock the source task
-```
-
-## Routing rules
-
-### Distress card routing
-
-- `[BLOCKED]` title prefix should bypass normal triage.
-- The card should go directly to the orchestration profile.
-- The orchestrator should start from a clean session each time.
-
-### Rate-limit fallback
-
-When the source task is rate-limited:
-
-- do not keep retrying in the worker
-- let the watcher synthesize the distress card
-- have the orchestrator reassign the source task to a different profile/provider combo
-
-### Provider fallback principle
-
-Never reassign rate-limited work back to the same provider if the failure was provider pressure. Use a different provider when possible.
-
-### Suggested fallback order
-
-1. Keep the current task body and scope guards intact.
-2. Reassign to a different profile on a different provider.
-3. If that is impossible, reassign to a different profile on the same provider only for non-rate-limit blockers.
-4. If repeated failures continue, split the task into a narrower atomic card.
-
-## Related recovery docs
-
-- Mission packet recovery contract: `/opt/hermes/docs/mission-toolset-heartbeat.md`
-- Hermes mission implementation plan: `/opt/hermes/docs/plans/mission-toolset-implementation.md`
-- The same packet-first resume rule applies: inspect the latest packet before re-reading mission files.
-- New-session trigger: when a profile config changes, start a fresh session or `/reset` so the updated toolset is actually loaded.
-
-## Watchers to implement
-
-### Auto-heal watcher
-
-Responsibilities:
-
-- reap stale workers
-- reset dead-PID crash loops
-- track reset counts
-- escalate after repeated resets
-
-### Distress synthesizer watcher
-
-Responsibilities:
-
-- detect rate-limited / stuck workers
-- create `[BLOCKED]` cards mechanically
-- link the card to the source task
-- leave a comment for traceability
-
-### Iteration-budget watcher
-
-Responsibilities:
-
-- detect long-running tasks and repeated failure patterns
-- recommend splits when a task is clearly over-scoped
-- report tasks that need human review after multiple resets
-
-## Operational principle
-
-If a task cannot cleanly finish within its atomic scope, the right response is to surface a smaller coordination problem, not to keep burning context.
-
-This is what makes the system robust across compaction, rate limits, and dead workers.
-
-## Suggested implementation order
-
-1. Atomic task metadata in task bodies
-2. Worker-authored distress card protocol
-3. Mechanical distress synthesizer watcher
-4. Auto-heal watcher for dead workers
-5. Orchestrator routing rules for `[BLOCKED]`
-6. Rate-limit fallback / model reassignment table
-
-## Where this fits in Hermes
-
-- Kanban = durable work graph and status engine
-- Watchers = mechanical healing and distress synthesis
-- Orchestrator = split / reassign / unblock decision-maker
-- Workers = execution inside atomic task boundaries
-
-## Where this fits in Mosaic Stack
-
-- PRD / coordination infra should encode the same patterns
-- Mosaic can use the same distress-card contract and watcher logic
-- The coordination model should be runtime-agnostic: any agent system can use it if it can write a task card and react to a ready queue
-
-## Cross-project takeaway
-
-The important pattern is not the specific tool names. It is the mechanical feedback loop:
-
-- detect failure without requiring the failing worker to succeed
-- create a standardized help artifact
-- route that artifact to a fresh orchestrator context
-- repair the assignment graph
-- continue the mission
-
-That pattern is reusable anywhere.

docs/plans/agent-reflection-loop-PRD.md

@@ -1,173 +0,0 @@
-# PRD — Agent Reflection Loop (durable kernel)
-
-**Issue:** [#544](http://git.mosaicstack.dev/mosaicstack/stack/issues/544)
-**Source design:** jarvis-brain `docs/planning/AGENT-REFLECTION-LOOP.md` (commit df6576fc, debate-hardened v2)
-**Status:** in-progress
-**Scope rule:** Build the **durable kernel** only. The closed calibration/skill-synthesis loop
-(design §7–§8) is **gated** behind Phase-0 experiments P1/P2/P3 and is explicitly out of scope here.
-
----
-
-## 1. Problem
-
-At end-of-run an agent holds context that never reaches the diff or the "done" message —
-assumptions, shortcuts, untested paths, the single most-likely way the work is wrong. That context
-is what a lead/human needs to judge trust, and it evaporates when the session ends. Capture it
-mechanically as **structured data** (`reflection.v1`), and derive a **review risk-floor** from the
-change surface so risky diffs are flagged for independent review.
-
-## 2. Non-goals (gated on Phase-0)
-
-- No closed calibration loop (predicted-vs-actual scoring as a routing input).
-- No skill synthesis.
-- No automated reviewer routing/dispatch. The kernel **writes** the sidecar; pickup is future work.
-
-## 3. Components & exact placement (main-branch truth)
-
-| #   | Component            | Path                                                                                             | Mirror                              |
-| --- | -------------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------- |
-| a   | Stop hook (capture)  | `packages/mosaic/framework/tools/qa/reflect-stop-hook.sh`                                        | `tools/qa/prevent-memory-write.sh`  |
-| a   | Hook registration    | `packages/mosaic/framework/runtime/claude/settings.json` (`hooks.Stop`)                          | existing `PreToolUse`/`PostToolUse` |
-| b   | JSON Schema          | `packages/macp/src/schemas/reflection.v1.schema.json`                                            | `schemas/task.schema.json`          |
-| b   | TS types (zod) + DTO | `packages/types/src/reflection/{index.ts,reflection.dto.ts}` + re-export from `src/index.ts`     | `packages/types/src/federation/*`   |
-| c   | Diff risk-floor      | `packages/macp/src/risk-floor.ts` (+ `__tests__/risk-floor.test.ts`, export from `src/index.ts`) | `packages/macp/src/gate-runner.ts`  |
-| d   | Phase-0 scripts      | `scripts/analysis/reflect-{git-history,board-history,calibration}.sh`                            | `scripts/publish-npmjs.sh`          |
-
-**Activation note (deliberate deviation):** the `settings-overlays/` directory has **no merge
-mechanism** (referenced only in docs), so a hooks overlay there would be inert. The Stop hook is
-registered in the canonical `runtime/claude/settings.json` — the same file the `mosaic` launcher
-reflects into `~/.claude/settings.json` (verified byte-identical hooks live there). Still fully
-vendored in-repo.
-
-## 4. `reflection.v1` schema (authoritative field list)
-
-```jsonc
-{
-  "schema": "reflection.v1", // literal
-  "task_ref": "string", // canonical task ref; kernel derives from REFLECTION_TASK_REF or repo+branch
-  "agent": "string", // persona/runtime id (REFLECTION_AGENT or "unknown")
-  "session_id": "string", // from Stop payload session_id, else "unknown"
-  "timestamp": "string", // ISO-8601 UTC
-  "repo": "string", // repo root basename
-  "confidence": 0.0, // FLOAT [0,1] — SELF-REPORTED (optional; null if not supplied)
-  "most_likely_wrong": {
-    // SELF-REPORTED (optional)
-    "surface": "auth|data|infra|ui|build|test|docs|none",
-    "description": "string",
-  },
-  "known_not_in_diff": "string|null", // SELF-REPORTED: "what I know that isn't visible in the diff"
-  "risk": {
-    // MECHANICAL — from risk-floor
-    "needs_review": true,
-    "score": 0.0, // [0,1]
-    "surface": "auth|data|infra|ui|build|test|docs|none",
-    "reason": "string",
-  },
-  "files_changed": ["string"], // MECHANICAL — git diff name-only
-  "provenance": {
-    "source": "stop-hook",
-    "reflection_attempt": 1,
-    "degraded": false, // true if self-report inputs missing/unreadable
-    "reflection_mode": "off|solo|orchestrated",
-  },
-}
-```
-
-**Mechanical vs self-reported.** A bash Stop hook cannot author the agent's self-assessment. The
-hook populates the **mechanical** fields deterministically (risk, files_changed, provenance, ids).
-The **self-reported** fields are read from an optional agent-supplied input file
-(`$REFLECTION_INPUT`, default `<repo>/.mosaic/reflection-input.json`) and merged if present;
-absent/unreadable → those fields null and `provenance.degraded=true`. This realizes the design's
-"hook is a pre-seed, not the asker" (§4).
-
-## 5. Stop hook behavior (fail-closed, non-blocking)
-
-1. Read Stop payload JSON from stdin.
-2. **Fail-closed:** if `REFLECTION_MODE` is unset or `off` → `exit 0` immediately (strict no-op). This
-   is the global-registration safety guarantee.
-3. **Sentinel guard:** if `<sidecar>.lock` exists → `exit 0` (prevents re-fire loops). Create it,
-   `trap` cleanup.
-4. Determine output dir: `$REFLECTION_DIR` else `<repo>/.mosaic/reflections/`. `mkdir -p`.
-5. Compute mechanical fields: `git diff --name-only` (HEAD + staged + worktree, best-effort),
-   call risk-floor logic (inline bash port OR `node -e` into `@mosaicstack/macp` — see §6), session
-   ids from payload + env.
-6. Merge optional `$REFLECTION_INPUT` self-report if readable JSON.
-7. Write `reflection.v1` to a temp file, `mv` (atomic) to `<dir>/<session>-<ts>.reflection.json`.
-8. Always `exit 0`. **Never** emit a `decision` field (Stop hooks are observational).
-
-Hook must never fail the session: wrap risky steps, default to `degraded:true` on any error, exit 0.
-
-## 6. Risk-floor (`packages/macp/src/risk-floor.ts`)
-
-Pure, deterministic, no IO. Single source of truth for the verdict; the hook calls it via
-`node --input-type=module -e` (importing the built package) **or**, to avoid a node dependency in the
-hook path, the hook ports the same surface table. **Decision:** implement the canonical logic in TS
-(tested), and have the hook shell out to node when available, else fall back to a minimal inline
-classifier flagged `degraded:true`. (Keep the TS the authority; the inline path is a safety net.)
-
-```ts
-export type ReviewSurface = 'auth' | 'data' | 'infra' | 'ui' | 'build' | 'test' | 'docs' | 'none';
-export interface RiskFloorInput {
-  filesChanged: string[];
-  insertions?: number;
-  deletions?: number;
-}
-export interface RiskFloorVerdict {
-  needs_review: boolean;
-  score: number;
-  surface: ReviewSurface;
-  reason: string;
-}
-export function evaluateRiskFloor(input: RiskFloorInput): RiskFloorVerdict;
-```
-
-Surface classification by path regex (first match wins, highest-risk surface dominates):
-
-- `auth` (weight 1.0): `auth`, `login`, `session`, `token`, `permission`, `rbac`, `credential`, `secret`
-- `data` (0.9): `migration`, `prisma`, `schema`, `\.sql`, `entity`, `repository`, `seed`
-- `infra` (0.85): `docker`, `\.woodpecker`, `compose`, `traefik`, `deploy`, `helm`, `k8s`, `terraform`
-- `build` (0.6): `package.json`, `tsconfig`, `turbo.json`, `pnpm-`, `\.config\.`, `eslint`, `vite`
-- `ui` (0.4): `\.tsx`, `\.css`, `components/`, `apps/web/`
-- `test` (0.2): `\.spec\.`, `\.test\.`, `__tests__/`
-- `docs` (0.1): `\.md`, `docs/`
-- `none` (0.0): anything else
-
-`needs_review = score >= THRESHOLD` (default `0.5`, overridable). `reason` names the files+surface
-that tripped it. **Subordinate to CI:** this is a _floor_ (minimum review requirement) only;
-consumers MUST treat CI/tests as authoritative above the floor (precedence: CI/tests > human merge >
-reviewer verdict > self-reflection). Documented in the module header.
-
-## 7. Phase-0 experiment scripts (`scripts/analysis/`)
-
-Offline, no-infra bash. Each script: `#!/usr/bin/env bash`, `set -euo pipefail`, header `Usage:` +
-`Requirements:`, flag parsing, **prints its pre-registered kill condition**, emits structured
-(JSON/markdown) output. They are harnesses + rubrics — real corpora are wired later.
-
-- `reflect-git-history.sh` (**P2** — only-self-reflection bucket): scan `git log` for failure signals
-  (reverts, `fix:`/`hotfix` shortly after a feature merge) over a window; classify each by which gate
-  would catch it (CI / human-review / only-self-reflection) via a pre-registered heuristic; tally.
-  Kill: bucket-3 near-empty → no §7/§8.
-- `reflect-board-history.sh` (**P3** — outcome detectability): given a task/board export (or the
-  git history of `data/` task files), measure the fraction of completed tasks with a
-  machine-detectable correct/wrong signal within 30 days. Kill: base-rate < 20% → caveat-notes only.
-- `reflect-calibration.sh` (**P1** — confidence signal): consume a labeled corpus (JSONL of
-  `{confidence, correct}`), compute discrimination (AUC/lift) on the self-rated-high subset, print
-  the metric vs the pre-registered chance threshold. Kill: AUC ≈ chance on the high subset → no §7/§8.
-
-## 8. CI / quality gates
-
-- TS packages: `pnpm typecheck` (tsc --noEmit), `pnpm lint` (eslint), `pnpm format:check`
-  (prettier), `pnpm test` (vitest). ESM, NodeNext, `.js` import specifiers, `*.dto.ts` at boundaries.
-- New files in existing packages need no CI config change; add ≥1 vitest spec per new TS module.
-- Bash scripts/hook are dev/runtime tooling, not CI-built; keep them `shellcheck`-clean.
-
-## 9. Acceptance criteria
-
-1. `REFLECTION_MODE` unset → hook is a strict no-op (`exit 0`, no file written). **(test)**
-2. With `REFLECTION_MODE=solo`, hook writes a schema-valid `reflection.v1` with correct mechanical
-   fields; self-report merged when `$REFLECTION_INPUT` present, `degraded:true` when absent.
-3. `evaluateRiskFloor` deterministic across all surfaces; unit-tested incl. auth/data/infra → review,
-   docs/test → no review, empty → `none`/no review.
-4. `reflection.v1` zod type + JSON Schema agree; sidecar validates against the schema.
-5. Phase-0 scripts run offline, print kill conditions, emit structured output, shellcheck-clean.
-6. `pnpm typecheck && pnpm lint && pnpm format:check && pnpm test` green; independent review passed.

docs/scratchpads/536-wrapper-login-pin.md

@@ -1,50 +0,0 @@
-# Issue 536 Wrapper Login Pin Scratchpad
-
-## Metadata
-
-- Date: 2026-06-12
-- Worktree: `/home/hermes/agent-work/536-wrapper-audit`
-- Branch: `fix/536-wrapper-login-pin`
-- Coordinator: `mos-claude`
-- Issue: `mosaicstack/stack#536`
-- Scope: Audit and fix Gitea git wrappers that hardcode or incorrectly inherit tea login/instance selection.
-
-## Objective
-
-Fix the framework git wrappers so Gitea issue/PR operations resolve the tea login from the target repository host instead of pinning `mosaicstack`. The fix must cover the class of bug across `packages/mosaic/framework/tools/git/`, not only `issue-close.sh`.
-
-## Acceptance Criteria
-
-1. `issue-close.sh` no longer uses `--login mosaicstack` for non-mosaic hosts.
-2. All wrappers in `packages/mosaic/framework/tools/git/` avoid hardcoded Gitea login fallback where host-specific resolution is available.
-3. Host-specific resolution works for `git.mosaicstack.dev` and `git.uscllc.com` using configured credentials / tea login data.
-4. Read-only verification runs against both Gitea instances where possible.
-5. Queue guard passes before push, PR is opened referencing #536, and merge is left to the coordinator.
-
-## Progress Log
-
-- Read required Mosaic hard-gate docs and coordinator briefing.
-- Read issue #536 via Gitea API with mosaicstack credentials.
-- Initial audit found hardcoded `${GITEA_LOGIN:-mosaicstack}` in issue and PR wrappers, plus shared `get_gitea_repo_args`.
-- Added host-aware Gitea login resolution in `detect-platform.sh`, including exact host matching for `tea login list` entries and HTTPS remotes with embedded credentials.
-- Updated Gitea issue, PR, milestone, and CI wrappers to use resolved host-specific tea login arguments instead of defaulting to `mosaicstack`.
-- Added authenticated API fallbacks for close/reopen paths so wrappers can still operate when a matching `tea` login is absent but token credentials are available.
-- Added regression coverage for stale `GITEA_LOGIN`, exact host matching, `--repo` override flows, USC issue close routing, mosaicstack API fallback, and PR metadata/merge fallbacks.
-- Delta after PR #538 review: extended host-aware login/repo resolution to PowerShell wrappers, Bash milestone wrappers, and API-only `--repo` fallback paths.
-- Delta after live USC `pr-create.sh` repro: tightened `GITEA_LOGIN` trust so stale login names are ignored unless the tea login itself matches the target host, and added USC API fallback coverage for `pr-create.sh`.
-
-## Verification
-
-- `bash -n packages/mosaic/framework/tools/git/*.sh`
-- `packages/mosaic/framework/tools/git/test-gitea-login-resolution.sh`
-- `packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh`
-- `packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh`
-- `pwsh -NoProfile` parse check for all `packages/mosaic/framework/tools/git/*.ps1`
-- `pnpm typecheck`
-- `pnpm lint`
-- `pnpm format:check`
-- `pnpm --filter @mosaicstack/mosaic test -- src/commands/git-wrapper-redirects.spec.ts`
-- `pnpm test` progressed past wrapper redirect assertions; local run then stopped on `apps/gateway` Postgres connection refused at `localhost:5433`, which CI provides as a service.
-- Live read-only: direct Gitea API read of `mosaicstack/stack#536` with `User-Agent: curl/8`.
-- Live read-only: USC temporary repo remote to `https://git.uscllc.com/USC/uconnect.git`; `issue-list.sh -n 1` resolved the USC login and returned USC issues.
-- Independent Codex review final verdict: approve, no findings.

docs/scratchpads/544-agent-reflection-loop.md

@@ -1,55 +0,0 @@
-# Scratchpad — #544 Agent Reflection Loop (durable kernel)
-
-**Started:** 2026-06-16 · **Branch:** `feat/agent-reflection-loop` · **Base:** `main` @ c461380
-
-## Goal
-
-Bake the durable kernel of the agent reflection loop into the Mosaic Stack
-monorepo through full delivery gates. Kernel only; closed loop (§7–§8) gated on
-Phase-0. Authoritative spec: `docs/plans/agent-reflection-loop-PRD.md`. Task
-breakdown: `docs/tasks/544-agent-reflection-loop.md`.
-
-## Timeline / decisions
-
-- Mapped house style against `main` truth (the earlier recon had mapped a dirty
-  feature branch and returned non-existent paths; re-cloned `main` clean).
-- macp uses co-located `*.spec.ts`; types uses `src/<mod>/{*.ts, *.dto.ts, __tests__/*.spec.ts}`.
-- zod v4 + class-validator/class-transformer present in `@mosaicstack/types`;
-  `packages/types/tsconfig.json` enables `experimentalDecorators`/`emitDecoratorMetadata`.
-- **Gotcha (fixed):** `class-transformer`'s `@Type` calls `Reflect.getMetadata`
-  at module-load time; the types vitest env has no `reflect-metadata`, so any test
-  importing the reflection barrel crashed on import. `chat.dto.ts` avoids this by
-  using class-validator only. Fix: dropped `@Type`/`@ValidateNested` from the DTO;
-  zod owns deep nested validation.
-- **Gotcha (fixed):** Stop hook `EXIT` trap referenced a `main`-local `lock` →
-  `unbound variable` under `set -u` at exit. Promoted to a global `LOCKFILE`.
-- **Gotcha (fixed):** the hook's own lock + `.mosaic/` scratch leaked into
-  `files_changed`. Excluded `^\.mosaic/` from the change-surface scan.
-
-## Verification evidence
-
-- macp: typecheck OK, lint OK, **88 tests pass** (15 new risk-floor).
-- types: typecheck OK, lint OK, **64 tests pass** (10 new reflection).
-- Root: `pnpm typecheck` (41 tasks), `pnpm lint` (23), `pnpm format:check`, `pnpm build` (23) — all green.
-- Stop hook smoke (throwaway git repo): TEST1 no-op (mode unset, 0 files);
-  TEST2 solo degraded, `.mosaic/` excluded, auth→needs_review; TEST3 self-report
-  merged, degraded=false; TEST4 lock suppresses re-fire. All pass, always exit 0.
-- shellcheck clean: hook + `reflect-{git-history,board-history,calibration}.sh`.
-- Phase-0 smoke: P2 on this repo (142 failures classified), P1 AUC=0.875 on a
-  synthetic fixture, P3 base-rate on a synthetic board — all emit structured output
-  - kill conditions.
-
-## Open risks / follow-ups
-
-- Full `pnpm test` (DB-bound packages) validated via CI's postgres service, not
-  locally; affected packages (macp, types) are DB-independent and green here.
-- sequential-thinking MCP was registered mid-session (effective next session);
-  this session compensated with the written PRD as the planning artifact.
-- Phase-0 corpora are not yet wired — scripts are harnesses + pre-registered
-  rubrics (P1/P2/P3 tasks tracked in jarvis-brain `agent-reflection-loop` project).
-
-## Gate status
-
-- [x] PRD authored · [x] issue #544 created + linked · [x] code + tests
-- [x] local gates green · [ ] independent code review · [ ] PR opened
-- [ ] CI terminal green · [ ] merged to main · [ ] issue closed

docs/scratchpads/git-wrapper-rollup-20260526.md

@@ -1,33 +0,0 @@
-# Git Wrapper Rollup — 2026-05-26
-
-## Objective
-
-Consolidate pending Mosaic wrapper fixes after `mosaic update` reported the local framework package was already current (`@mosaicstack/mosaic 0.0.30`) but the installed `~/.config/mosaic/tools` wrappers still lacked the open Gitea/Woodpecker wrapper patches.
-
-## Scope
-
-Roll up the open wrapper-related Gitea PR branches into one integration branch:
-
-- PR #513: `pr-ci-wait.sh` stdin collision fix.
-- PR #518: Gitea PR metadata/merge preflight hardening.
-- PR #521: Gitea merge fallback + unsafe PR-number rejection.
-- PR #522: Woodpecker credential/pagination fixes and CI Postgres service collision fix.
-- PR #523: explicit Gitea repo/login args and `eval` removal for PR/issue creation.
-
-## Conflict resolutions
-
-- Kept array-based command construction where possible instead of reintroducing `eval`.
-- Kept explicit `--repo OWNER/REPO --login mosaicstack` Gitea arguments for `tea` calls.
-- Combined PR merge API fallback behavior from metadata hardening and empty-identity fallback branches.
-- Preserved numeric PR-number validation for `pr-merge.sh`.
-
-## Verification checklist
-
-- `bash -n` on changed shell scripts.
-- Wrapper smoke checks from a clean worktree.
-- Gitea PR verification after push.
-- CI status checked through Gitea/Woodpecker.
-
-## Notes
-
-`mosaic update` did not install these fixes because the package registry still reports `@mosaicstack/mosaic 0.0.30` as current. The source patches must merge/release before normal framework update will carry them.

docs/scratchpads/t-a292e96f-gitea-pr-metadata.md

@@ -1,98 +0,0 @@
-# t_a292e96f — Gitea PR metadata wrapper fix
-
-## Objective
-
-Repair Mosaic git wrappers so Gitea PR metadata and merge preflight work for U-Connect PRs on `git.uscllc.com` without selecting the unrelated `git.mosaicstack.dev` tea login.
-
-## Findings
-
-- Reproduced the failure from `/src/uconnect-worktrees/t_39ce717c-authentik-smoke-gate` with the current `pr-metadata.sh`:
-  - PR #1905 returned JSON with `number=null`, `baseRefName=""`, `headRefName=""`.
-  - PR #1908 returned JSON with `number=null`, `baseRefName=""`, `headRefName=""`.
-- Root cause: the wrapper treated HTTP/API error payloads as PR payloads and normalized missing fields to empty strings.
-- The credential loader can return a non-working `git.uscllc.com` API token in this environment, while host-specific `~/.git-credentials` basic auth succeeds. The wrapper now falls back by host before normalization.
-- `tea login list` has only `git.mosaicstack.dev` configured here; `pr-merge.sh` previously forced `--login mosaicstack`, which is invalid for `git.uscllc.com` and caused `Login name mosaicstack does not exist`.
-
-## Changes
-
-- `packages/mosaic/framework/tools/git/detect-platform.sh`
-  - Added `get_gitea_basic_auth <host>` to retrieve host-specific HTTPS credentials from `~/.git-credentials` without printing secrets.
-- `packages/mosaic/framework/tools/git/pr-metadata.sh`
-  - Uses strict bash mode.
-  - Checks Gitea HTTP status and fails nonzero on API errors/non-JSON instead of emitting empty branch fields.
-  - Falls back from token auth to host-specific basic auth.
-  - Normalizes standard `head.ref`/`base.ref` and fallback branch fields.
-  - Requires non-empty `headRefName` and `baseRefName`.
-  - Preserves GitHub `gh pr view` behavior.
-- `packages/mosaic/framework/tools/git/pr-merge.sh`
-  - Reads metadata once for base-branch policy preflight.
-  - Selects a `tea` login only when its configured URL matches the repo host.
-  - Falls back to authenticated Gitea merge API when no matching `tea` login exists, avoiding the wrong `mosaicstack` login for USC repos.
-  - Keeps squash-only and main-only merge policy.
-- `packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh`
-  - Added fixture-based regression harness for standard Gitea fields, fallback branch fields, `refs/pull/<n>/head` plus `head.label` normalization, and API error payloads.
-
-## Documentation / changelog note
-
-This repository currently has no root `CHANGELOG.md`; the scratchpad and `docs/TASKS.md` carry the task-level change record for this wrapper fix.
-
-## Verification log
-
-- Red regression check: copied the new `test-pr-metadata-gitea.sh` harness next to `origin/main` wrapper scripts and ran it with `MOSAIC_TEST_WORK_DIR=$PWD/.mosaic-test-work/pr-metadata-gitea-red`; it failed as expected with `headRefName=''` and `baseRefName=''` on the fixture API-error path.
-- `bash -n packages/mosaic/framework/tools/git/{detect-platform.sh,pr-metadata.sh,pr-merge.sh,test-pr-metadata-gitea.sh}`: passed.
-- `shellcheck -x -P . -e SC1090 packages/mosaic/framework/tools/git/{detect-platform.sh,pr-metadata.sh,pr-merge.sh,test-pr-metadata-gitea.sh}`: passed.
-- `MOSAIC_TEST_WORK_DIR=$PWD/.mosaic-test-work/pr-metadata-gitea packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh`: passed; verifies standard Gitea fields, fallback branch fields, `refs/pull/<n>/head` label normalization, and nonzero API-error handling.
-- Installed wrapper parity: `/home/hermes/.config/mosaic/tools/git/{detect-platform.sh,pr-metadata.sh,pr-merge.sh}` byte-match the PR source copies after validation, so active U-Connect wrapper invocations use the same fix while source PR review runs.
-- Live sanitized U-Connect metadata from `/src/uconnect` with `MOSAIC_CREDENTIALS_FILE=/src/jarvis-brain/credentials.json`:
-  - PR #1905: `number=1905`, `baseRefName=main`, `headRefName=edith/t_39ce717c-authentik-smoke-gate`, `state=open`, `host=git.uscllc.com`.
-  - PR #1908: `number=1908`, `baseRefName=main`, `headRefName=fix/t_23fa9e1d-portal-health-backend`, `state=closed`, `host=git.uscllc.com`.
-- Merge preflight dry runs from installed wrappers:
-  - PR #1905: `Dry run: would merge PR #1905 on git.uscllc.com with authenticated Gitea API fallback (base=main, method=squash).`
-  - PR #1908: `Dry run: would merge PR #1908 on git.uscllc.com with authenticated Gitea API fallback (base=main, method=squash).`
-- PR: `https://git.mosaicstack.dev/mosaicstack/stack/pulls/518`, branch `fix/t-a292e96f-gitea-pr-metadata`.
-- CI: Recent PR/push pipelines failed before clone/test execution due Woodpecker/Kubernetes PVC API timeout: `dial tcp 10.43.0.1:443: i/o timeout`. No repository test step executed in CI; local targeted verification above remains clean.
-
-## 2026-06-18 — PR #549 functional blocker remediation
-
-### Assignment
-
-Coordinator `mos-claude` assigned remediation for PR #549: fix `packages/mosaic/framework/tools/git/pr-metadata.sh` tmpfile cleanup where an `EXIT` trap references function-local `body_file` after the function returns inside `RAW=$(...)`, producing `body_file: unbound variable` on the authenticated success path and failing to clean up safely on early `set -e` exits.
-
-### Plan
-
-1. Add a non-vacuous Gitea test that exercises `curl_gitea_pull` with stubbed `curl` and `GITEA_TOKEN` instead of `MOSAIC_GITEA_PR_METADATA_RAW_FILE`.
-2. Prove the new test is RED against the current PR head.
-3. Replace the function-local `EXIT` cleanup with robust function-scoped tmpfile cleanup.
-4. Re-run targeted tests, `bash -n`, and review gates; commit and push branch only. Do not merge.
-
-### Constraints / assumptions
-
-- Do not modify prior injection/JSON fixes in `issue-edit`, `issue-assign`, or `milestone-create`.
-- Worker role: do not modify `docs/TASKS.md`; orchestrator remains the single writer.
-- Budget: no explicit token cap provided; keep scope to shell wrapper + targeted regression harness.
-
-### Remediation results
-
-- Rebased `fix/tooling-eval-injection-jq-json` onto `origin/main`; branch was already current.
-- Added a curl-stub regression path that does not use `MOSAIC_GITEA_PR_METADATA_RAW_FILE`, so it exercises `curl_gitea_pull` and its temp body file.
-- RED evidence: copied the new harness next to the pre-fix `HEAD` version of `pr-metadata.sh`; `MOSAIC_TEST_WORK_DIR=$PWD/.mosaic-test-work/pr-metadata-red-work .../test-pr-metadata-gitea.sh` failed with `body_file: unbound variable` on the curl success path.
-- Fix: replaced `EXIT` temp-file cleanup with a `RETURN`-scoped cleanup function that removes the body file while the function-local variable is still in scope, preserves the original return status, and clears the `RETURN` trap.
-- GREEN evidence:
-  - `MOSAIC_TEST_WORK_DIR=$PWD/.mosaic-test-work/pr-metadata-gitea-current packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh` passed.
-  - `bash -n packages/mosaic/framework/tools/git/pr-metadata.sh packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh` passed.
-  - `shellcheck -x -P . -e SC1090 packages/mosaic/framework/tools/git/pr-metadata.sh packages/mosaic/framework/tools/git/test-pr-metadata-gitea.sh` passed.
-
-### Review remediation
-
-- Codex review returned one should-fix: the early-exit test used `chmod 000`, which is not root-safe in container CI.
-- Remediation: changed the stubbed 2xx/cat-failure mode to replace the curl output with a broken symlink, which fails deterministically even as root and still validates cleanup via `rm -f -- "$body_file"`.
-
-### Second review remediation
-
-- Codex review found the 2xx `cat "$body_file"` read could be masked under command substitution semantics because the branch returned 0 unconditionally.
-- Remediation: both authenticated 2xx branches now use `cat "$body_file" || return $?` before returning success.
-- Strengthened the broken-symlink test to require the body-read failure and reject the later `Gitea API returned non-JSON` parse-failure path, so the test verifies the helper-level failure propagation rather than eventual downstream failure.
-
-### Final review gate
-
-- Codex review after remediation: approved (`0 blockers, 0 should-fix, 0 suggestions`).

docs/scratchpads/t_301e4e3b-pr-merge-gitea-empty-uid.md

@@ -1,31 +0,0 @@
-# Scratchpad: t_301e4e3b pr-merge.sh Gitea empty-uid fallback
-
-## Task
-
-Implement a narrow hardening in `packages/mosaic/framework/tools/git/pr-merge.sh` so Gitea merges recover from the known non-interactive `tea pr merge` identity failure: `user does not exist [uid: 0, name: ]`.
-
-## Constraints
-
-- Preserve Mosaic policy gates: squash-only, base branch `main`, queue guard unless explicitly skipped.
-- Preserve the existing authenticated Gitea API fallback when no tea login exists.
-- Do not fallback on arbitrary tea failures.
-- Do not expose tokens or credential-bearing remotes.
-- Scope is limited to the merge wrapper plus focused test/support/scratchpad files.
-
-## External issue
-
-- Gitea issue #520: Harden pr-merge.sh Gitea empty-uid fallback
-
-## Plan
-
-1. Add a focused shell regression harness with mocked `tea` and `curl` proving the known empty uid/name failure must fall back to Gitea API.
-2. Watch the harness fail on current code.
-3. Implement helper functions in `pr-merge.sh` for redacted command display, known failure classification, and authenticated Gitea API merge fallback.
-4. Keep unknown `tea` failures blocking by replaying stderr and exiting non-zero.
-5. Run syntax, shellcheck if available, focused regression, and repo quality gates before push/PR.
-
-## Session log
-
-- 2026-05-22: Read Kanban context, Mosaic global/repo instructions, created isolated branch `fix/t_301e4e3b-pr-merge-gitea-empty-uid`, and opened Gitea issue #520 using the Mosaic issue wrapper/API fallback.
-- 2026-05-22: Added regression harness and watched it fail on current behavior with `user does not exist [uid: 0, name: ]`; implemented narrow fallback and verified known-empty-identity fallback, arbitrary tea failure blocking, and no-tea-login API fallback paths.
-- 2026-05-22: Validation passed for `bash -n`, `shellcheck -x`, focused shell harness, `pnpm typecheck`, `pnpm lint`, `pnpm format:check`, and `pnpm --filter @mosaicstack/mosaic test`. Full `pnpm test` exposed an out-of-scope gateway DB setup failure (`relation "messages" does not exist`) in `apps/gateway/src/__tests__/cross-user-isolation.test.ts`.

docs/scratchpads/t_5aab9cc8-pr-merge-eval-injection.md

@@ -1,48 +0,0 @@
-# t_5aab9cc8 — pr-merge.sh eval injection remediation
-
-## Objective
-
-Remediate PR #521 review blocker: `packages/mosaic/framework/tools/git/pr-merge.sh` must reject non-numeric PR numbers before metadata lookup/merge and must not use `eval` for GitHub merge execution.
-
-## Scope
-
-- Shell wrapper only: `packages/mosaic/framework/tools/git/pr-merge.sh`
-- Focused regression harness: `packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh`
-- No API/frontend/infra surfaces.
-
-## Acceptance Criteria
-
-- AC1: `PR_NUMBER` is validated as digits-only immediately after required-argument parsing, before metadata lookup.
-- AC2: GitHub merge path uses a quoted argv array, not command-string construction plus `eval`.
-- AC3: Focused tests prove PR-number metacharacters are rejected and cannot execute injected shell commands on GitHub path.
-- AC4: Focused tests prove PR-number metacharacters are rejected on Gitea path before tea/curl merge calls.
-- AC5: Existing Gitea empty-uid fallback behavior remains green.
-- AC6: Syntax, shellcheck where available, focused harness, and relevant repo gates are rerun or absence documented.
-
-## Plan
-
-1. Add failing regression tests for GitHub eval injection and Gitea invalid PR rejection.
-2. Implement fail-closed PR number validation before metadata lookup.
-3. Replace GitHub `eval` command with argv array execution.
-4. Run required validation and update this scratchpad with evidence.
-5. Commit, queue-guard, push branch, update PR #521.
-
-## TDD Log
-
-- RED: `AGENT_WORK_ROOT="$HERMES_KANBAN_WORKSPACE/work" bash packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh` failed on vulnerable code with `Expected GitHub metacharacter PR number to be rejected` and showed the injected PR number reached the GitHub merge path.
-- GREEN: Added digits-only validation before metadata lookup and replaced GitHub `eval` with an argv array. The focused harness now passes and verifies invalid PR numbers are rejected before GitHub `gh` calls and before Gitea `tea`/`curl` calls.
-
-## Validation Evidence
-
-- PASS: `AGENT_WORK_ROOT="$HERMES_KANBAN_WORKSPACE/work" bash -n packages/mosaic/framework/tools/git/pr-merge.sh packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh`
-- PASS: `shellcheck -x packages/mosaic/framework/tools/git/pr-merge.sh packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh`
-- PASS: `AGENT_WORK_ROOT="$HERMES_KANBAN_WORKSPACE/work" bash packages/mosaic/framework/tools/git/test-pr-merge-gitea-empty-uid.sh`
-- PASS: `pnpm --filter @mosaicstack/mosaic... build`
-- PASS: `pnpm --filter @mosaicstack/mosaic lint`
-- PASS: `pnpm --filter @mosaicstack/mosaic typecheck`
-- PASS: `pnpm --filter @mosaicstack/mosaic test` — 32 files / 291 tests passed.
-- REVIEW: `/home/hermes/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted` could not run due Codex 401 Unauthorized. Independent delegate review completed read-only with PASS / no blockers; non-blocking suggestion to assert GitHub mock log remains empty was applied.
-
-## Risks / Blockers
-
-- No active blockers.

docs/tasks/544-agent-reflection-loop.md

@@ -1,67 +0,0 @@
-# 544: Agent Reflection Loop — durable kernel
-
-**Issue:** [#544](http://git.mosaicstack.dev/mosaicstack/stack/issues/544)
-**PRD:** [`docs/plans/agent-reflection-loop-PRD.md`](../plans/agent-reflection-loop-PRD.md)
-**Branch:** `feat/agent-reflection-loop`
-
-## Context
-
-Build the **durable kernel** of the agent reflection loop: passive end-of-run
-capture of the doer's end-state as structured `reflection.v1` data, plus a
-deterministic diff **review risk-floor**. The closed calibration / skill-synthesis
-loop (design §7–§8) stays **gated** behind Phase-0 experiments P1/P2/P3 and is
-explicitly out of scope here. Source design: jarvis-brain
-`docs/planning/AGENT-REFLECTION-LOOP.md` (debate-hardened v2).
-
-Scope rule, non-goals, the full `reflection.v1` field list, and acceptance
-criteria live in the PRD. This file is the task breakdown + status.
-
-## Work items
-
-| #   | Item                                                  | Path                                                      | Status |
-| --- | ----------------------------------------------------- | --------------------------------------------------------- | ------ |
-| 1   | Diff risk-floor (pure, deterministic) + unit tests    | `packages/macp/src/risk-floor.ts`, `risk-floor.spec.ts`   | done   |
-| 2   | `reflection.v1` JSON Schema (documented contract)     | `packages/macp/src/schemas/reflection.v1.schema.json`     | done   |
-| 3   | `reflection.v1` zod schemas + self-report DTO + tests | `packages/types/src/reflection/*`                         | done   |
-| 4   | Stop hook (fail-closed capture)                       | `packages/mosaic/framework/tools/qa/reflect-stop-hook.sh` | done   |
-| 5   | Hook registration (`hooks.Stop`)                      | `packages/mosaic/framework/runtime/claude/settings.json`  | done   |
-| 6   | Phase-0 experiment harnesses (P1/P2/P3)               | `scripts/analysis/reflect-*.sh`                           | done   |
-
-## Design decisions (this implementation)
-
-- **Mechanical vs self-reported split.** A bash Stop hook cannot author the
-  agent's self-assessment, so it writes the mechanical fields (risk-floor verdict,
-  `files_changed`, ids, provenance) and merges an optional agent-supplied
-  `$REFLECTION_INPUT` self-report; absent/unreadable ⇒ those fields `null` and
-  `provenance.degraded = true`.
-- **Risk-floor authority.** `evaluateRiskFloor` (TS, tested) is the source of
-  truth. The hook ports the same surface table inline to avoid a node/build
-  dependency on the hook path; the two are documented as kept in sync.
-- **Hook registration deviation.** `settings-overlays/` has no merge mechanism
-  (docs-only), so a hooks overlay there would be inert. The Stop hook is
-  registered in the canonical `runtime/claude/settings.json` — the same file the
-  `mosaic` launcher reflects into `~/.claude/settings.json`. Still vendored in-repo.
-- **DTO without class-transformer.** `reflection.dto.ts` uses class-validator only
-  (no `@Type`), matching `chat.dto.ts`, so the module imports without a
-  `reflect-metadata` shim in the types-package test env. Deep nested validation is
-  owned by the zod `ReflectionSelfReportSchema` (the runtime authority the hook uses).
-- **`.mosaic/` excluded** from the change surface — it is agent scratch
-  (reflections, locks, self-report input), not part of the diff under review.
-
-## Verification
-
-- `pnpm --filter @mosaicstack/macp test` → 88 passed (15 new risk-floor).
-- `pnpm --filter @mosaicstack/types test` → 64 passed (10 new reflection).
-- Root `pnpm typecheck`, `pnpm lint`, `pnpm format:check`, `pnpm build` → green.
-- Stop hook smoke: fail-closed no-op (mode unset), solo capture (degraded),
-  self-report merge (degraded=false), re-fire lock guard — all pass.
-- All bash (hook + 3 Phase-0 scripts) shellcheck-clean; Phase-0 scripts emit
-  structured JSON/markdown and print their pre-registered kill conditions.
-
-## Activation (post-merge, deployment concern — not a blocker)
-
-The Stop hook only activates when a launcher/profile sets
-`REFLECTION_MODE=solo|orchestrated`; unset/`off` is a strict no-op, so global
-registration is safe. `framework/install.sh` rsyncs the hook into
-`~/.config/mosaic/tools/qa/`, and the `mosaic` launcher reflects the updated
-`settings.json` (`hooks.Stop`) into `~/.claude/settings.json`.

guides/BOOTSTRAP.md

@@ -453,26 +453,6 @@ Initialize standard labels and the first pre-MVP milestone:
 
 ---
 
-## Secrets Bootstrap (Required for Every New App)
-
-Every new application MUST complete the following secrets bootstrap before deploying to any non-local environment. This is a hard gate — deployment without completed secrets bootstrap is forbidden.
-
-### Secrets bootstrap checklist
-
-- [ ] Vault path created: `vault kv put secret/k3s/<app>/ ...` with all required secret fields
-- [ ] Required secrets listed in project README under a "Secrets architecture" section, including:
-  - Vault path(s) used
-  - All required secret keys and their purpose
-  - Whether the app uses ESO bridge (default) or Direct-Vault (opt-in, with justification)
-- [ ] `external-secret.yaml` manifest committed to repo's `deploy/` or `k8s/` directory
-- [ ] Deployment YAML references the synced k8s Secret via `secretKeyRef` (not raw env vars or `.env` files)
-- [ ] App startup has schema-based validation for all required env vars (zod / pydantic / envconfig equivalent) that exits non-zero on missing required values
-- [ ] Direct-Vault opt-in (if applicable): justification documented in README + AppRole provisioned + bootstrap credentials stored in Vault and synced via a separate `ExternalSecret`
-
-See `~/.config/mosaic/guides/VAULT-SECRETS.md` for full worked examples of the ESO bridge pattern, the Direct-Vault opt-in pattern, and the forbidden antipatterns.
-
----
-
 ## Checklist
 
 After bootstrapping, verify:

guides/VAULT-SECRETS.md

@@ -203,374 +203,3 @@ Error: token expired
 3. **Audit logging** - All access is logged; act accordingly
 4. **No local copies** - Don't store secrets in files or env vars long-term
 5. **Rotate on compromise** - Immediately rotate any exposed secrets
-
----
-
-## Secrets Architecture Decision Matrix
-
-Use this table to choose between the ESO bridge (default) and Direct-Vault (opt-in) patterns for every new app or integration.
-
-| Factor                      | ESO Bridge (default)                                                          | Direct-Vault (opt-in)                                                                                                   |
-| --------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| **Use-case**                | All static secrets (DB creds, API keys, signing keys, OAuth secrets)          | Dynamic creds with short TTLs (DB rotation, AWS STS, PKI), per-request audit trails, or lease renewal mid-pod-lifecycle |
-| **App code change**         | None — reads standard env vars via `secretKeyRef`                             | Requires Vault client (`hvac`, `node-vault`, `vault/api`) in application code                                           |
-| **Secret rotation**         | ESO re-syncs on Vault write; pod restart or secret refresh picks up new value | App manages lease renewal or re-auth within the running process                                                         |
-| **Audit granularity**       | Access logged at Vault when ESO syncs; no per-request app audit               | Every app request to Vault is a separate audit log entry                                                                |
-| **Operational burden**      | Low — ESO handles polling, sync, and k8s Secret lifecycle                     | Higher — app must handle auth, lease renewal, error paths, and token rotation                                           |
-| **Justification required?** | No — this is the default                                                      | Yes — document in project README under "Secrets architecture"                                                           |
-| **Example use cases**       | Web app DB password, OAuth client secret, JWT signing key, API token          | HashiCorp DB secrets engine with 15-min TTL leases, AWS STS assume-role, Vault PKI short-lived certs                    |
-
-**Decision rule:** If you are unsure, use ESO. Only justify Direct-Vault when the secret cannot be safely stored in a k8s Secret (too short-lived, per-request TTL required, or mid-lifecycle renewal needed).
-
----
-
-## ESO Bridge Pattern (Default)
-
-This is the required default for all k8s workloads. Follow this exact pattern unless a documented dynamic-secrets requirement justifies Direct-Vault.
-
-### 1. Provision Vault path
-
-```bash
-# Write the secrets for the app (run once; use IaC/Terraform for repeatable provisioning)
-vault kv put secret/k3s/<app> \
-  db_password="..." \
-  api_key="..." \
-  jwt_secret="..."
-```
-
-Use the canonical path structure: `secret/k3s/<app>` for k3s cluster workloads.
-
-### 2. ExternalSecret manifest
-
-Commit this to the repo's `deploy/` or `k8s/` directory:
-
-```yaml
-# deploy/external-secret.yaml
-apiVersion: external-secrets.io/v1beta1
-kind: ExternalSecret
-metadata:
-  name: <app>-secrets
-  namespace: <namespace>
-spec:
-  refreshInterval: 1h
-  secretStoreRef:
-    name: vault-backend # ClusterSecretStore name — verify with cluster admin
-    kind: ClusterSecretStore
-  target:
-    name: <app>-secrets # k8s Secret name that will be created
-    creationPolicy: Owner
-  data:
-    - secretKey: DB_PASSWORD # key in the k8s Secret
-      remoteRef:
-        key: secret/k3s/<app> # Vault path
-        property: db_password # field within the Vault secret
-    - secretKey: API_KEY
-      remoteRef:
-        key: secret/k3s/<app>
-        property: api_key
-    - secretKey: JWT_SECRET
-      remoteRef:
-        key: secret/k3s/<app>
-        property: jwt_secret
-```
-
-### 3. Deployment manifest — reference synced k8s Secret
-
-```yaml
-# deploy/deployment.yaml (env section)
-env:
-  - name: DB_PASSWORD
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets # matches ExternalSecret target.name
-        key: DB_PASSWORD
-  - name: API_KEY
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets
-        key: API_KEY
-  - name: JWT_SECRET
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets
-        key: JWT_SECRET
-  - name: PORT
-    value: '3000' # safe-default: non-secret, no Vault needed
-```
-
-### 4. App-side schema validation — TypeScript (zod)
-
-Validate all required env vars at startup. Exit non-zero on missing values.
-
-```typescript
-// src/env.ts
-import { z } from 'zod';
-
-const envSchema = z.object({
-  DB_PASSWORD: z.string().min(1, 'DB_PASSWORD is required'),
-  API_KEY: z.string().min(1, 'API_KEY is required'),
-  JWT_SECRET: z.string().min(32, 'JWT_SECRET must be at least 32 chars'),
-  PORT: z.coerce.number().default(3000),
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('production'),
-});
-
-const result = envSchema.safeParse(process.env);
-if (!result.success) {
-  console.error('Missing or invalid environment variables:');
-  console.error(result.error.flatten().fieldErrors);
-  process.exit(1);
-}
-
-export const env = result.data;
-```
-
-### 4b. App-side schema validation — Python (pydantic)
-
-```python
-# src/config.py
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-class Settings(BaseSettings):
-    db_password: str
-    api_key: str
-    jwt_secret: str
-    port: int = 3000
-    node_env: str = "production"
-
-    model_config = SettingsConfigDict(env_file=None)  # no .env in prod
-
-try:
-    settings = Settings()
-except Exception as e:
-    import sys
-    print(f"Missing or invalid environment variables: {e}", file=sys.stderr)
-    sys.exit(1)
-```
-
-### 4c. App-side schema validation — Go (envconfig)
-
-```go
-// config/config.go
-package config
-
-import (
-    "fmt"
-    "github.com/kelseyhightower/envconfig"
-)
-
-type Config struct {
-    DBPassword string `envconfig:"DB_PASSWORD" required:"true"`
-    APIKey     string `envconfig:"API_KEY" required:"true"`
-    JWTSecret  string `envconfig:"JWT_SECRET" required:"true"`
-    Port       int    `envconfig:"PORT" default:"3000"`
-}
-
-func Load() (*Config, error) {
-    var cfg Config
-    if err := envconfig.Process("", &cfg); err != nil {
-        return nil, fmt.Errorf("invalid environment: %w", err)
-    }
-    return &cfg, nil
-}
-```
-
-In your `main.go`:
-
-```go
-cfg, err := config.Load()
-if err != nil {
-    fmt.Fprintln(os.Stderr, err)
-    os.Exit(1)
-}
-```
-
----
-
-## Direct-Vault Opt-In Pattern
-
-Use this pattern ONLY when a documented dynamic-secrets requirement applies (DB rotation with short TTLs, AWS STS, PKI, per-request audit). Document the justification in the project README under "Secrets architecture" before implementing.
-
-### When it is justified
-
-- Vault DB secrets engine with lease TTLs shorter than a typical pod lifecycle (< 1 hour)
-- AWS STS assume-role tokens generated per-request
-- Vault PKI short-lived certificates (< 24 hours) that must be renewed within a running pod
-- Per-request audit trail requirement (each app call must appear separately in Vault audit log)
-
-### Provision an AppRole for the app
-
-```bash
-# Enable AppRole auth (if not already enabled)
-vault auth enable approle
-
-# Create a Vault policy for the app
-# Note: KV v2 paths require both the exact path (for the top-level secret) and the
-# wildcard (for sub-paths). Always include both to avoid permission denied errors.
-vault policy write <app>-policy - <<EOF
-path "secret/data/k3s/<app>" {
-  capabilities = ["read"]
-}
-path "secret/data/k3s/<app>/*" {
-  capabilities = ["read"]
-}
-path "database/creds/<app>-role" {
-  capabilities = ["read"]
-}
-EOF
-
-# Create the AppRole
-vault write auth/approle/role/<app>-role \
-  token_policies="<app>-policy" \
-  token_ttl=1h \
-  token_max_ttl=4h \
-  secret_id_ttl=0
-
-# Retrieve role-id and secret-id
-vault read auth/approle/role/<app>-role/role-id
-vault write -f auth/approle/role/<app>-role/secret-id
-```
-
-### Bootstrap AppRole credentials via ESO (solving the chicken-and-egg problem)
-
-The AppRole `role-id` and `secret-id` are themselves secrets. Store them in Vault at a bootstrap path, then use ESO to sync them into a k8s Secret. The app reads that k8s Secret at startup to authenticate with Vault directly.
-
-```bash
-# Store the bootstrap credentials in Vault
-vault kv put secret/k3s/<app>-bootstrap \
-  role_id="<role-id>" \
-  secret_id="<secret-id>"
-```
-
-```yaml
-# deploy/external-secret-bootstrap.yaml
-apiVersion: external-secrets.io/v1beta1
-kind: ExternalSecret
-metadata:
-  name: <app>-vault-auth
-  namespace: <namespace>
-spec:
-  refreshInterval: 24h
-  secretStoreRef:
-    name: vault-backend
-    kind: ClusterSecretStore
-  target:
-    name: <app>-vault-auth
-    creationPolicy: Owner
-  data:
-    - secretKey: VAULT_ROLE_ID
-      remoteRef:
-        key: secret/k3s/<app>-bootstrap
-        property: role_id
-    - secretKey: VAULT_SECRET_ID
-      remoteRef:
-        key: secret/k3s/<app>-bootstrap
-        property: secret_id
-```
-
-```yaml
-# deploy/deployment.yaml (env section for Direct-Vault app)
-env:
-  - name: VAULT_ADDR
-    value: 'https://vault.example.com' # safe-default: non-secret cluster address
-  - name: VAULT_ROLE_ID
-    valueFrom:
-      secretKeyRef:
-        name: <app>-vault-auth
-        key: VAULT_ROLE_ID
-  - name: VAULT_SECRET_ID
-    valueFrom:
-      secretKeyRef:
-        name: <app>-vault-auth
-        key: VAULT_SECRET_ID
-```
-
-### App-side Vault client pattern
-
-```typescript
-// src/vault-client.ts — only exists in Direct-Vault apps
-import vault from 'node-vault';
-import { z } from 'zod';
-
-const bootstrapSchema = z.object({
-  VAULT_ADDR: z.string().url(),
-  VAULT_ROLE_ID: z.string().min(1),
-  VAULT_SECRET_ID: z.string().min(1),
-});
-
-const bootstrap = bootstrapSchema.parse(process.env);
-
-const client = vault({ endpoint: bootstrap.VAULT_ADDR });
-
-export async function getVaultClient() {
-  const { auth } = await client.approleLogin({
-    role_id: bootstrap.VAULT_ROLE_ID,
-    secret_id: bootstrap.VAULT_SECRET_ID,
-  });
-  client.token = auth.client_token;
-  return client;
-}
-```
-
-Document in README under "Secrets architecture": the Vault path, why Direct-Vault is required, and the lease/renewal strategy.
-
----
-
-## Forbidden Patterns (CI Lint Targets)
-
-The following patterns are forbidden in all Mosaic projects. CI lint SHOULD catch these automatically (implementation tracked separately). Agents MUST NOT introduce these patterns.
-
-### 1. Untagged fallback defaults for required values
-
-```yaml
-# FORBIDDEN — required secret with silent fallback
-environment:
-  - DB_PASSWORD=${DB_PASSWORD:-changeme}
-  - API_KEY=${API_KEY:-}
-
-# REQUIRED — fast-fail on missing required values
-environment:
-  - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD is required}
-  - API_KEY=${API_KEY:?API_KEY is required}
-
-# ALLOWED — true convenience default, tagged
-environment:
-  - PORT=${PORT:-3000}  # safe-default: non-secret, app works at any port
-```
-
-This applies to: `docker-compose.yml`, k8s manifests, Helm `values.yaml`, any env file committed to git.
-
-### 2. Vault KV calls in application source code (ESO-default projects)
-
-```python
-# FORBIDDEN in ESO-default apps — direct Vault client in app source
-import hvac
-client = hvac.Client(url=os.environ['VAULT_ADDR'])
-secret = client.secrets.kv.v2.read_secret_version(path='myapp/db')
-```
-
-ESO-default apps read env vars only. Direct-Vault clients belong only in apps with a documented dynamic-secrets justification in README.
-
-### 3. Hardcoded secrets or API keys in committed files
-
-```python
-# FORBIDDEN — hardcoded credential
-DB_PASSWORD = "supersecret123"
-API_KEY = "sk-live-abc123"
-```
-
-No exceptions. CI lint must flag any string matching common secret patterns (`password`, `secret`, `api_key`, `token` assigned a literal non-env-var value).
-
-### 4. `.env` files in production deployment paths
-
-```
-# FORBIDDEN — .env file in a production deploy path
-deploy/.env
-k8s/.env
-docker/.env
-
-# ALLOWED — local dev only
-.env.example          # template only, no real values
-.env                  # local dev, must be in .gitignore
-```
-
-`.env` files are acceptable in local-dev contexts only and MUST be in `.gitignore`. They are forbidden in any path that a CI pipeline or production deployment process reads directly.

packages/appservice/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@mosaicstack/appservice",
-  "version": "0.0.1",
-  "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "https://git.mosaicstack.dev/mosaicstack/stack.git",
-    "directory": "packages/appservice"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "lint": "eslint src",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run --passWithNoTests"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "typescript": "^5.8.0",
-    "vitest": "^2.0.0"
-  },
-  "publishConfig": {
-    "registry": "https://git.mosaicstack.dev/api/packages/mosaicstack/npm/",
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ]
-}

packages/appservice/src/__tests__/agent-store.test.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { AGENTS_ACCOUNT_DATA_TYPE, AgentTokenStore } from '../agent-store.js';
-import type { AppserviceIntent } from '../intent.js';
-
-/** Fake intent: in-memory account_data, no-op user provisioning. Only the
- * surface AgentTokenStore touches is implemented. */
-const makeFakeIntent = () => {
-  const store: Record<string, Record<string, unknown>> = {};
-  const fake = {
-    domain: 'hs.example',
-    getSenderAccountData: async (type: string): Promise<Record<string, unknown> | null> =>
-      store[type] ?? null,
-    setSenderAccountData: async (type: string, content: Record<string, unknown>): Promise<void> => {
-      store[type] = structuredClone(content);
-    },
-    ensureRegistered: async (agent: string): Promise<string> => `@agent-${agent}:hs.example`,
-    setDisplayName: async (): Promise<void> => {},
-  };
-  return { intent: fake as unknown as AppserviceIntent, store };
-};
-
-describe('AgentTokenStore', () => {
-  it('mints a magt_ token and stores only its sha256 (never plaintext)', async () => {
-    const { intent, store } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    const { agentUserId, token } = await s.register({ alias: 'pi0', host: 'web1' });
-
-    expect(agentUserId).toBe('@agent-pi0-web1:hs.example');
-    expect(token.startsWith('magt_')).toBe(true);
-
-    const raw = JSON.stringify(store[AGENTS_ACCOUNT_DATA_TYPE]);
-    expect(raw).not.toContain(token);
-    // The stored hash is sha256hex(token), 64 hex chars.
-    const { createHash } = await import('node:crypto');
-    const hash = createHash('sha256').update(token).digest('hex');
-    expect(raw).toContain(hash);
-  });
-
-  it('verifyToken returns the agentUserId for a fresh token, null otherwise', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    const { agentUserId, token } = await s.register({ alias: 'pi0', host: 'web1' });
-
-    expect(await s.verifyToken(token)).toBe(agentUserId);
-    expect(await s.verifyToken('magt_garbage')).toBeNull();
-    expect(await s.verifyToken('not-a-token')).toBeNull();
-    expect(await s.verifyToken('')).toBeNull();
-  });
-
-  it('revoke invalidates tokens, returns count, and hides agent from list', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    const { agentUserId, token } = await s.register({ alias: 'pi0', host: 'web1' });
-
-    expect((await s.list()).map((a) => a.agent_user_id)).toContain(agentUserId);
-
-    const count = await s.revoke(agentUserId);
-    expect(count).toBe(1);
-    expect(await s.verifyToken(token)).toBeNull();
-    expect((await s.list()).map((a) => a.agent_user_id)).not.toContain(agentUserId);
-
-    // Idempotent on unknown / already-revoked.
-    expect(await s.revoke(agentUserId)).toBe(0);
-    expect(await s.revoke('@agent-nope:hs.example')).toBe(0);
-  });
-
-  it('re-register after revoke yields a working token and the agent reappears', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    const { agentUserId, token: t1 } = await s.register({ alias: 'pi0', host: 'web1' });
-    await s.revoke(agentUserId);
-
-    const { token: t2 } = await s.register({ alias: 'pi0', host: 'web1' });
-    expect(await s.verifyToken(t1)).toBeNull();
-    expect(await s.verifyToken(t2)).toBe(agentUserId);
-    expect((await s.list()).map((a) => a.agent_user_id)).toContain(agentUserId);
-  });
-
-  it('agent A token never verifies as agent B', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    const a = await s.register({ alias: 'pi0', host: 'web1' });
-    const b = await s.register({ alias: 'pi1', host: 'web2' });
-
-    expect(await s.verifyToken(a.token)).toBe(a.agentUserId);
-    expect(await s.verifyToken(b.token)).toBe(b.agentUserId);
-    expect(a.agentUserId).not.toBe(b.agentUserId);
-  });
-
-  it('rejects an ambiguous re-registration that collides on one Matrix id', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    // alias="a-b",host="c" and alias="a",host="b-c" both -> @agent-a-b-c.
-    const first = await s.register({ alias: 'a-b', host: 'c' });
-    expect(first.agentUserId).toBe('@agent-a-b-c:hs.example');
-
-    await expect(s.register({ alias: 'a', host: 'b-c' })).rejects.toThrow(/collision/);
-
-    // The original registration is untouched: still one active token, correct pair.
-    expect(await s.verifyToken(first.token)).toBe(first.agentUserId);
-    const summary = (await s.list()).find((x) => x.agent_user_id === first.agentUserId);
-    expect(summary?.alias).toBe('a-b');
-    expect(summary?.host).toBe('c');
-    expect(summary?.active_token_count).toBe(1);
-  });
-
-  it('display_name is stored and surfaced in list', async () => {
-    const { intent } = makeFakeIntent();
-    const s = new AgentTokenStore(intent);
-    await s.register({ alias: 'pi0', host: 'web1', displayName: 'Pi Zero' });
-    const summary = (await s.list())[0];
-    expect(summary?.display_name).toBe('Pi Zero');
-    expect(summary?.active_token_count).toBe(1);
-  });
-});

packages/appservice/src/__tests__/appservice.test.ts

@@ -1,230 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { validateBridgeMessage, validateBridgeTyping } from '../bridge.dto.js';
-import { AppserviceIntent, MatrixApiError } from '../intent.js';
-import { buildRegistration, registrationToYaml } from '../registration.js';
-import { TransactionHandler } from '../transactions.js';
-import type { AppserviceConfig, MatrixEvent } from '../types.js';
-
-const cfg: AppserviceConfig = {
-  homeserverUrl: 'https://hs.example',
-  domain: 'hs.example',
-  asToken: 'as-secret',
-  hsToken: 'hs-secret',
-};
-
-const jsonResponse = (status: number, body: unknown): Response =>
-  new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
-
-describe('TransactionHandler', () => {
-  const makeHandler = (onEvent = vi.fn()) => ({
-    onEvent,
-    handler: new TransactionHandler({ hsToken: 'hs-secret', onEvent }),
-  });
-
-  it('rejects a bad hs_token with M_FORBIDDEN', async () => {
-    const { handler, onEvent } = makeHandler();
-    const res = await handler.handle(
-      't1',
-      { events: [{ type: 'm.room.message' }] },
-      { authorizationHeader: 'Bearer wrong' },
-    );
-    expect(res.status).toBe(403);
-    expect(res.body.errcode).toBe('M_FORBIDDEN');
-    expect(onEvent).not.toHaveBeenCalled();
-  });
-
-  it('accepts Bearer auth and legacy access_token param', async () => {
-    const { handler } = makeHandler();
-    expect(
-      (await handler.handle('t1', { events: [] }, { authorizationHeader: 'Bearer hs-secret' }))
-        .status,
-    ).toBe(200);
-    expect(
-      (await handler.handle('t2', { events: [] }, { accessTokenParam: 'hs-secret' })).status,
-    ).toBe(200);
-  });
-
-  it('processes events once per txnId (idempotent retries)', async () => {
-    const { handler, onEvent } = makeHandler();
-    const body = { events: [{ type: 'm.room.message', event_id: '$e1' }] };
-    await handler.handle('t1', body, { authorizationHeader: 'Bearer hs-secret' });
-    const retry = await handler.handle('t1', body, { authorizationHeader: 'Bearer hs-secret' });
-    expect(retry.status).toBe(200);
-    expect(onEvent).toHaveBeenCalledTimes(1);
-  });
-
-  it('a throwing event handler does not fail the transaction', async () => {
-    const onError = vi.fn();
-    const handler = new TransactionHandler({
-      hsToken: 'hs-secret',
-      onEvent: () => {
-        throw new Error('boom');
-      },
-      onError,
-    });
-    const res = await handler.handle(
-      't1',
-      { events: [{ type: 'x' }, { type: 'y' }] },
-      { authorizationHeader: 'Bearer hs-secret' },
-    );
-    expect(res.status).toBe(200);
-    expect(onError).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('AppserviceIntent', () => {
-  it('derives namespaced user ids and rejects bad slugs', () => {
-    const intent = new AppserviceIntent(cfg);
-    expect(intent.agentUserId('pi0-web1')).toBe('@agent-pi0-web1:hs.example');
-    expect(intent.agentUserId('Pi0-Web1')).toBe('@agent-pi0-web1:hs.example');
-    expect(() => intent.agentUserId('../evil')).toThrow();
-    expect(() => intent.agentUserId('')).toThrow();
-  });
-
-  it('uses uuid transaction ids', async () => {
-    const calls: string[] = [];
-    const fetchMock = vi.fn(async (input: URL | string) => {
-      calls.push(new URL(String(input)).pathname);
-      return jsonResponse(200, {});
-    });
-    const intent = new AppserviceIntent(cfg, fetchMock as unknown as typeof fetch);
-    await intent.sendAsAgent({ roomId: '!r:hs.example', agent: 'pi0', body: 'x' });
-    const send = calls.find((p) => p.includes('/send/m.room.message/'));
-    expect(send).toMatch(/mosaic-as-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-  });
-
-  it('registers once, impersonates via user_id, threads replies', async () => {
-    const calls: Array<{ url: URL; init: RequestInit }> = [];
-    const fetchMock = vi.fn(async (input: URL | string, init?: RequestInit) => {
-      calls.push({ url: new URL(String(input)), init: init ?? {} });
-      return jsonResponse(200, { event_id: '$sent' });
-    });
-    const intent = new AppserviceIntent(cfg, fetchMock as unknown as typeof fetch);
-
-    const eventId = await intent.sendAsAgent({
-      roomId: '!room:hs.example',
-      agent: 'pi0-web1',
-      body: 'hello',
-      threadRoot: '$req',
-    });
-    await intent.sendAsAgent({ roomId: '!room:hs.example', agent: 'pi0-web1', body: 'again' });
-
-    expect(eventId).toBe('$sent');
-    const paths = calls.map((c) => c.url.pathname);
-    expect(paths.filter((p) => p.endsWith('/register'))).toHaveLength(1); // cached
-    expect(paths.filter((p) => p.includes('/join'))).toHaveLength(1); // cached
-
-    const send = calls.find((c) => c.url.pathname.includes('/send/m.room.message/'));
-    expect(send).toBeDefined();
-    expect(send!.url.searchParams.get('user_id')).toBe('@agent-pi0-web1:hs.example');
-    const content = JSON.parse(String(send!.init.body)) as Record<string, unknown>;
-    const rel = content['m.relates_to'] as Record<string, unknown>;
-    expect(rel.rel_type).toBe('m.thread');
-    expect(rel.event_id).toBe('$req');
-    expect(rel.is_falling_back).toBe(true);
-    expect(
-      calls.every(
-        (c) => (c.init.headers as Record<string, string>).Authorization === 'Bearer as-secret',
-      ),
-    ).toBe(true);
-  });
-
-  it('tolerates M_USER_IN_USE and surfaces other register errors', async () => {
-    const inUse = vi.fn(async () =>
-      jsonResponse(400, { errcode: 'M_USER_IN_USE', error: 'taken' }),
-    );
-    const intent = new AppserviceIntent(cfg, inUse as unknown as typeof fetch);
-    await expect(intent.ensureRegistered('pi0-web1')).resolves.toBe('@agent-pi0-web1:hs.example');
-
-    const denied = vi.fn(async () =>
-      jsonResponse(401, { errcode: 'M_UNKNOWN_TOKEN', error: 'nope' }),
-    );
-    const intent2 = new AppserviceIntent(cfg, denied as unknown as typeof fetch);
-    await expect(intent2.ensureRegistered('pi0-web1')).rejects.toThrow(MatrixApiError);
-  });
-
-  it('invites then joins on M_FORBIDDEN join', async () => {
-    const paths: string[] = [];
-    const fetchMock = vi.fn(async (input: URL | string) => {
-      const url = new URL(String(input));
-      paths.push(url.pathname);
-      if (url.pathname.endsWith('/join') && paths.filter((p) => p.endsWith('/join')).length === 1) {
-        return jsonResponse(403, { errcode: 'M_FORBIDDEN', error: 'not invited' });
-      }
-      return jsonResponse(200, {});
-    });
-    const intent = new AppserviceIntent(cfg, fetchMock as unknown as typeof fetch);
-    await intent.ensureJoined('!room:hs.example', 'pi0-web1');
-    expect(paths.filter((p) => p.endsWith('/invite'))).toHaveLength(1);
-    expect(paths.filter((p) => p.endsWith('/join'))).toHaveLength(2);
-  });
-});
-
-describe('registration', () => {
-  it('builds an exclusive escaped user namespace', () => {
-    const reg = buildRegistration(cfg, { url: 'http://mosaic-as:8008' });
-    expect(reg.namespaces.users[0]).toEqual({
-      regex: '@agent-.*:hs\\.example',
-      exclusive: true,
-    });
-    expect(reg.rate_limited).toBe(false);
-    const yaml = registrationToYaml(reg);
-    expect(yaml).toContain("sender_localpart: 'mosaic-as'");
-    expect(yaml).toContain("as_token: 'as-secret'");
-    expect(yaml).toContain('exclusive: true');
-  });
-});
-
-describe('registration hardening', () => {
-  it('rejects control characters in registration values', () => {
-    const reg = buildRegistration(
-      { ...cfg, asToken: 'abc\nhttp_injected: true' },
-      { url: 'http://mosaic-as:8008' },
-    );
-    expect(() => registrationToYaml(reg)).toThrow(/control characters/);
-  });
-
-  it('escapes single quotes in token values', () => {
-    const reg = buildRegistration({ ...cfg, asToken: "it's" }, { url: 'http://mosaic-as:8008' });
-    expect(registrationToYaml(reg)).toContain("as_token: 'it''s'");
-  });
-});
-
-describe('bridge DTOs', () => {
-  it('validates message and typing payloads', () => {
-    expect(() =>
-      validateBridgeMessage({ room_id: '!r:hs', agent: 'pi0', body: 'x' }),
-    ).not.toThrow();
-    expect(() => validateBridgeMessage({ room_id: 'bad', agent: 'pi0', body: 'x' })).toThrow();
-    expect(() => validateBridgeMessage({ room_id: '!r:hs', agent: '', body: 'x' })).toThrow();
-    expect(() => validateBridgeMessage({ room_id: '!r:hs', agent: '../evil', body: 'x' })).toThrow(
-      /agent must match/,
-    );
-    expect(() =>
-      validateBridgeTyping({ room_id: '!r:hs', agent: 'pi0', typing: true }),
-    ).not.toThrow();
-    expect(() => validateBridgeTyping({ room_id: '!r:hs', agent: 'pi0', typing: 'yes' })).toThrow();
-  });
-});
-
-describe('event shape', () => {
-  it('transaction events flow through to the handler', async () => {
-    const seen: MatrixEvent[] = [];
-    const handler = new TransactionHandler({
-      hsToken: 'hs-secret',
-      onEvent: (e) => void seen.push(e),
-    });
-    await handler.handle(
-      't1',
-      {
-        events: [
-          { type: 'm.room.message', room_id: '!r:hs', sender: '@u:hs', content: { body: 'hi' } },
-        ],
-      },
-      { authorizationHeader: 'Bearer hs-secret' },
-    );
-    expect(seen).toHaveLength(1);
-    expect(seen[0]!.content?.body).toBe('hi');
-  });
-});

packages/appservice/src/agent-registry.dto.ts

@@ -1,63 +0,0 @@
-/** DTOs for agent registration + scoped/revocable bridge tokens (US-007). */
-
-export interface RegisterAgentDto {
-  /** Agent alias slug, e.g. "pi0". Combined with host into the agent slug. */
-  alias: string;
-  /** Host slug, e.g. "web1". Combined with alias into the agent slug. */
-  host: string;
-  display_name?: string;
-}
-
-export interface RevokeAgentDto {
-  agent_user_id: string;
-}
-
-export interface RegisterAgentResponse {
-  agent_user_id: string;
-  bridge_token: string;
-}
-
-export interface AgentSummary {
-  agent_user_id: string;
-  alias: string;
-  host: string;
-  display_name?: string;
-  created_at: string;
-  active_token_count: number;
-}
-
-const SLUG_RE = /^[a-z0-9][a-z0-9_.-]*$/;
-
-/** Combined agent slug, e.g. alias="pi0", host="web1" -> "pi0-web1". */
-export function agentSlug(alias: string, host: string): string {
-  return `${alias}-${host}`;
-}
-
-const assertSlug = (value: unknown, field: string): void => {
-  if (typeof value !== 'string' || value.length === 0 || !SLUG_RE.test(value)) {
-    throw new Error(`${field} must match [a-z0-9][a-z0-9_.-]* (lowercase, non-empty)`);
-  }
-};
-
-export function validateRegisterAgent(input: unknown): asserts input is RegisterAgentDto {
-  const o = input as Partial<RegisterAgentDto> | null | undefined;
-  if (!o || typeof o !== 'object') throw new Error('payload must be an object');
-  assertSlug(o.alias, 'alias');
-  assertSlug(o.host, 'host');
-  if (o.display_name !== undefined) {
-    if (typeof o.display_name !== 'string' || o.display_name.length === 0) {
-      throw new Error('display_name must be a non-empty string');
-    }
-    if (o.display_name.length > 100) {
-      throw new Error('display_name must be at most 100 chars');
-    }
-  }
-}
-
-export function validateRevokeAgent(input: unknown): asserts input is RevokeAgentDto {
-  const o = input as Partial<RevokeAgentDto> | null | undefined;
-  if (!o || typeof o !== 'object') throw new Error('payload must be an object');
-  if (typeof o.agent_user_id !== 'string' || !o.agent_user_id.startsWith('@')) {
-    throw new Error('agent_user_id must be a Matrix user id');
-  }
-}

packages/appservice/src/agent-store.ts

@@ -1,160 +0,0 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-
-import { agentSlug } from './agent-registry.dto.js';
-import type { AgentSummary } from './agent-registry.dto.js';
-import type { AppserviceIntent } from './intent.js';
-
-/** account_data type holding the agent registry on the AS sender user. */
-export const AGENTS_ACCOUNT_DATA_TYPE = 'org.uscllc.mosaic_as.agents';
-
-const TOKEN_PREFIX = 'magt_';
-
-interface StoredAgent {
-  alias: string;
-  host: string;
-  display_name?: string;
-  created_at: string;
-  /** sha256hex of each active token. Plaintext tokens are NEVER stored. */
-  token_hashes: string[];
-  revoked_at?: string;
-}
-
-interface AgentRegistry {
-  agents: Record<string, StoredAgent>;
-}
-
-const sha256hex = (value: string): string => createHash('sha256').update(value).digest('hex');
-
-const mintToken = (): string => `${TOKEN_PREFIX}${randomBytes(32).toString('base64url')}`;
-
-/**
- * Persists scoped/revocable bridge tokens for agent virtual users in Matrix
- * account_data on the AS sender user (no new infra; survives restart).
- *
- * Tokens are stored only as sha256 hashes (the high-entropy `magt_` token makes
- * plain sha256 safe — no salt/KDF needed since brute force is infeasible).
- *
- * KNOWN v1 LIMIT: Synapse caps a single account_data object (default
- * max_account_data_size, ~100KB). Each agent + hash entry is small, so this
- * supports thousands of agents, but a very large fleet would eventually need a
- * dedicated store. Revoked agents with no active tokens are pruned of hashes
- * (kept as tombstones) to bound growth.
- */
-export class AgentTokenStore {
-  constructor(private readonly intent: AppserviceIntent) {}
-
-  /** Read the registry fresh from account_data (low-frequency ops favor
-   * correctness over caching; verifyToken/list also read fresh). */
-  private async read(): Promise<AgentRegistry> {
-    const data = await this.intent.getSenderAccountData(AGENTS_ACCOUNT_DATA_TYPE);
-    const agents = data?.agents;
-    if (agents && typeof agents === 'object') {
-      return { agents: agents as Record<string, StoredAgent> };
-    }
-    return { agents: {} };
-  }
-
-  private async write(registry: AgentRegistry): Promise<void> {
-    await this.intent.setSenderAccountData(AGENTS_ACCOUNT_DATA_TYPE, {
-      agents: registry.agents,
-    });
-  }
-
-  /** Ensure the virtual user exists, mint a fresh token, store its hash, and
-   * return the plaintext token ONCE. Clears any prior revocation. */
-  async register(opts: {
-    alias: string;
-    host: string;
-    displayName?: string;
-  }): Promise<{ agentUserId: string; token: string }> {
-    const slug = agentSlug(opts.alias, opts.host);
-    const agentUserId = await this.intent.ensureRegistered(slug);
-    if (opts.displayName !== undefined) {
-      await this.intent.setDisplayName(slug, opts.displayName);
-    }
-
-    const token = mintToken();
-    const hash = sha256hex(token);
-
-    const registry = await this.read();
-    const existing = registry.agents[agentUserId];
-    if (existing) {
-      // The agent slug `<alias>-<host>` joins with a `-`, which is also a legal
-      // slug char, so distinct pairs can collide on one Matrix id (e.g.
-      // a/b-c and a-b/c both -> @agent-a-b-c). They ARE the same Matrix user,
-      // but silently overwriting the stored alias/host of a different pair
-      // would conflate two logical agents into one token bucket. Reject the
-      // ambiguous re-registration instead of overwriting.
-      if (existing.alias !== opts.alias || existing.host !== opts.host) {
-        throw new Error(
-          `agent id collision: ${agentUserId} already registered as ` +
-            `${existing.alias}/${existing.host}, refusing ${opts.alias}/${opts.host}`,
-        );
-      }
-      if (opts.displayName !== undefined) existing.display_name = opts.displayName;
-      existing.token_hashes = [...existing.token_hashes, hash];
-      delete existing.revoked_at;
-    } else {
-      registry.agents[agentUserId] = {
-        alias: opts.alias,
-        host: opts.host,
-        ...(opts.displayName !== undefined ? { display_name: opts.displayName } : {}),
-        created_at: new Date().toISOString(),
-        token_hashes: [hash],
-      };
-    }
-    await this.write(registry);
-    return { agentUserId, token };
-  }
-
-  /** Return the agentUserId bound to an active (non-revoked) token, else null.
-   * Constant-time hash comparison; no early-out on match. */
-  async verifyToken(token: string): Promise<string | null> {
-    if (!token.startsWith(TOKEN_PREFIX)) return null;
-    const presented = Buffer.from(sha256hex(token), 'hex');
-
-    const registry = await this.read();
-    let matched: string | null = null;
-    for (const [agentUserId, agent] of Object.entries(registry.agents)) {
-      if (agent.revoked_at) continue;
-      for (const stored of agent.token_hashes) {
-        const candidate = Buffer.from(stored, 'hex');
-        if (candidate.length === presented.length && timingSafeEqual(candidate, presented)) {
-          // No early break: keep scanning so timing does not reveal match position.
-          matched = agentUserId;
-        }
-      }
-    }
-    return matched;
-  }
-
-  /** Revoke all active tokens for an agent. Idempotent; returns count revoked. */
-  async revoke(agentUserId: string): Promise<number> {
-    const registry = await this.read();
-    const agent = registry.agents[agentUserId];
-    if (!agent) return 0;
-    const count = agent.token_hashes.length;
-    agent.token_hashes = [];
-    agent.revoked_at = new Date().toISOString();
-    await this.write(registry);
-    return count;
-  }
-
-  /** List agents with at least one active token (never advertise revoked/phantom). */
-  async list(): Promise<AgentSummary[]> {
-    const registry = await this.read();
-    const out: AgentSummary[] = [];
-    for (const [agentUserId, agent] of Object.entries(registry.agents)) {
-      if (agent.revoked_at || agent.token_hashes.length === 0) continue;
-      out.push({
-        agent_user_id: agentUserId,
-        alias: agent.alias,
-        host: agent.host,
-        ...(agent.display_name !== undefined ? { display_name: agent.display_name } : {}),
-        created_at: agent.created_at,
-        active_token_count: agent.token_hashes.length,
-      });
-    }
-    return out;
-  }
-}

packages/appservice/src/bridge.dto.ts

@@ -1,83 +0,0 @@
-/** DTOs for the internal bridge API consumed by agent-comms host daemons. */
-
-export interface BridgeMessageDto {
-  room_id: string;
-  /** Agent slug (localpart suffix), e.g. "pi0-web1". */
-  agent: string;
-  body: string;
-  thread_root?: string;
-  msgtype?: string;
-  /** Optional protocol payload merged into content (e.g. org.uscllc.agent). */
-  extra_content?: Record<string, unknown>;
-}
-
-export interface BridgeTypingDto {
-  room_id: string;
-  agent: string;
-  typing: boolean;
-}
-
-const AGENT_SLUG_RE = /^[a-z0-9][a-z0-9_.-]*$/;
-
-const assertAgentSlug = (agent: unknown): void => {
-  if (typeof agent !== 'string' || !AGENT_SLUG_RE.test(agent.toLowerCase())) {
-    throw new Error('agent must match [a-z0-9][a-z0-9_.-]*');
-  }
-};
-
-export function validateBridgeMessage(input: unknown): asserts input is BridgeMessageDto {
-  const o = input as Partial<BridgeMessageDto> | null | undefined;
-  if (!o || typeof o !== 'object') throw new Error('payload must be an object');
-  if (typeof o.room_id !== 'string' || !o.room_id.startsWith('!'))
-    throw new Error('room_id must be a Matrix room id');
-  assertAgentSlug(o.agent);
-  if (typeof o.body !== 'string') throw new Error('body must be a string');
-  if (o.thread_root !== undefined && typeof o.thread_root !== 'string')
-    throw new Error('thread_root must be a string');
-  if (
-    o.extra_content !== undefined &&
-    (typeof o.extra_content !== 'object' || o.extra_content === null)
-  ) {
-    throw new Error('extra_content must be an object');
-  }
-}
-
-export function validateBridgeTyping(input: unknown): asserts input is BridgeTypingDto {
-  const o = input as Partial<BridgeTypingDto> | null | undefined;
-  if (!o || typeof o !== 'object') throw new Error('payload must be an object');
-  if (typeof o.room_id !== 'string' || !o.room_id.startsWith('!'))
-    throw new Error('room_id must be a Matrix room id');
-  assertAgentSlug(o.agent);
-  if (typeof o.typing !== 'boolean') throw new Error('typing must be a boolean');
-}
-
-export interface ProvisionRoomDto {
-  name: string;
-  alias?: string;
-  topic?: string;
-  invite?: string[];
-  space_id?: string;
-}
-
-export function validateProvisionRoom(input: unknown): asserts input is ProvisionRoomDto {
-  const o = input as Partial<ProvisionRoomDto> | null | undefined;
-  if (!o || typeof o !== 'object') throw new Error('payload must be an object');
-  if (typeof o.name !== 'string' || o.name.length === 0) throw new Error('name is required');
-  if (o.alias !== undefined && (!/^[a-z0-9_.-]+$/.test(o.alias) || o.alias.length > 200)) {
-    throw new Error('alias must match [a-z0-9_.-]+ (max 200 chars)');
-  }
-  if (o.invite !== undefined) {
-    if (
-      !Array.isArray(o.invite) ||
-      o.invite.some((u) => typeof u !== 'string' || !u.startsWith('@'))
-    ) {
-      throw new Error('invite must be a list of Matrix user ids');
-    }
-    if (o.invite.length > 50) {
-      throw new Error('invite list exceeds maximum of 50');
-    }
-  }
-  if (o.space_id !== undefined && (typeof o.space_id !== 'string' || !o.space_id.startsWith('!'))) {
-    throw new Error('space_id must be a Matrix room id');
-  }
-}

packages/appservice/src/index.ts

@@ -1,27 +0,0 @@
-export { AppserviceIntent, MatrixApiError } from './intent.js';
-export type { SendMessageOptions } from './intent.js';
-export { TransactionHandler } from './transactions.js';
-export type { TransactionHandlerOptions } from './transactions.js';
-export { buildRegistration, registrationToYaml } from './registration.js';
-export type { RegistrationOptions } from './registration.js';
-export {
-  validateBridgeMessage,
-  validateBridgeTyping,
-  validateProvisionRoom,
-} from './bridge.dto.js';
-export type { BridgeMessageDto, BridgeTypingDto, ProvisionRoomDto } from './bridge.dto.js';
-export { agentSlug, validateRegisterAgent, validateRevokeAgent } from './agent-registry.dto.js';
-export type {
-  RegisterAgentDto,
-  RevokeAgentDto,
-  RegisterAgentResponse,
-  AgentSummary,
-} from './agent-registry.dto.js';
-export { AgentTokenStore, AGENTS_ACCOUNT_DATA_TYPE } from './agent-store.js';
-export type {
-  AppserviceConfig,
-  EventHandler,
-  HandlerResult,
-  MatrixEvent,
-  Transaction,
-} from './types.js';

packages/appservice/src/intent.ts

@@ -1,262 +0,0 @@
-import crypto from 'node:crypto';
-
-import type { AppserviceConfig } from './types.js';
-
-export interface SendMessageOptions {
-  roomId: string;
-  /** Agent slug, e.g. "pi0-web1" -> @agent-pi0-web1:domain */
-  agent: string;
-  body: string;
-  /** Request event id to thread off (m.thread, spec v1.4). */
-  threadRoot?: string;
-  msgtype?: string;
-  /** Extra content keys merged into the message content (e.g. org.uscllc.agent). */
-  extraContent?: Record<string, unknown>;
-}
-
-export class MatrixApiError extends Error {
-  constructor(
-    readonly status: number,
-    readonly errcode: string | undefined,
-    message: string,
-  ) {
-    super(message);
-    this.name = 'MatrixApiError';
-  }
-}
-
-type FetchLike = typeof fetch;
-
-/**
- * Acts on the homeserver as appservice-namespaced virtual users
- * (Application Service API: as_token auth + user_id impersonation).
- */
-export class AppserviceIntent {
-  private readonly registered = new Set<string>();
-  private readonly joined = new Set<string>();
-  private readonly fetchImpl: FetchLike;
-
-  constructor(
-    private readonly cfg: AppserviceConfig,
-    fetchImpl?: FetchLike,
-  ) {
-    this.fetchImpl = fetchImpl ?? fetch;
-  }
-
-  get userPrefix(): string {
-    return this.cfg.userPrefix ?? 'agent-';
-  }
-
-  get senderUserId(): string {
-    return `@${this.cfg.senderLocalpart ?? 'mosaic-as'}:${this.cfg.domain}`;
-  }
-
-  agentLocalpart(agent: string): string {
-    const slug = agent.toLowerCase();
-    if (!/^[a-z0-9][a-z0-9_.-]*$/.test(slug)) {
-      throw new Error(`invalid agent slug: ${agent}`);
-    }
-    return `${this.userPrefix}${slug}`;
-  }
-
-  agentUserId(agent: string): string {
-    return `@${this.agentLocalpart(agent)}:${this.cfg.domain}`;
-  }
-
-  private async request(
-    method: string,
-    path: string,
-    options: { userId?: string; body?: unknown } = {},
-  ): Promise<Record<string, unknown>> {
-    const url = new URL(this.cfg.homeserverUrl.replace(/\/$/, '') + path);
-    if (options.userId) {
-      url.searchParams.set('user_id', options.userId);
-    }
-    const res = await this.fetchImpl(url, {
-      method,
-      headers: {
-        Authorization: `Bearer ${this.cfg.asToken}`,
-        'Content-Type': 'application/json',
-      },
-      body: options.body === undefined ? undefined : JSON.stringify(options.body),
-    });
-    const text = await res.text();
-    const data = (text ? JSON.parse(text) : {}) as Record<string, unknown>;
-    if (!res.ok) {
-      throw new MatrixApiError(
-        res.status,
-        typeof data.errcode === 'string' ? data.errcode : undefined,
-        `${method} ${path} -> ${res.status}: ${text.slice(0, 300)}`,
-      );
-    }
-    return data;
-  }
-
-  /** Register the virtual user if it does not exist yet. Idempotent. */
-  async ensureRegistered(agent: string): Promise<string> {
-    const localpart = this.agentLocalpart(agent);
-    const userId = this.agentUserId(agent);
-    if (this.registered.has(userId)) return userId;
-    try {
-      await this.request('POST', '/_matrix/client/v3/register', {
-        body: { type: 'm.login.application_service', username: localpart },
-      });
-    } catch (err) {
-      if (!(err instanceof MatrixApiError && err.errcode === 'M_USER_IN_USE')) {
-        throw err;
-      }
-    }
-    this.registered.add(userId);
-    return userId;
-  }
-
-  /** Join the agent to a room; on invite-only rooms the AS sender invites first. */
-  async ensureJoined(roomId: string, agent: string): Promise<void> {
-    const userId = await this.ensureRegistered(agent);
-    const key = `${userId} ${roomId}`;
-    if (this.joined.has(key)) return;
-    const room = encodeURIComponent(roomId);
-    try {
-      await this.request('POST', `/_matrix/client/v3/rooms/${room}/join`, { userId, body: {} });
-    } catch (err) {
-      if (!(err instanceof MatrixApiError && err.errcode === 'M_FORBIDDEN')) throw err;
-      await this.request('POST', `/_matrix/client/v3/rooms/${room}/invite`, {
-        userId: this.senderUserId,
-        body: { user_id: userId },
-      });
-      await this.request('POST', `/_matrix/client/v3/rooms/${room}/join`, { userId, body: {} });
-    }
-    this.joined.add(key);
-  }
-
-  /** Send a message AS the agent's virtual user. */
-  async sendAsAgent(options: SendMessageOptions): Promise<string | undefined> {
-    const userId = this.agentUserId(options.agent);
-    await this.ensureJoined(options.roomId, options.agent);
-    const content: Record<string, unknown> = {
-      msgtype: options.msgtype ?? 'm.text',
-      body: options.body,
-      ...options.extraContent,
-    };
-    if (options.threadRoot) {
-      content['m.relates_to'] = {
-        rel_type: 'm.thread',
-        event_id: options.threadRoot,
-        is_falling_back: true,
-        'm.in_reply_to': { event_id: options.threadRoot },
-      };
-    }
-    const txn = `mosaic-as-${crypto.randomUUID()}`;
-    const room = encodeURIComponent(options.roomId);
-    const res = await this.request(
-      'PUT',
-      `/_matrix/client/v3/rooms/${room}/send/m.room.message/${txn}`,
-      { userId, body: content },
-    );
-    return typeof res.event_id === 'string' ? res.event_id : undefined;
-  }
-
-  /** Set the agent's typing indicator in a room. */
-  async setTyping(
-    roomId: string,
-    agent: string,
-    typing: boolean,
-    timeoutMs = 30000,
-  ): Promise<void> {
-    const userId = await this.ensureRegistered(agent);
-    const room = encodeURIComponent(roomId);
-    const user = encodeURIComponent(userId);
-    await this.request('PUT', `/_matrix/client/v3/rooms/${room}/typing/${user}`, {
-      userId,
-      body: typing ? { typing: true, timeout: timeoutMs } : { typing: false },
-    });
-  }
-
-  /** Create a room as the AS sender: agents get PL 50 by namespace via the
-   * sender (PL 100); humans invited at default PL. Optionally link into a
-   * space (m.space.child + m.space.parent). Returns the room id. */
-  async createRoom(options: {
-    name: string;
-    alias?: string;
-    topic?: string;
-    invite?: string[];
-    spaceId?: string;
-  }): Promise<{ roomId: string; spaceLinked: boolean; spaceError?: string }> {
-    const body: Record<string, unknown> = {
-      name: options.name,
-      preset: 'private_chat',
-      invite: options.invite ?? [],
-      power_level_content_override: {
-        users: { [this.senderUserId]: 100 },
-        // state_default 50 stays; the AS sender can grant agents as needed.
-      },
-    };
-    if (options.alias) body.room_alias_name = options.alias;
-    if (options.topic) body.topic = options.topic;
-    const res = await this.request('POST', '/_matrix/client/v3/createRoom', {
-      userId: this.senderUserId,
-      body,
-    });
-    const roomId = res.room_id;
-    if (typeof roomId !== 'string') throw new Error('createRoom returned no room_id');
-    if (!options.spaceId) {
-      return { roomId, spaceLinked: false };
-    }
-    // Space-link failures must NOT throw: the room already exists, and an
-    // exception would hide the room_id (orphaned room, no recovery path).
-    const encodedSpaceId = encodeURIComponent(options.spaceId);
-    const encodedRoomId = encodeURIComponent(roomId);
-    try {
-      await this.request(
-        'PUT',
-        `/_matrix/client/v3/rooms/${encodedSpaceId}/state/m.space.child/${encodedRoomId}`,
-        { userId: this.senderUserId, body: { via: [this.cfg.domain], suggested: true } },
-      );
-      await this.request(
-        'PUT',
-        `/_matrix/client/v3/rooms/${encodedRoomId}/state/m.space.parent/${encodedSpaceId}`,
-        { userId: this.senderUserId, body: { via: [this.cfg.domain], canonical: true } },
-      );
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return { roomId, spaceLinked: false, spaceError: message };
-    }
-    return { roomId, spaceLinked: true };
-  }
-
-  /** Set display name for an agent's virtual user. */
-  async setDisplayName(agent: string, displayName: string): Promise<void> {
-    const userId = await this.ensureRegistered(agent);
-    const user = encodeURIComponent(userId);
-    await this.request('PUT', `/_matrix/client/v3/profile/${user}/displayname`, {
-      userId,
-      body: { displayname: displayName },
-    });
-  }
-
-  /** Read an account_data object on the AS sender user. Returns null when the
-   * key has never been written (M_NOT_FOUND), so callers can treat that as an
-   * empty store; any other error propagates. */
-  async getSenderAccountData(type: string): Promise<Record<string, unknown> | null> {
-    const user = encodeURIComponent(this.senderUserId);
-    const key = encodeURIComponent(type);
-    try {
-      return await this.request('GET', `/_matrix/client/v3/user/${user}/account_data/${key}`, {
-        userId: this.senderUserId,
-      });
-    } catch (err) {
-      if (err instanceof MatrixApiError && err.errcode === 'M_NOT_FOUND') return null;
-      throw err;
-    }
-  }
-
-  /** Write an account_data object on the AS sender user. */
-  async setSenderAccountData(type: string, content: Record<string, unknown>): Promise<void> {
-    const user = encodeURIComponent(this.senderUserId);
-    const key = encodeURIComponent(type);
-    await this.request('PUT', `/_matrix/client/v3/user/${user}/account_data/${key}`, {
-      userId: this.senderUserId,
-      body: content,
-    });
-  }
-}

packages/appservice/src/registration.ts

@@ -1,76 +0,0 @@
-import type { AppserviceConfig } from './types.js';
-
-export interface RegistrationOptions {
-  /** Unique appservice id in Synapse. Default: "mosaic-as". */
-  id?: string;
-  /** URL where Synapse reaches the appservice, e.g. http://mosaic-as:8008 */
-  url: string;
-  /** Alias namespace regex prefix. Default: "#mosaic-". */
-  aliasPrefix?: string;
-}
-
-const escapeRegex = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-/**
- * Build the Synapse appservice registration document (mosaic-as.yaml).
- * Deployment (infrastructure repo) serializes this to YAML and mounts it via
- * app_service_config_files.
- */
-export function buildRegistration(cfg: AppserviceConfig, options: RegistrationOptions) {
-  const prefix = cfg.userPrefix ?? 'agent-';
-  return {
-    id: options.id ?? 'mosaic-as',
-    url: options.url,
-    as_token: cfg.asToken,
-    hs_token: cfg.hsToken,
-    sender_localpart: cfg.senderLocalpart ?? 'mosaic-as',
-    rate_limited: false,
-    namespaces: {
-      users: [
-        {
-          regex: `@${escapeRegex(prefix)}.*:${escapeRegex(cfg.domain)}`,
-          exclusive: true,
-        },
-      ],
-      aliases: [
-        {
-          regex: `${escapeRegex(options.aliasPrefix ?? '#mosaic-')}.*:${escapeRegex(cfg.domain)}`,
-          exclusive: false,
-        },
-      ],
-      rooms: [],
-    },
-  };
-}
-
-const assertYamlSafe = (field: string, value: string): string => {
-  // Tokens/urls/ids are single-line opaque strings; control characters would
-  // let a crafted value terminate the scalar and inject YAML keys.
-  if (/[\r\n\x00-\x08\x0b-\x1f]/.test(value)) {
-    throw new Error(`registration field ${field} contains control characters`);
-  }
-  return value.replace(/'/g, "''");
-};
-
-/** Minimal YAML serialization for the flat registration document. */
-export function registrationToYaml(registration: ReturnType<typeof buildRegistration>): string {
-  const ns = registration.namespaces;
-  const nsBlock = (entries: Array<{ regex: string; exclusive: boolean }>): string =>
-    entries.length === 0
-      ? ' []'
-      : '\n' +
-        entries.map((e) => `    - regex: '${e.regex}'\n      exclusive: ${e.exclusive}`).join('\n');
-  return [
-    `id: '${assertYamlSafe('id', registration.id)}'`,
-    `url: '${assertYamlSafe('url', registration.url)}'`,
-    `as_token: '${assertYamlSafe('as_token', registration.as_token)}'`,
-    `hs_token: '${assertYamlSafe('hs_token', registration.hs_token)}'`,
-    `sender_localpart: '${assertYamlSafe('sender_localpart', registration.sender_localpart)}'`,
-    `rate_limited: ${registration.rate_limited}`,
-    'namespaces:',
-    `  users:${nsBlock(ns.users)}`,
-    `  aliases:${nsBlock(ns.aliases)}`,
-    `  rooms:${nsBlock(ns.rooms)}`,
-    '',
-  ].join('\n');
-}

packages/appservice/src/transactions.ts

@@ -1,89 +0,0 @@
-import { timingSafeEqual } from 'node:crypto';
-
-import type { EventHandler, HandlerResult, Transaction } from './types.js';
-
-const MAX_SEEN_TXN_IDS = 1000;
-
-function safeTokenCompare(presented: string | undefined, expected: string): boolean {
-  if (presented === undefined) return false;
-  const a = Buffer.from(presented);
-  const b = Buffer.from(expected);
-  if (a.length !== b.length) {
-    // Compare against a same-length dummy so length is not a timing oracle.
-    timingSafeEqual(a, Buffer.alloc(a.length));
-    return false;
-  }
-  return timingSafeEqual(a, b);
-}
-
-export interface TransactionHandlerOptions {
-  hsToken: string;
-  onEvent: EventHandler;
-  /** Called for handler errors; events are at-most-once, errors must not 500. */
-  onError?: (error: unknown, txnId: string) => void;
-}
-
-/**
- * Framework-agnostic handler for the Application Service transactions API
- * (PUT /_matrix/app/v1/transactions/{txnId}). Host apps (Fastify/Nest) wrap
- * this in a route.
- *
- * Spec requirements covered: hs_token verification (Authorization: Bearer,
- * with legacy ?access_token fallback), txnId idempotency, always-200 on
- * accepted transactions (homeserver retries on any other status).
- *
- * KNOWN LIMITATION: the txnId dedupe ring is in-process memory only. After a
- * restart the homeserver may redeliver pending transactions — event handlers
- * must be idempotent (delivery is at-least-once across process lifetimes).
- */
-export class TransactionHandler {
-  private readonly seen: string[] = [];
-  private readonly seenSet = new Set<string>();
-
-  constructor(private readonly options: TransactionHandlerOptions) {}
-
-  authorized(
-    authorizationHeader: string | undefined,
-    accessTokenParam: string | undefined,
-  ): boolean {
-    const bearer = authorizationHeader?.startsWith('Bearer ')
-      ? authorizationHeader.slice('Bearer '.length)
-      : undefined;
-    const presented = bearer ?? accessTokenParam;
-    return safeTokenCompare(presented, this.options.hsToken);
-  }
-
-  async handle(
-    txnId: string,
-    body: unknown,
-    auth: { authorizationHeader?: string; accessTokenParam?: string },
-  ): Promise<HandlerResult> {
-    if (!this.authorized(auth.authorizationHeader, auth.accessTokenParam)) {
-      return { status: 403, body: { errcode: 'M_FORBIDDEN', error: 'bad hs_token' } };
-    }
-    if (this.seenSet.has(txnId)) {
-      return { status: 200, body: {} };
-    }
-    this.markSeen(txnId);
-    const txn = (body ?? {}) as Partial<Transaction>;
-    for (const event of txn.events ?? []) {
-      try {
-        await this.options.onEvent(event);
-      } catch (error) {
-        // A failing handler must not fail the transaction: the homeserver
-        // would retry the whole batch forever.
-        this.options.onError?.(error, txnId);
-      }
-    }
-    return { status: 200, body: {} };
-  }
-
-  private markSeen(txnId: string): void {
-    this.seen.push(txnId);
-    this.seenSet.add(txnId);
-    while (this.seen.length > MAX_SEEN_TXN_IDS) {
-      const evicted = this.seen.shift();
-      if (evicted !== undefined) this.seenSet.delete(evicted);
-    }
-  }
-}

packages/appservice/src/types.ts

@@ -1,35 +0,0 @@
-export interface AppserviceConfig {
-  /** Homeserver client-server API base, e.g. https://chat.uscllc.com */
-  homeserverUrl: string;
-  /** Server name used in user IDs, e.g. chat.uscllc.com */
-  domain: string;
-  /** Token the appservice presents to the homeserver (as_token). */
-  asToken: string;
-  /** Token the homeserver presents to the appservice (hs_token). */
-  hsToken: string;
-  /** Localpart prefix owned by this appservice. Default: "agent-". */
-  userPrefix?: string;
-  /** The appservice's own sender user localpart. Default: "mosaic-as". */
-  senderLocalpart?: string;
-}
-
-export interface MatrixEvent {
-  type: string;
-  event_id?: string;
-  room_id?: string;
-  sender?: string;
-  state_key?: string;
-  content?: Record<string, unknown>;
-  origin_server_ts?: number;
-}
-
-export interface Transaction {
-  events: MatrixEvent[];
-}
-
-export type EventHandler = (event: MatrixEvent) => void | Promise<void>;
-
-export interface HandlerResult {
-  status: number;
-  body: Record<string, unknown>;
-}

packages/appservice/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

packages/db/package.json

@@ -42,7 +42,6 @@
     "access": "public"
   },
   "files": [
-    "dist",
+    "dist"
-    "drizzle"
   ]
 }

packages/db/src/client-pglite.ts

@@ -1,12 +1,10 @@
 import { PGlite } from '@electric-sql/pglite';
-import { vector } from '@electric-sql/pglite/vector';
 import { drizzle } from 'drizzle-orm/pglite';
 import * as schema from './schema.js';
 import type { DbHandle } from './client.js';
 
 export function createPgliteDb(dataDir: string): DbHandle {
-  // pgvector extension is required by migration 0001 (insights.embedding column).
+  const client = new PGlite(dataDir);
-  const client = new PGlite(dataDir, { extensions: { vector } });
   const db = drizzle(client, { schema });
   return {
     db: db as unknown as DbHandle['db'],

packages/db/src/index.ts

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

packages/db/src/migrate.test.ts

@@ -1,70 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { sql } from 'drizzle-orm';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { createPgliteDb } from './client-pglite.js';
-import { runPgliteMigrations } from './migrate.js';
-import type { DbHandle } from './client.js';
-
-interface PgliteExec {
-  exec(query: string): Promise<unknown>;
-}
-
-describe('runPgliteMigrations', () => {
-  let dataDir: string;
-  let handle: DbHandle;
-
-  beforeEach(() => {
-    dataDir = mkdtempSync(join(tmpdir(), 'mosaic-db-migrate-test-'));
-    handle = createPgliteDb(dataDir);
-  });
-
-  afterEach(async () => {
-    await handle.close();
-    rmSync(dataDir, { recursive: true, force: true });
-  });
-
-  it('creates the BetterAuth tables required by the gateway', async () => {
-    await runPgliteMigrations(handle);
-
-    const result = (await handle.db.execute(sql`
-      SELECT table_name FROM information_schema.tables
-      WHERE table_schema = 'public'
-      ORDER BY table_name
-    `)) as unknown as { rows: Array<{ table_name: string }> };
-
-    const tables = result.rows.map((r) => r.table_name);
-
-    // Auth tables — required for sign-in / bootstrap to function.
-    expect(tables).toContain('users');
-    expect(tables).toContain('sessions');
-    expect(tables).toContain('accounts');
-    expect(tables).toContain('verifications');
-
-    // Schema sanity check — admin token table consumed by mosaic gateway config.
-    expect(tables).toContain('admin_tokens');
-  });
-
-  it('is idempotent — running twice does not error', async () => {
-    await runPgliteMigrations(handle);
-    await expect(runPgliteMigrations(handle)).resolves.toBeUndefined();
-  });
-
-  it('surfaces statement-level error context on failure and leaves no ledger row', async () => {
-    // Pre-create a `users` table that conflicts with migration 0000's CREATE TABLE,
-    // forcing it to fail without IF NOT EXISTS.
-    const client = (handle.db as unknown as { $client: PgliteExec }).$client;
-    await client.exec('CREATE TABLE users (sentinel text)');
-
-    await expect(runPgliteMigrations(handle)).rejects.toThrow(
-      /migration hash=[a-f0-9]+ statement #\d+ failed/,
-    );
-
-    // Ledger should be empty — partial application must not pretend to be complete.
-    const ledger = (await handle.db.execute(
-      sql`SELECT count(*)::int AS count FROM drizzle.__drizzle_migrations`,
-    )) as unknown as { rows: Array<{ count: number }> };
-    expect(ledger.rows[0]?.count).toBe(0);
-  });
-});

packages/db/src/migrate.ts

@@ -1,109 +1,18 @@
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
-import { drizzle as drizzlePostgres } from 'drizzle-orm/postgres-js';
+import { migrate } from 'drizzle-orm/postgres-js/migrator';
-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';
-import type { DbHandle } from './client.js';
-
-interface PgliteExecutor {
-  exec(query: string): Promise<unknown>;
-}
-
-interface ExecuteRows<T> {
-  rows: T[];
-}
-
-function migrationsFolder(): string {
-  const here = dirname(fileURLToPath(import.meta.url));
-  return resolve(here, '../drizzle');
-}
 
 export async function runMigrations(url?: string): Promise<void> {
   const connectionString = url ?? process.env['DATABASE_URL'] ?? DEFAULT_DATABASE_URL;
-  const sqlClient = postgres(connectionString, { max: 1 });
+  const sql = postgres(connectionString, { max: 1 });
-  const db = drizzlePostgres(sqlClient);
+  const db = drizzle(sql);
+  const __dirname = dirname(fileURLToPath(import.meta.url));
   try {
-    // TODO: postgres-tier first-install also fails because (a) Drizzle wraps every
+    await migrate(db, { migrationsFolder: resolve(__dirname, '../drizzle') });
-    // migration in one transaction (breaks 0009's ALTER TYPE ADD VALUE → SET DEFAULT
-    // sequence) and (b) drizzle/meta/_journal.json has 0009 ordered before 0008,
-    // which the postgres-js migrator skips by `created_at < folderMillis`. The
-    // PGlite path below sidesteps both. A follow-up should either share the
-    // per-statement loop (see runPgliteMigrations) or fix the journal ordering.
-    await migratePostgres(db, { migrationsFolder: migrationsFolder() });
   } finally {
-    await sqlClient.end();
+    await sql.end();
-  }
-}
-
-// Apply Drizzle migrations against an embedded PGlite database.
-//
-// We don't reuse drizzle's pglite migrator because it wraps ALL migrations in
-// one outer transaction, which breaks Postgres' `check_safe_enum_use` rule —
-// e.g. migration 0009 does `ALTER TYPE ADD VALUE 'pending'` then references
-// `'pending'` as a default in the same tx. PGlite's `exec()` runs each
-// statement under the Simple Query protocol, autocommitting between them.
-//
-// We still write to the standard `drizzle.__drizzle_migrations` ledger so the
-// 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 client.exec('CREATE SCHEMA IF NOT EXISTS drizzle');
-  await client.exec(`
-    CREATE TABLE IF NOT EXISTS drizzle.__drizzle_migrations (
-      id SERIAL PRIMARY KEY,
-      hash text NOT NULL,
-      created_at bigint
-    )
-  `);
-
-  const appliedRows = (await handle.db.execute(
-    sql`SELECT hash FROM drizzle.__drizzle_migrations`,
-  )) as unknown as ExecuteRows<{ hash: string }>;
-  const applied = new Set(appliedRows.rows.map((r) => r.hash));
-
-  const migrations = readMigrationFiles({ migrationsFolder: migrationsFolder() });
-  for (const migration of migrations) {
-    if (applied.has(migration.hash)) continue;
-
-    // Run each statement-breakpoint chunk in its own exec() call so PGlite
-    // commits between statements — this is what lets `ALTER TYPE ADD VALUE`
-    // become visible before a subsequent statement references the new value.
-    for (const [stmtIdx, stmt] of migration.sql.entries()) {
-      const trimmed = stmt.trim();
-      if (!trimmed) continue;
-      try {
-        await client.exec(trimmed);
-      } catch (err) {
-        const cause = err instanceof Error ? err.message : String(err);
-        throw new Error(
-          `runPgliteMigrations: migration hash=${migration.hash} statement #${stmtIdx} failed: ${cause}\n` +
-            `Statement: ${trimmed.slice(0, 200)}${trimmed.length > 200 ? '…' : ''}`,
-          { cause: err },
-        );
-      }
-    }
-    await handle.db.execute(
-      sql`INSERT INTO drizzle.__drizzle_migrations (hash, created_at) VALUES (${migration.hash}, ${migration.folderMillis})`,
-    );
   }
 }

packages/macp/src/index.ts

@@ -39,11 +39,6 @@ export { normalizeGate, runShell, countAIFindings, runGate, runGates } from './g
 
 export type { NormalizedGate } from './gate-runner.js';
 
-// Risk-floor (agent reflection loop — diff review classifier)
-export { evaluateRiskFloor, DEFAULT_RISK_THRESHOLD } from './risk-floor.js';
-
-export type { ReviewSurface, RiskFloorInput, RiskFloorVerdict } from './risk-floor.js';
-
 // Event emitter
 export { nowISO, appendEvent, emitEvent } from './event-emitter.js';
 

packages/macp/src/risk-floor.spec.ts

@@ -1,87 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { DEFAULT_RISK_THRESHOLD, evaluateRiskFloor, type ReviewSurface } from './risk-floor.js';
-
-describe('evaluateRiskFloor', () => {
-  it('returns a no-review "none" verdict for an empty diff', () => {
-    const v = evaluateRiskFloor({ filesChanged: [] });
-    expect(v).toEqual({
-      needs_review: false,
-      score: 0,
-      surface: 'none',
-      reason: 'no files changed',
-    });
-  });
-
-  it('ignores empty/non-string entries', () => {
-    const v = evaluateRiskFloor({ filesChanged: ['', '   ' as unknown as string].filter(Boolean) });
-    // only the whitespace string survives the Boolean filter; it classifies to none
-    expect(v.surface).toBe('none');
-    expect(v.needs_review).toBe(false);
-  });
-
-  it.each<[string, string, ReviewSurface, boolean]>([
-    ['auth', 'apps/api/src/auth/session.guard.ts', 'auth', true],
-    ['data', 'packages/db/migrations/0007_add_users.sql', 'data', true],
-    ['infra', '.woodpecker/deploy.yml', 'infra', true],
-    ['build', 'packages/types/tsconfig.json', 'build', true],
-    ['ui', 'apps/web/src/components/Button.tsx', 'ui', false],
-    ['test', 'packages/macp/src/risk-floor.spec.ts', 'test', false],
-    ['docs', 'docs/plans/agent-reflection-loop-PRD.md', 'docs', false],
-    ['none', 'README', 'none', false],
-  ])(
-    'classifies a single %s file → surface=%s needs_review=%s',
-    (_label, file, surface, needsReview) => {
-      const v = evaluateRiskFloor({ filesChanged: [file] });
-      expect(v.surface).toBe(surface);
-      expect(v.needs_review).toBe(needsReview);
-      expect(v.reason).toContain(
-        file === 'README' ? 'no sensitive surface' : surface === 'none' ? '' : surface,
-      );
-    },
-  );
-
-  it('lets the highest-risk surface dominate a mixed diff', () => {
-    const v = evaluateRiskFloor({
-      filesChanged: [
-        'docs/readme.md',
-        'apps/web/src/components/Nav.tsx',
-        'apps/api/src/auth/token.service.ts',
-      ],
-    });
-    expect(v.surface).toBe('auth');
-    expect(v.score).toBe(1.0);
-    expect(v.needs_review).toBe(true);
-    expect(v.reason).toContain('token.service.ts');
-    expect(v.reason).not.toContain('readme.md');
-  });
-
-  it('names every file that ties at the dominant surface', () => {
-    const v = evaluateRiskFloor({
-      filesChanged: ['src/login.ts', 'src/permission-check.ts'],
-    });
-    expect(v.surface).toBe('auth');
-    expect(v.reason).toContain('src/login.ts');
-    expect(v.reason).toContain('src/permission-check.ts');
-  });
-
-  it('treats docs+test-only diffs as below the floor', () => {
-    const v = evaluateRiskFloor({
-      filesChanged: ['docs/guide.md', 'packages/x/src/x.test.ts'],
-    });
-    expect(v.needs_review).toBe(false);
-    expect(v.surface).toBe('test'); // higher weight than docs
-  });
-
-  it('honors a custom threshold', () => {
-    const docsOnly = { filesChanged: ['docs/guide.md'] };
-    expect(evaluateRiskFloor(docsOnly, 0.05).needs_review).toBe(true);
-    expect(evaluateRiskFloor(docsOnly, DEFAULT_RISK_THRESHOLD).needs_review).toBe(false);
-  });
-
-  it('is deterministic across call order', () => {
-    const a = evaluateRiskFloor({ filesChanged: ['a.md', 'auth/x.ts', 'b.tsx'] });
-    const b = evaluateRiskFloor({ filesChanged: ['b.tsx', 'a.md', 'auth/x.ts'] });
-    expect(a).toEqual(b);
-  });
-});

packages/macp/src/risk-floor.ts

@@ -1,138 +0,0 @@
-/**
- * Diff risk-floor — deterministic review-need classifier.
- *
- * Given the set of changed files in a diff, derive a *minimum* review
- * requirement ("floor") from the change surface. This is the mechanical half
- * of the agent reflection loop (design §6): risky surfaces (auth, data, infra)
- * trip a review requirement regardless of what the agent self-reports.
- *
- * Precedence (authoritative ordering, see design §5):
- *   CI/tests  >  human merge  >  reviewer verdict  >  self-reflection
- * This module sits at the *floor*. It NEVER overrides CI or a human; a
- * `needs_review: false` verdict means "no surface tripped the floor", not
- * "safe to merge". Consumers MUST keep CI/tests authoritative above it.
- *
- * Pure and deterministic: no IO, no clock, no randomness. Same input → same
- * verdict. Safe to call from a Stop hook via `node -e` or to port inline.
- */
-
-/** Review surfaces, ordered most- to least-sensitive. */
-export type ReviewSurface = 'auth' | 'data' | 'infra' | 'build' | 'ui' | 'test' | 'docs' | 'none';
-
-export interface RiskFloorInput {
-  /** Paths of changed files, repo-relative. Order-insensitive. */
-  filesChanged: string[];
-  /** Optional diff size signals; reserved for future weighting. */
-  insertions?: number;
-  deletions?: number;
-}
-
-export interface RiskFloorVerdict {
-  /** True when the change surface meets/exceeds the review threshold. */
-  needs_review: boolean;
-  /** Aggregate risk score in [0, 1] — the max surface weight across files. */
-  score: number;
-  /** The dominant (highest-weight) surface across all changed files. */
-  surface: ReviewSurface;
-  /** Human-readable explanation naming the surface and tripping files. */
-  reason: string;
-}
-
-/** Default review threshold; `score >= THRESHOLD` ⇒ `needs_review`. */
-export const DEFAULT_RISK_THRESHOLD = 0.5;
-
-interface SurfaceRule {
-  surface: ReviewSurface;
-  weight: number;
-  /** Case-insensitive regex matched against the file path. */
-  pattern: RegExp;
-}
-
-/**
- * Surface classification rules, evaluated highest-weight first. The first
- * rule whose pattern matches a path classifies that file; the file's surface
- * is the highest-risk surface it matches (rules are pre-sorted by weight).
- */
-const SURFACE_RULES: readonly SurfaceRule[] = [
-  {
-    surface: 'auth',
-    weight: 1.0,
-    pattern: /auth|login|session|token|permission|rbac|credential|secret/i,
-  },
-  {
-    surface: 'data',
-    weight: 0.9,
-    pattern: /migration|prisma|schema|\.sql|entity|repository|seed/i,
-  },
-  {
-    surface: 'infra',
-    weight: 0.85,
-    pattern: /docker|\.woodpecker|compose|traefik|deploy|helm|k8s|terraform/i,
-  },
-  {
-    surface: 'build',
-    weight: 0.6,
-    pattern: /package\.json|tsconfig|turbo\.json|pnpm-|\.config\.|eslint|vite/i,
-  },
-  { surface: 'ui', weight: 0.4, pattern: /\.tsx|\.css|components\/|apps\/web\// },
-  { surface: 'test', weight: 0.2, pattern: /\.spec\.|\.test\.|__tests__\// },
-  { surface: 'docs', weight: 0.1, pattern: /\.md$|docs\// },
-];
-
-const NONE_WEIGHT = 0.0;
-
-/** Classify a single path to its highest-risk surface and weight. */
-function classify(path: string): { surface: ReviewSurface; weight: number } {
-  for (const rule of SURFACE_RULES) {
-    if (rule.pattern.test(path)) {
-      return { surface: rule.surface, weight: rule.weight };
-    }
-  }
-  return { surface: 'none', weight: NONE_WEIGHT };
-}
-
-/**
- * Evaluate the review risk-floor for a diff.
- *
- * @param input         changed files (+ optional size signals)
- * @param threshold     review cutoff; defaults to {@link DEFAULT_RISK_THRESHOLD}
- */
-export function evaluateRiskFloor(
-  input: RiskFloorInput,
-  threshold: number = DEFAULT_RISK_THRESHOLD,
-): RiskFloorVerdict {
-  const files = (input.filesChanged ?? []).filter((f) => typeof f === 'string' && f.length > 0);
-
-  if (files.length === 0) {
-    return {
-      needs_review: false,
-      score: 0,
-      surface: 'none',
-      reason: 'no files changed',
-    };
-  }
-
-  let topSurface: ReviewSurface = 'none';
-  let topWeight = NONE_WEIGHT;
-  const tripping: string[] = [];
-
-  for (const file of files) {
-    const { surface, weight } = classify(file);
-    if (weight > topWeight) {
-      topWeight = weight;
-      topSurface = surface;
-      tripping.length = 0;
-      tripping.push(file);
-    } else if (weight === topWeight && surface === topSurface && surface !== 'none') {
-      tripping.push(file);
-    }
-  }
-
-  const needs_review = topWeight >= threshold;
-  const reason =
-    topSurface === 'none'
-      ? `no sensitive surface in ${files.length} changed file(s)`
-      : `${topSurface} surface (weight ${topWeight}) in: ${tripping.join(', ')}`;
-
-  return { needs_review, score: topWeight, surface: topSurface, reason };
-}

packages/macp/src/schemas/reflection.v1.schema.json

@@ -1,105 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://mosaicstack.dev/schemas/reflection/reflection.v1.schema.json",
-  "title": "Agent Reflection (v1)",
-  "description": "End-of-run reflection sidecar. Mechanical fields are written by the Stop hook; self-reported fields are merged from an optional agent-supplied input and are null when absent (provenance.degraded=true).",
-  "type": "object",
-  "required": [
-    "schema",
-    "task_ref",
-    "agent",
-    "session_id",
-    "timestamp",
-    "repo",
-    "risk",
-    "files_changed",
-    "provenance"
-  ],
-  "properties": {
-    "schema": {
-      "const": "reflection.v1"
-    },
-    "task_ref": {
-      "type": "string",
-      "description": "Canonical task ref; derived from REFLECTION_TASK_REF or repo+branch."
-    },
-    "agent": {
-      "type": "string",
-      "description": "Persona/runtime id (REFLECTION_AGENT or 'unknown')."
-    },
-    "session_id": {
-      "type": "string",
-      "description": "From the Stop payload session_id, else 'unknown'."
-    },
-    "timestamp": {
-      "type": "string",
-      "format": "date-time",
-      "description": "ISO-8601 UTC capture time."
-    },
-    "repo": {
-      "type": "string",
-      "description": "Repo root basename."
-    },
-    "confidence": {
-      "type": ["number", "null"],
-      "minimum": 0,
-      "maximum": 1,
-      "description": "SELF-REPORTED. Agent's overall confidence; null when not supplied."
-    },
-    "most_likely_wrong": {
-      "type": ["object", "null"],
-      "description": "SELF-REPORTED. The single most-likely way the work is wrong.",
-      "required": ["surface", "description"],
-      "properties": {
-        "surface": { "$ref": "#/$defs/surface" },
-        "description": { "type": "string" }
-      },
-      "additionalProperties": false
-    },
-    "known_not_in_diff": {
-      "type": ["string", "null"],
-      "description": "SELF-REPORTED. What the agent knows that isn't visible in the diff."
-    },
-    "risk": {
-      "type": "object",
-      "description": "MECHANICAL. Output of the diff risk-floor.",
-      "required": ["needs_review", "score", "surface", "reason"],
-      "properties": {
-        "needs_review": { "type": "boolean" },
-        "score": { "type": "number", "minimum": 0, "maximum": 1 },
-        "surface": { "$ref": "#/$defs/surface" },
-        "reason": { "type": "string" }
-      },
-      "additionalProperties": false
-    },
-    "files_changed": {
-      "type": "array",
-      "items": { "type": "string" },
-      "description": "MECHANICAL. git diff name-only."
-    },
-    "provenance": {
-      "type": "object",
-      "required": ["source", "reflection_attempt", "degraded", "reflection_mode"],
-      "properties": {
-        "source": { "const": "stop-hook" },
-        "reflection_attempt": { "type": "integer", "minimum": 1 },
-        "degraded": {
-          "type": "boolean",
-          "description": "True when self-report inputs were missing/unreadable."
-        },
-        "reflection_mode": {
-          "type": "string",
-          "enum": ["off", "solo", "orchestrated"]
-        }
-      },
-      "additionalProperties": false
-    }
-  },
-  "additionalProperties": false,
-  "$defs": {
-    "surface": {
-      "type": "string",
-      "enum": ["auth", "data", "infra", "build", "ui", "test", "docs", "none"]
-    }
-  }
-}

packages/mosaic/framework/defaults/AGENTS.md

@@ -1,24 +1,28 @@
 # Mosaic Global Agent Contract
 
-Canonical file: `~/.config/mosaic/AGENTS.md`. Mandatory behavior for all Mosaic agent runtimes.
+Canonical file: `~/.config/mosaic/AGENTS.md`
 
-This is the THIN CORE — the launcher injects it (plus USER.md, the TOOLS index, and the runtime
+This file defines the mandatory behavior for all Mosaic agent runtimes.
-contract) into every session. It carries only what must be resident to avoid violating a gate.
-Depth lives in guides, read on demand (see Conditional Guide Loading).
 
-## Session Start — Load Order
+## MANDATORY Load Order (No Exceptions)
 
-The core contract is ALREADY in your context (injected by `mosaic` launch). Do not re-read it.
+Before responding to any user message, you MUST read these files in order:
-At session start, additionally:
 
-1. Read `~/.config/mosaic/SOUL.md` (agent identity — small, once).
+1. `~/.config/mosaic/SOUL.md`
-2. Read project-local `AGENTS.md` / `CLAUDE.md` if present.
+2. `~/.config/mosaic/USER.md`
-3. Read guides ONLY as triggered by the Conditional Guide Loading table below. Do NOT pre-load
+3. `~/.config/mosaic/STANDARDS.md`
-   guides you do not need — role-relevant detail is pulled on demand, not up front.
+4. `~/.config/mosaic/AGENTS.md`
-4. When you begin implementation work, read `~/.config/mosaic/guides/E2E-DELIVERY.md` (the full
+5. `~/.config/mosaic/TOOLS.md`
-   delivery procedure: PRD/tracking gates, execution cycle, testing, review, completion).
+6. `~/.config/mosaic/guides/E2E-DELIVERY.md`
-5. `~/.config/mosaic/STANDARDS.md` is available for reference; load it only if the task requires
+7. `~/.config/mosaic/guides/MEMORY.md`
-   standards validation (do NOT halt if missing).
+8. Project-local `AGENTS.md` (if present)
+9. Runtime-specific reference:
+   - Pi: `~/.config/mosaic/runtime/pi/RUNTIME.md`
+   - Claude: `~/.config/mosaic/runtime/claude/RUNTIME.md`
+   - Codex: `~/.config/mosaic/runtime/codex/RUNTIME.md`
+   - OpenCode: `~/.config/mosaic/runtime/opencode/RUNTIME.md`
+
+If any required file is missing, you MUST stop and report the missing file.
 
 ## CRITICAL HARD GATES (Read First)
 
@@ -33,40 +37,56 @@ At session start, additionally:
 9. Do NOT stop at "PR created". Do NOT ask "should I merge?" Do NOT ask "should I close the issue?".
 10. Manual `docker build` / `docker push` for deployment is FORBIDDEN when CI/CD pipelines exist in the repository. CI is the ONLY canonical build path for container images.
 11. Before ANY build or deployment action, you MUST check for existing CI/CD pipeline configuration (`.woodpecker/`, `.woodpecker.yml`, `.github/workflows/`, etc.). If pipelines exist, use them — do not build locally.
-12. The mandatory intake procedure is NOT conditional on perceived task complexity. A "simple" commit-push-deploy task has the same procedural requirements as a multi-file feature. Skipping intake because a task "seems simple" is the most common framework violation.
+12. The mandatory load order and intake procedure are NOT conditional on perceived task complexity. A "simple" commit-push-deploy task has the same procedural requirements as a multi-file feature. Skipping intake because a task "seems simple" is the most common framework violation.
-13. **Merge authority (coordinated work):** when a coordinator/orchestrator session is active for the work, the post-review MERGE GO-AHEAD is the coordinator's to give — once code has passed the required review gates, request the coordinator's go-ahead and merge on their confirmation; do NOT wait on the human owner personally. Solo (uncoordinated) delivery keeps the default: merge without routine confirmation per gates 2 and 9. A "No self-merge" note on a PR means no UNREVIEWED self-merge — it does not suspend coordinator-authorized merges. (Policy: Jason, 2026-06-11.)
 
-## Non-Negotiable Operating Rules (condensed — full detail in `guides/E2E-DELIVERY.md`)
+## Non-Negotiable Operating Rules
 
-- **Source of requirements:** `docs/PRD.md`/`docs/PRD.json` MUST exist before coding. In steered autonomy, make best-guess PRD decisions, mark each `ASSUMPTION:` with rationale, continue. (`guides/PRD.md`)
+1. You MUST create and maintain a task-specific scratchpad for every non-trivial task.
-- **Tracking:** create/maintain a scratchpad and `docs/TASKS.md` for every non-trivial task; keep current through completion.
+2. You MUST follow the end-to-end procedure in `E2E-DELIVERY.md`.
-- **Execution cycle:** `plan → code → test → review → remediate → review → commit → push → greenfield situational test → repeat`. On failure, remediate and re-run from the failed step.
+3. You MUST execute this cycle for implementation work: `plan -> code -> test -> review -> remediate -> review -> commit -> push -> greenfield situational test -> repeat`.
-- **Testing:** run baseline tests before any completion claim. Situational testing is the PRIMARY gate. Risk-based TDD is REQUIRED for bug fixes, security/auth/permission logic, and critical data mutations. (`guides/QA-TESTING.md`)
+4. Before coding begins, `docs/PRD.md` or `docs/PRD.json` MUST exist and be treated as the source of requirements.
-- **Review:** if you modify source code, an independent code review MUST pass before completion. (`guides/CODE-REVIEW.md`)
+5. The main agent MUST prepare or update the PRD using user objectives, constraints, and available project context before implementation starts.
-- **Evidence:** provide explicit verification evidence before any completion claim. Never use workarounds that bypass quality gates.
+6. In steered autonomy mode, the agent MUST make best-guess PRD decisions when needed, mark each with `ASSUMPTION:` and rationale, and continue without waiting for routine user approval.
-- **Secrets & deps:** never hardcode secrets (`guides/VAULT-SECRETS.md`); never use deprecated/unsupported dependencies.
+7. You MUST run baseline tests before claiming completion.
-- **Git strategy:** trunk-based — branch from `main`, merge to `main` via PR only (squash merge), never push directly to `main`.
+8. Situational testing is the PRIMARY validation gate. You MUST run situational tests based on the change surface.
-- **Provider work:** detect platform first, then use `~/.config/mosaic/tools/git/*.sh` wrappers before any raw `gh`/`tea`/`glab`. Create/link issue(s) in `docs/TASKS.md` before coding; if no provider, use `TASKS:<id>` refs.
+9. TDD is risk-based and REQUIRED for bug fixes, security/auth/permission logic, and critical business logic/data mutations (see `~/.config/mosaic/guides/QA-TESTING.md`).
-- **Deployment:** own it when in scope and access is configured. Use immutable image tags (`sha-*`, `vX.Y.Z-rc.N`) with digest-first promotion; `latest` is forbidden as a deployment reference. (`guides/INFRASTRUCTURE.md`)
+10. If you modify source code, you MUST run an independent code review before completion.
-- **Release:** on milestone completion, create + push a release tag and publish a repository release.
+11. You MUST update required documentation for code/API/auth/infra changes per `~/.config/mosaic/guides/DOCUMENTATION.md`.
-- **Documentation:** update required docs for code/API/auth/infra changes; keep `docs/` root clean (scoped folders). (`guides/DOCUMENTATION.md`)
+12. You MUST provide verification evidence before completion claims.
-- **TypeScript:** DTO files (`*.dto.ts`) REQUIRED for module/API boundaries. (`guides/TYPESCRIPT.md`)
+13. You MUST NOT use workarounds that bypass quality gates.
-- **Ownership:** own execution end-to-end (plan→deploy). Human intervention is escalation-only — do not ask the human to do routine coding, review, or repo work.
+14. You MUST NOT hardcode secrets.
-- **Budget:** honor user plan/token budgets; adjust execution strategy to stay within limits.
+15. You MUST NOT use deprecated or unsupported dependencies.
+16. When a milestone is completed, you MUST create and push a release tag and publish a repository release.
+17. For every non-trivial implementation task, you MUST create or update `docs/TASKS.md` before coding and keep it current through completion.
+18. You MUST keep `docs/` root clean and place reports/artifacts in scoped folders per `~/.config/mosaic/guides/DOCUMENTATION.md`.
+19. For TypeScript codebases, DTO files are REQUIRED for module/API boundaries (`*.dto.ts`).
+20. You MUST honor user plan/token budgets: monitor estimated vs used tokens and adjust execution strategy to stay within limits.
+21. You MUST use trunk merge strategy: branch from `main`, merge to `main` via PR only, never push directly to `main`, and use squash merge only.
+22. You MUST own project execution end-to-end: planning, coding, testing, review, remediation, PR/repo operations, release/tag, and deployment when in scope.
+23. Human intervention is escalation-only; do not ask the human to perform routine coding, review, or repository management work.
+24. Deployment ownership is REQUIRED when deployment is in scope and target access is configured.
+25. For container deployments, you MUST use immutable image tags (`sha-*`, `vX.Y.Z-rc.N`) with digest-first promotion; `latest` is forbidden as a deployment reference.
+26. If an external git provider is available (Gitea/GitHub/GitLab), you MUST create or update issue(s) and link them in `docs/TASKS.md` before coding; if unavailable, use `TASKS:<id>` internal refs in `docs/TASKS.md`.
+27. For provider operations (issue/PR/milestone), you MUST detect platform first and use `~/.config/mosaic/tools/git/*.sh` wrappers before any raw provider CLI/API calls.
+28. Direct `gh`/`tea`/`glab` commands are forbidden as first choice when a Mosaic wrapper exists; use raw commands only as documented fallback.
+29. If the mission is orchestration-oriented (contains "orchestrate", issue/milestone coordination, or multi-task execution), you MUST load and follow `~/.config/mosaic/guides/ORCHESTRATOR.md` before taking action.
+30. At session start, you MUST declare the operating mode in your first response before any tool calls or implementation steps.
+31. For orchestration-oriented missions, the first line MUST be exactly: `Now initiating Orchestrator mode...`
+32. For non-orchestrator implementation missions, the first line MUST be exactly: `Now initiating Delivery mode...`
+33. For explicit review-only missions, the first line MUST be exactly: `Now initiating Review mode...`
+34. For source-code delivery through PR workflow, completion is forbidden until the PR is merged to `main`, CI/pipeline status is terminal green, and linked issue/internal task is closed.
+35. If merge/CI/issue-closure operations fail, you MUST report a blocker with the exact failed wrapper command and stop instead of declaring completion.
+36. Before push or PR merge, you MUST run CI queue guard and wait if the project has running/queued pipelines: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge`.
+37. When an active mission is detected at session start (MISSION-MANIFEST.md, TASKS.md, or scratchpads/ present), you MUST load `~/.config/mosaic/guides/ORCHESTRATOR-PROTOCOL.md` and follow the Session Resume Protocol before taking any action.
 
 ## Mode Declaration Protocol (Hard Rule)
 
-At session start, declare exactly one mode as the first line, before any tool call or step:
+At session start, declare one mode before any actions:
 
 1. Orchestration mission: `Now initiating Orchestrator mode...`
 2. Implementation mission: `Now initiating Delivery mode...`
 3. Review-only mission: `Now initiating Review mode...`
 
-Orchestration-oriented = contains "orchestrate", issue/milestone coordination, or multi-task
-execution → also load `guides/ORCHESTRATOR.md` before acting. If an active mission is detected at
-session start (MISSION-MANIFEST.md, TASKS.md, or scratchpads/ present) → load
-`guides/ORCHESTRATOR-PROTOCOL.md` and follow the Session Resume Protocol before any action.
-
 ## Steered Autonomy Escalation Triggers
 
 Only interrupt the human when one of these is true:
@@ -77,69 +97,136 @@ Only interrupt the human when one of these is true:
 4. Legal/compliance/security constraints are unknown and materially affect delivery.
 5. Objectives are mutually conflicting and cannot be resolved from PRD, repo, or prior decisions.
 
-## Conditional Guide Loading (role/task-driven — load only what the task needs)
+## Conditional Guide Loading
 
-| Task                                               | Guide                              |
+Load additional guides when the task requires them.
-| -------------------------------------------------- | ---------------------------------- |
-| Project bootstrap                                  | `guides/BOOTSTRAP.md`              |
-| PRD creation / requirements                        | `guides/PRD.md`                    |
-| Orchestration flow                                 | `guides/ORCHESTRATOR.md`           |
-| Mission lifecycle / multi-session orchestration    | `guides/ORCHESTRATOR-PROTOCOL.md`  |
-| Orchestrator estimation heuristics                 | `guides/ORCHESTRATOR-LEARNINGS.md` |
-| Frontend changes                                   | `guides/FRONTEND.md`               |
-| Backend/API changes                                | `guides/BACKEND.md`                |
-| Auth/authorization                                 | `guides/AUTHENTICATION.md`         |
-| CI/CD changes                                      | `guides/CI-CD-PIPELINES.md`        |
-| Infrastructure/DevOps/deployment                   | `guides/INFRASTRUCTURE.md`         |
-| Code review work                                   | `guides/CODE-REVIEW.md`            |
-| TypeScript strict typing                           | `guides/TYPESCRIPT.md`             |
-| QA / test strategy                                 | `guides/QA-TESTING.md`             |
-| Documentation (any code/API/auth/infra change)     | `guides/DOCUMENTATION.md`          |
-| Secrets / vault usage                              | `guides/VAULT-SECRETS.md`          |
-| Tool/credential reference (service CLIs, wrappers) | `guides/TOOLS-REFERENCE.md`        |
-| Memory protocol (OpenBrain capture/recall)         | `guides/MEMORY.md`                 |
 
-## Subagent Model Selection (Cost — Hard Rule)
+| Task                                                    | Required Guide                                      |
+| ------------------------------------------------------- | --------------------------------------------------- |
+| Project bootstrap                                       | `~/.config/mosaic/guides/BOOTSTRAP.md`              |
+| PRD creation and requirements definition                | `~/.config/mosaic/guides/PRD.md`                    |
+| Orchestration flow                                      | `~/.config/mosaic/guides/ORCHESTRATOR.md`           |
+| Frontend changes                                        | `~/.config/mosaic/guides/FRONTEND.md`               |
+| Backend/API changes                                     | `~/.config/mosaic/guides/BACKEND.md`                |
+| Documentation changes or any code/API/auth/infra change | `~/.config/mosaic/guides/DOCUMENTATION.md`          |
+| Authentication/authorization                            | `~/.config/mosaic/guides/AUTHENTICATION.md`         |
+| CI/CD changes                                           | `~/.config/mosaic/guides/CI-CD-PIPELINES.md`        |
+| Infrastructure/DevOps                                   | `~/.config/mosaic/guides/INFRASTRUCTURE.md`         |
+| Code review work                                        | `~/.config/mosaic/guides/CODE-REVIEW.md`            |
+| TypeScript strict typing                                | `~/.config/mosaic/guides/TYPESCRIPT.md`             |
+| QA and test strategy                                    | `~/.config/mosaic/guides/QA-TESTING.md`             |
+| Secrets and vault usage                                 | `~/.config/mosaic/guides/VAULT-SECRETS.md`          |
+| Orchestrator estimation heuristics                      | `~/.config/mosaic/guides/ORCHESTRATOR-LEARNINGS.md` |
+| Mission lifecycle / multi-session orchestration         | `~/.config/mosaic/guides/ORCHESTRATOR-PROTOCOL.md`  |
 
-Select the cheapest model capable of the task; do NOT default to the most expensive. Omitting the
+## Embedded Delivery Cycle (Hard Rule)
-tier defaults to the parent (usually opus) and wastes budget.
 
-- **haiku** — search/grep/glob, codebase exploration, status/health checks, one-line mechanical fixes.
+- Implementation work MUST follow the embedded execution cycle:
-- **sonnet** — code review, lint, test writing/fixing, standard feature implementation.
+  - `plan -> code -> test -> review -> remediate -> review -> commit -> push -> greenfield situational test -> repeat`
-- **opus** — complex architecture / multi-file refactors, security/auth logic, ambiguous design decisions.
+- If a step fails, you MUST remediate and re-run from the relevant step before proceeding.
 
-Start cheapest; escalate only when the task genuinely needs deeper reasoning. Runtime syntax for
+## Sequential-Thinking MCP (Hard Requirement)
-specifying tier is in the runtime contract.
+
+- `sequential-thinking` MCP server is REQUIRED for Mosaic operation.
+- Installation and configuration are managed by Mosaic bootstrap and runtime linking.
+- If sequential-thinking is unavailable, you MUST report the failure and stop planning-intensive execution.
+
+## Subagent Model Selection (Cost Optimization — Hard Rule)
+
+When delegating work to subagents, you MUST select the cheapest model capable of completing the task. Do NOT default to the most expensive model for every delegation.
+
+| Task Type                                     | Model Tier | Rationale                                               |
+| --------------------------------------------- | ---------- | ------------------------------------------------------- |
+| File search, grep, glob, codebase exploration | **haiku**  | Read-only, pattern matching, no reasoning depth needed  |
+| Status checks, health monitoring, heartbeat   | **haiku**  | Structured API calls, pass/fail output                  |
+| Simple code fixes (typos, rename, one-liner)  | **haiku**  | Minimal reasoning, mechanical changes                   |
+| Code review, lint, style checks               | **sonnet** | Needs judgment but not deep architectural reasoning     |
+| Test writing, test fixes                      | **sonnet** | Pattern-based, moderate complexity                      |
+| Standard feature implementation               | **sonnet** | Good balance of capability and cost for most coding     |
+| Complex architecture, multi-file refactors    | **opus**   | Requires deep reasoning, large context, design judgment |
+| Security review, auth logic                   | **opus**   | High-stakes reasoning where mistakes are costly         |
+| Ambiguous requirements, design decisions      | **opus**   | Needs nuanced judgment and tradeoff analysis            |
+
+**Decision rule**: Start with the cheapest viable tier. Only escalate if the task genuinely requires deeper reasoning — not as a safety default. Most coding tasks are sonnet-tier. Reserve opus for work where wrong answers are expensive.
+
+**Runtime-specific syntax**: See the runtime reference for how to specify model tier when spawning subagents (e.g., Claude Code Task tool `model` parameter).
 
 ## Superpowers Enforcement (Hard Rule)
 
-Skills, hooks, MCP tools, and plugins are force multipliers you MUST use when applicable;
+Mosaic provides capabilities beyond basic code editing: **skills**, **hooks**, **MCP tools**, and **plugins**. These are not optional extras — they are force multipliers that agents MUST actively use when applicable. Under-utilization of superpowers is a framework violation.
-under-utilization is a framework violation.
 
-- **Skills:** before implementation, scan `~/.config/mosaic/skills/` and load any matching the task
+### Skills
-  domain (e.g. `nestjs-best-practices` for NestJS). Include skill loading in worker kickstarts. Do
-  not load unrelated skills.
-- **Hooks:** never bypass or suppress hook output; treat hook failures like failing tests and fix
-  them. If a hook is wrong, report it as a framework issue — do not work around it.
-- **MCP:** sequential-thinking is REQUIRED for planning/architecture/multi-step reasoning. OpenBrain
-  (`capture`/`search`/`recent`) is the cross-agent memory layer — search at session start, capture
-  what you learn. Use web/browser/research MCP tools instead of asking the user to look things up.
-- **Plugins:** use code-review / pr-review / architecture plugins proactively after significant
-  changes and before opening a PR — do not wait to be asked.
-- **Self-evolution:** capture recurring patterns (`framework-improvement`), missing tooling
-  (`tooling-gap`), and value-less friction (`framework-friction`) to OpenBrain.
 
-## Other Hard Rules
+Skills are domain-specific instruction sets in `~/.config/mosaic/skills/` that encode best practices, patterns, and guardrails. They are loaded into agents via the runtime's skill mechanism (e.g., Claude Code slash commands, Pi `--skill` flag).
 
-- **Sequential-thinking MCP** is REQUIRED. If unavailable, report the failure and stop planning-intensive execution.
+**Rules:**
-- **Missing core file:** if `AGENTS.md`, `SOUL.md`, or the runtime contract is missing, stop and report it.
 
-## Session Closure
+1. Before starting implementation, scan available skills (`ls ~/.config/mosaic/skills/`) and load any that match the task domain.
+2. When a skill exists for the technology being used (e.g., `nestjs-best-practices` for NestJS work), you MUST load it.
+3. When spawning workers, include skill loading in the kickstart prompt.
+4. If you complete a task without loading a relevant available skill, that is a quality gap.
 
-Before closing an implementation task, confirm: required + situational tests passed (primary gate);
+### Hooks
-aligned to `docs/PRD.md`; acceptance criteria mapped to evidence; independent code review passed (if
+
-code changed); required docs updated; scratchpad updated with decisions/results/risks; explicit
+Hooks provide automated quality gates (lint, format, typecheck) that fire on file edits. They are configured in the runtime settings and run automatically.
-completion evidence provided. For PR-workflow delivery: confirm merged PR number + merge commit on
+
-`main`, terminal-green CI, and linked issue closed (or `docs/TASKS.md` equivalent). If any of those
+**Rules:**
-are blocked by access/tooling failure, return `blocked` with the exact failed wrapper command — do
+
-not claim completion. Full checklist: `guides/E2E-DELIVERY.md`.
+1. Do NOT bypass or suppress hook output. If a hook reports errors, fix them before proceeding.
+2. Hook failures are immediate feedback — treat them like failing tests.
+3. If a hook is consistently failing on valid code, report it as a framework issue rather than working around it.
+
+### MCP Tools
+
+MCP servers extend agent capabilities with external integrations (sequential-thinking, web search, memory, browser automation, etc.). Available MCP tools are listed at session start.
+
+**Rules:**
+
+1. **sequential-thinking** is REQUIRED for planning, architecture, and multi-step reasoning. Use it — do not skip structured thinking for complex decisions.
+2. **OpenBrain** (`capture`, `search`, `recent`) is the cross-agent memory layer. Capture discoveries and search for prior context at session start.
+3. When a task involves web research, browser testing, or external data, use the available MCP tools (web-search, chrome-devtools, web-reader) rather than asking the user to look things up.
+4. Check available MCP tools at session start and use them proactively throughout the session.
+
+### Plugins (Runtime-Specific)
+
+Runtime plugins (e.g., Claude Code's `feature-dev`, `pr-review-toolkit`, `code-review`) provide specialized agent capabilities like code review, architecture analysis, and test coverage analysis.
+
+**Rules:**
+
+1. After completing a significant code change, use code review plugins proactively — do not wait for the user to ask.
+2. Before creating a PR, use PR review plugins to catch issues early.
+3. When designing architecture, use planning/architecture plugins for structured analysis.
+
+### Self-Evolution
+
+The Mosaic framework should improve over time based on usage patterns:
+
+1. When you discover a recurring pattern that should be codified, capture it to OpenBrain with `type: "framework-improvement"`.
+2. When a hook, skill, or tool is missing for a common task, capture the gap to OpenBrain with `type: "tooling-gap"`.
+3. When a framework rule causes friction without adding value, capture the observation to OpenBrain with `type: "framework-friction"`.
+
+These captures feed the framework's continuous improvement cycle.
+
+## Skills Policy
+
+- Load skills that match the active task domain before starting implementation.
+- Do not load unrelated skills.
+- Follow skill trigger rules from the active runtime instruction layer.
+- Actively check `~/.config/mosaic/skills/` for applicable skills rather than passively waiting for them to be mentioned.
+
+## Session Closure Requirement
+
+Before closing any implementation task:
+
+1. Confirm required tests passed.
+2. Confirm situational tests passed (primary gate).
+3. Confirm implementation is aligned to the active `docs/PRD.md` or `docs/PRD.json`.
+4. Confirm acceptance criteria are mapped to verification evidence.
+5. If source code changed, confirm independent code review passed.
+6. Confirm required documentation updates were completed and reviewed.
+7. Update scratchpad with decisions, results, and open risks.
+8. Provide explicit completion evidence.
+9. If source code changed and external provider is available, confirm merged PR number and merge commit on `main`.
+10. Confirm CI/pipeline status is terminal green for the merged change (or merged PR head when equivalent).
+11. Confirm linked issue is closed (or internal `docs/TASKS.md` equivalent is closed when no provider exists).
+12. If any of items 9-11 are blocked by access/tooling failure, return `blocked` status with exact failed wrapper command and do not claim completion.

packages/mosaic/framework/defaults/STANDARDS.md

@@ -27,16 +27,6 @@ Master/slave model:
 - Do not perform destructive git/file actions without explicit instruction.
 - Browser automation (Playwright, Cypress, Puppeteer) MUST run in headless mode. Never launch a visible browser — it collides with the user's display and active session.
 
-### Secrets handling (HARD RULE)
-
-- Vault is the canonical source-of-truth for every secret in every environment. No exceptions.
-- For k8s workloads, the default read path is **External Secrets Operator → k8s Secret → env var** (`secretKeyRef`). The app reads standard env vars; no Vault client in app code.
-- Direct-Vault clients in application code are **opt-in only**, justified per-app by a documented dynamic-secrets requirement (e.g., DB rotation, AWS STS). Default to ESO. Document the justification in the project's README under "Secrets architecture".
-- `${VAR:-default}` fallback syntax in any deployment configuration (compose, k8s manifests, Helm values, env files committed to git) is **forbidden** for required values. Use `${VAR:?VAR is required}` to fast-fail. Defaults are allowed only for true conveniences (e.g. `${PORT:-3000}`) and MUST be tagged `# safe-default: <reason>` so a reviewer can confirm the intent.
-- `.env` files in production deployment paths are **forbidden**. `.env.example` and `.env` in local-dev paths are fine.
-- App startup MUST validate required secrets against a schema (zod / pydantic / equivalent) and exit non-zero on missing required values. Never run with defaulted weak fallbacks.
-- New apps: bootstrap checklist (see `~/.config/mosaic/guides/BOOTSTRAP.md`) MUST include Vault path provisioning + `ExternalSecret` manifest + README declaring the Vault path and required keys.
-
 ## Session Lifecycle Contract
 
 - Start: `scripts/agent/session-start.sh`

packages/mosaic/framework/defaults/TOOLS.md

@@ -1,87 +1,257 @@
-# Machine Tools — Index
+# Machine-Level Tool Reference
 
-Tool suites live at `~/.config/mosaic/tools/<suite>/`. This is the index only.
+Centralized reference for tools, credentials, and CLI patterns available across all projects.
-**Full CLI signatures, flags, and examples: `~/.config/mosaic/guides/TOOLS-REFERENCE.md`** —
-read it (or the relevant service guide) when your task actually touches that service.
 Project-specific tooling belongs in the project's `AGENTS.md`, not here.
 
-## ⚡ Most-used fleet tools (reach for these FIRST — don't hand-roll)
+All tool suites are located at `~/.config/mosaic/tools/`.
 
-You are a Mosaic fleet agent. These cover the highest-frequency cross-agent and git-provider
+## Tool Suites
-tasks — use them before improvising with raw `tmux send-keys`, raw `tea`/`gh`/`glab`, or `curl`.
 
-**1. Message another agent** → `tools/tmux/agent-send.sh` (NOT raw `tmux send-keys`):
+### Git Wrappers (Use First)
+
+Mosaic wrappers at `~/.config/mosaic/tools/git/*.sh` handle platform detection and edge cases. Always use these before raw CLI commands.
 
 ```bash
-tools/tmux/agent-send.sh -s <target-session> -m "message"   # or -f <file> to send a file's contents
+# Issues
+~/.config/mosaic/tools/git/issue-create.sh
+~/.config/mosaic/tools/git/issue-close.sh
+
+# PRs
+~/.config/mosaic/tools/git/pr-create.sh
+~/.config/mosaic/tools/git/pr-merge.sh
+
+# Milestones
+~/.config/mosaic/tools/git/milestone-create.sh
+
+# CI queue guard (required before push/merge)
+~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge
 ```
 
-The coordinator session is `mos-claude` — send status, findings, and questions there.
+### Code Review (Codex)
-
-**2. Issues / PRs / milestones** → `tools/git/*.sh` wrappers (before raw `tea`/`gh`/`glab`):
 
 ```bash
-tools/git/pr-create.sh ...   tools/git/issue-create.sh ...   tools/git/pr-merge.sh ...
+~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
-tools/git/ci-queue-wait.sh --purpose push|merge   # REQUIRED before any push/merge
+~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
 ```
 
-**GITEA_LOGIN gotcha** — the wrappers default to login `mosaicstack`; on a USC repo that fails with
+### Infrastructure — Portainer
-`gitea / Error: GetUserByName ... not found`. Pick the login from the repo's `origin` host first:
 
-| origin host           | login                                    |
+```bash
-| --------------------- | ---------------------------------------- |
+~/.config/mosaic/tools/portainer/stack-status.sh -n <stack-name>
-| `git.uscllc.com`      | `export GITEA_LOGIN=usc`                 |
+~/.config/mosaic/tools/portainer/stack-redeploy.sh -n <stack-name>
-| `git.mosaicstack.dev` | default `mosaicstack` (no export needed) |
+~/.config/mosaic/tools/portainer/stack-list.sh
+~/.config/mosaic/tools/portainer/endpoint-list.sh
+```
 
-## Suites (use wrappers first)
+### Infrastructure — Coolify (DEPRECATED)
 
-| Suite      | Path                                             | Purpose                                                                  |
+> Coolify has been superseded by Portainer Docker Swarm in this stack.
-| ---------- | ------------------------------------------------ | ------------------------------------------------------------------------ |
+> Tools remain for reference but should not be used for new deployments.
-| tmux       | `tools/tmux/agent-send.sh`                       | inter-agent messaging (see "Most-used" above)                            |
-| git        | `tools/git/*.sh`                                 | issues, PRs, milestones, CI queue guard (platform-auto-detected)         |
-| woodpecker | `tools/woodpecker/*.sh`                          | CI pipelines (`-a mosaic`\|`usc`; match git remote host)                 |
-| portainer  | `tools/portainer/*.sh`                           | Docker Swarm stacks (status/redeploy/list)                               |
-| coolify    | `tools/coolify/*.sh`                             | **DEPRECATED** — superseded by Portainer; do not use for new deployments |
-| authentik  | `tools/authentik/*.sh`                           | identity (users/groups/apps/flows)                                       |
-| cloudflare | `tools/cloudflare/*.sh`                          | DNS (zones/records; `-a` instance)                                       |
-| glpi       | `tools/glpi/*.sh`                                | IT tickets/computers/users                                               |
-| health     | `tools/health/stack-health.sh`                   | service health checks                                                    |
-| codex      | `tools/codex/*.sh`                               | code/security review (`--uncommitted`)                                   |
-| openbrain  | `tools/openbrain/*`, `tools/openbrain_client.py` | semantic memory (see below)                                              |
-| excalidraw | MCP `mcp__excalidraw__*`                         | diagram export/generation                                                |
 
-Git wrappers are MANDATORY-first for issue/PR/milestone ops (see AGENTS.md hard gates 6–8).
+```bash
-Queue guard before push/merge: `tools/git/ci-queue-wait.sh --purpose push|merge`.
+# DEPRECATED — do not use for new deployments
+~/.config/mosaic/tools/coolify/project-list.sh
+~/.config/mosaic/tools/coolify/service-list.sh
+~/.config/mosaic/tools/coolify/service-status.sh -u <uuid>
+~/.config/mosaic/tools/coolify/deploy.sh -u <uuid>
+~/.config/mosaic/tools/coolify/env-set.sh -u <uuid> -k KEY -v VALUE
+```
 
-## Credentials
+### Identity — Authentik
 
-`source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials <service>`
+```bash
-Supported: portainer, coolify (deprecated), authentik, glpi, github, gitea-mosaicstack,
+~/.config/mosaic/tools/authentik/user-list.sh
-gitea-usc, woodpecker, cloudflare, turbo-cache, openbrain. Never expose or commit values.
+~/.config/mosaic/tools/authentik/user-create.sh -u <username> -n <name> -e <email>
+~/.config/mosaic/tools/authentik/group-list.sh
+~/.config/mosaic/tools/authentik/app-list.sh
+~/.config/mosaic/tools/authentik/flow-list.sh
+~/.config/mosaic/tools/authentik/admin-status.sh
+```
 
-## OpenBrain — Semantic Memory (PRIMARY) — capture when you LEARN, never when you DO
+### CI/CD — Woodpecker
 
-Primary cross-agent memory (pgvector). Capture decisions/gotchas/preferences/patterns; never task
+Multi-instance support: `-a <instance>` selects a named instance. Omit `-a` to use the default from `woodpecker.default` in credentials.json.
-starts, commits, PRs, test results, or file edits. At session start, `search` + `recent` to load
-prior context. MCP (`mcp__openbrain__capture/search/recent/stats`) preferred when connected; else
-REST/`tools/openbrain_client.py`. Full protocol: `guides/MEMORY.md`.
 
-**MANDATORY jarvis-brain rule:** when working in `~/src/jarvis-brain`, NEVER capture project data,
+| Instance           | URL                | Serves                             |
-meeting notes, status, timelines, or task completions to OpenBrain — the flat files
+| ------------------ | ------------------ | ---------------------------------- |
-(`data/projects/*.json`, `data/tasks/*.json`) are the SSOT (use `tools/brain.py` + direct JSON
+| `mosaic` (default) | ci.mosaicstack.dev | Mosaic repos (git.mosaicstack.dev) |
-edits). OpenBrain there is for agent meta-observations ONLY (tooling gotchas, framework learnings,
+| `usc`              | ci.uscllc.com      | USC repos (git.uscllc.com)         |
-cross-project patterns). Violating this creates duplicate, divergent data.
+
+```bash
+# List recent pipelines
+~/.config/mosaic/tools/woodpecker/pipeline-list.sh [-r owner/repo] [-a instance]
+
+# Check latest or specific pipeline status
+~/.config/mosaic/tools/woodpecker/pipeline-status.sh [-r owner/repo] [-n number] [-a instance]
+
+# Trigger a build
+~/.config/mosaic/tools/woodpecker/pipeline-trigger.sh [-r owner/repo] [-b branch] [-a instance]
+```
+
+Instance selection rule: match `-a` to the git remote host of the target repo. If the repo is on `git.uscllc.com`, use `-a usc`. If on `git.mosaicstack.dev`, use `-a mosaic` (or omit, since it's the default).
+
+### DNS — Cloudflare
+
+Multi-instance support: `-a <instance>` selects a named instance (e.g. `personal`, `work`). Omit `-a` to use the default from `cloudflare.default` in credentials.json.
+
+```bash
+# List zones (domains)
+~/.config/mosaic/tools/cloudflare/zone-list.sh [-a instance]
+
+# List DNS records (zone by name or ID)
+~/.config/mosaic/tools/cloudflare/record-list.sh -z <zone> [-a instance] [-t type] [-n name]
+
+# Create DNS record
+~/.config/mosaic/tools/cloudflare/record-create.sh -z <zone> -t <type> -n <name> -c <content> [-a instance] [-p] [-l ttl] [-P priority]
+
+# Update DNS record
+~/.config/mosaic/tools/cloudflare/record-update.sh -z <zone> -r <record-id> -t <type> -n <name> -c <content> [-a instance] [-p] [-l ttl]
+
+# Delete DNS record
+~/.config/mosaic/tools/cloudflare/record-delete.sh -z <zone> -r <record-id> [-a instance]
+```
+
+### IT Service — GLPI
+
+```bash
+~/.config/mosaic/tools/glpi/ticket-list.sh
+~/.config/mosaic/tools/glpi/ticket-create.sh -t <title> -c <content>
+~/.config/mosaic/tools/glpi/computer-list.sh
+~/.config/mosaic/tools/glpi/user-list.sh
+```
+
+### Health Check
+
+```bash
+# Check all configured services
+~/.config/mosaic/tools/health/stack-health.sh
+
+# Check a specific service
+~/.config/mosaic/tools/health/stack-health.sh -s portainer
+
+# JSON output for automation
+~/.config/mosaic/tools/health/stack-health.sh -f json
+```
+
+### Shared Credential Loader
+
+```bash
+# Source in any script to load service credentials
+source ~/.config/mosaic/tools/_lib/credentials.sh
+load_credentials <service-name>
+# Supported: portainer, coolify, authentik, glpi, github, gitea-mosaicstack, gitea-usc, woodpecker, cloudflare, turbo-cache, openbrain
+```
+
+### OpenBrain — Semantic Memory (PRIMARY)
+
+Self-hosted semantic brain backed by pgvector. Primary shared memory layer for all agents across all sessions and harnesses. Stores and retrieves decisions, context, and observations via semantic search.
+
+**MANDATORY jarvis-brain rule:** When working in `~/src/jarvis-brain`, NEVER capture project data, meeting notes, status updates, timeline decisions, or task completions to OpenBrain. The flat files (`data/projects/*.json`, `data/tasks/*.json`) are the SSOT — use `tools/brain.py` and direct JSON edits. OpenBrain is for agent meta-observations ONLY (tooling gotchas, framework learnings, cross-project patterns). Violating this creates duplicate, divergent data.
+
+**Credentials:** `load_credentials openbrain` → exports `OPENBRAIN_URL`, `OPENBRAIN_TOKEN`
+
+Configure in your credentials.json:
+
+```json
+"openbrain": {
+  "url": "https://<your-openbrain-host>",
+  "api_key": "<your-api-key>"
+}
+```
+
+**REST API** (any language, any harness):
+
+```bash
+source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials openbrain
+
+# Search by meaning
+curl -s -X POST -H "Authorization: Bearer $OPENBRAIN_TOKEN" -H "Content-Type: application/json" \
+  -d '{"query": "your search", "limit": 5}' "$OPENBRAIN_URL/v1/search"
+
+# Capture a thought
+curl -s -X POST -H "Authorization: Bearer $OPENBRAIN_TOKEN" -H "Content-Type: application/json" \
+  -d '{"content": "...", "source": "agent-name", "metadata": {}}' "$OPENBRAIN_URL/v1/thoughts"
+
+# Recent activity
+curl -s -H "Authorization: Bearer $OPENBRAIN_TOKEN" "$OPENBRAIN_URL/v1/thoughts/recent?limit=5"
+
+# Stats
+curl -s -H "Authorization: Bearer $OPENBRAIN_TOKEN" "$OPENBRAIN_URL/v1/stats"
+```
+
+**Python client** (if jarvis-brain is available on PYTHONPATH):
+
+```bash
+python tools/openbrain_client.py search "topic"
+python tools/openbrain_client.py capture "decision or observation" --source agent-name
+python tools/openbrain_client.py recent --limit 5
+python tools/openbrain_client.py stats
+```
+
+**MCP (Claude Code sessions):** When connected, `mcp__openbrain__capture/search/recent/stats` tools are available natively — prefer those over CLI when in a Claude session.
+
+**Rule: capture when you LEARN something. Never when you DO something.**
+
+| Trigger                                   | Action                                    | Retention             |
+| ----------------------------------------- | ----------------------------------------- | --------------------- |
+| Session start                             | `search` + `recent` to load prior context | —                     |
+| Architectural or tooling decision made    | Capture with rationale                    | `long` or `permanent` |
+| Gotcha or non-obvious behavior discovered | Capture immediately                       | `medium`              |
+| User preference stated or confirmed       | Capture                                   | `permanent`           |
+| Cross-project pattern identified          | Capture                                   | `permanent`           |
+| Prior decision superseded                 | UPDATE existing thought                   | (keep tier)           |
+
+**Never capture:** task started, commit pushed, PR opened, test results, file edits, CI status.
+
+Full protocol and cleanup tools: `~/.config/mosaic/guides/MEMORY.md`
+Smart capture wrapper (enforces schema + dedup): `~/.config/mosaic/tools/openbrain/capture.sh`
+
+### Excalidraw — Diagram Export (MCP)
+
+Headless `.excalidraw` → SVG export via `@excalidraw/excalidraw`. Available as MCP tools in Claude Code sessions.
+
+**MCP tools (when connected):**
+
+| Tool                                      | Input                                         | Output                                               |
+| ----------------------------------------- | --------------------------------------------- | ---------------------------------------------------- |
+| `mcp__excalidraw__excalidraw_to_svg`      | `elements` JSON string + optional `app_state` | SVG string                                           |
+| `mcp__excalidraw__excalidraw_file_to_svg` | `file_path` to `.excalidraw`                  | SVG string + writes `.svg` alongside                 |
+| `mcp__excalidraw__list_diagrams`          | (none)                                        | Available templates (requires `EXCALIDRAW_GEN_PATH`) |
+| `mcp__excalidraw__generate_diagram`       | `name`, optional `output_path`                | Path to generated `.excalidraw`                      |
+| `mcp__excalidraw__generate_and_export`    | `name`, optional `output_path`                | Paths to `.excalidraw` and `.svg`                    |
+
+**Diagram generation** (`list_diagrams`, `generate_diagram`, `generate_and_export`) requires `EXCALIDRAW_GEN_PATH` env var pointing to `excalidraw_gen.py`. Set in environment or shell profile:
+
+```bash
+export EXCALIDRAW_GEN_PATH="$HOME/src/jarvis-brain/tools/excalidraw_export/excalidraw_gen.py"
+```
+
+**Manual registration:**
+
+```bash
+mosaic-ensure-excalidraw           # install deps + register with Claude
+mosaic-ensure-excalidraw --check   # verify registration
+```
 
 ## Git Providers
 
-| Host                | Instance         | CI                               |
+| Instance                      | URL | CLI | Purpose |
-| ------------------- | ---------------- | -------------------------------- |
+| ----------------------------- | --- | --- | ------- |
-| git.mosaicstack.dev | mosaic (default) | ci.mosaicstack.dev (`-a mosaic`) |
+| (add your git providers here) |     |     |         |
-| git.uscllc.com      | usc              | ci.uscllc.com (`-a usc`)         |
 
-Match Woodpecker `-a` and credential instance to the target repo's git remote host.
+## Credentials
+
+**Location:** (configure your credential file path)
+**Loader:** `source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials <service>`
+
+**Never expose actual values. Never commit credential files.**
+
+## CLI Gotchas
+
+(Add platform-specific CLI gotchas as you discover them.)
 
 ## Safety Defaults
 
-- Prefer `trash` over `rm` when available — recoverable beats gone forever.
+- Prefer `trash` over `rm` when available — recoverable beats gone forever
-- Never run destructive commands without explicit instruction.
+- Never run destructive commands without explicit instruction
+- Write it down — "mental notes" don't survive session restarts; files do

packages/mosaic/framework/guides/BOOTSTRAP.md

@@ -453,26 +453,6 @@ Initialize standard labels and the first pre-MVP milestone:
 
 ---
 
-## Secrets Bootstrap (Required for Every New App)
-
-Every new application MUST complete the following secrets bootstrap before deploying to any non-local environment. This is a hard gate — deployment without completed secrets bootstrap is forbidden.
-
-### Secrets bootstrap checklist
-
-- [ ] Vault path created: `vault kv put secret/k3s/<app>/ ...` with all required secret fields
-- [ ] Required secrets listed in project README under a "Secrets architecture" section, including:
-  - Vault path(s) used
-  - All required secret keys and their purpose
-  - Whether the app uses ESO bridge (default) or Direct-Vault (opt-in, with justification)
-- [ ] `external-secret.yaml` manifest committed to repo's `deploy/` or `k8s/` directory
-- [ ] Deployment YAML references the synced k8s Secret via `secretKeyRef` (not raw env vars or `.env` files)
-- [ ] App startup has schema-based validation for all required env vars (zod / pydantic / envconfig equivalent) that exits non-zero on missing required values
-- [ ] Direct-Vault opt-in (if applicable): justification documented in README + AppRole provisioned + bootstrap credentials stored in Vault and synced via a separate `ExternalSecret`
-
-See `~/.config/mosaic/guides/VAULT-SECRETS.md` for full worked examples of the ESO bridge pattern, the Direct-Vault opt-in pattern, and the forbidden antipatterns.
-
----
-
 ## Checklist
 
 After bootstrapping, verify:

packages/mosaic/framework/guides/E2E-DELIVERY.md

@@ -88,11 +88,6 @@ For implementation work, you MUST run this cycle in order:
 
 ### Post-PR Hard Gate (Execute Sequentially, No Exceptions)
 
-> **Merge authority:** if a coordinator/orchestrator session is active for this
-> work, obtain the coordinator's merge go-ahead after review passes, then run
-> the gate (AGENTS.md hard gate "Merge authority"). Solo delivery proceeds
-> without asking.
-
 1. `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`
 2. `~/.config/mosaic/tools/git/pr-merge.sh -n <PR_NUMBER> -m squash`
 3. `~/.config/mosaic/tools/git/pr-ci-wait.sh -n <PR_NUMBER>`

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

@@ -1,257 +0,0 @@
-# Machine-Level Tool Reference
-
-Centralized reference for tools, credentials, and CLI patterns available across all projects.
-Project-specific tooling belongs in the project's `AGENTS.md`, not here.
-
-All tool suites are located at `~/.config/mosaic/tools/`.
-
-## Tool Suites
-
-### Git Wrappers (Use First)
-
-Mosaic wrappers at `~/.config/mosaic/tools/git/*.sh` handle platform detection and edge cases. Always use these before raw CLI commands.
-
-```bash
-# Issues
-~/.config/mosaic/tools/git/issue-create.sh
-~/.config/mosaic/tools/git/issue-close.sh
-
-# PRs
-~/.config/mosaic/tools/git/pr-create.sh
-~/.config/mosaic/tools/git/pr-merge.sh
-
-# Milestones
-~/.config/mosaic/tools/git/milestone-create.sh
-
-# CI queue guard (required before push/merge)
-~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge
-```
-
-### Code Review (Codex)
-
-```bash
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
-```
-
-### Infrastructure — Portainer
-
-```bash
-~/.config/mosaic/tools/portainer/stack-status.sh -n <stack-name>
-~/.config/mosaic/tools/portainer/stack-redeploy.sh -n <stack-name>
-~/.config/mosaic/tools/portainer/stack-list.sh
-~/.config/mosaic/tools/portainer/endpoint-list.sh
-```
-
-### Infrastructure — Coolify (DEPRECATED)
-
-> Coolify has been superseded by Portainer Docker Swarm in this stack.
-> Tools remain for reference but should not be used for new deployments.
-
-```bash
-# DEPRECATED — do not use for new deployments
-~/.config/mosaic/tools/coolify/project-list.sh
-~/.config/mosaic/tools/coolify/service-list.sh
-~/.config/mosaic/tools/coolify/service-status.sh -u <uuid>
-~/.config/mosaic/tools/coolify/deploy.sh -u <uuid>
-~/.config/mosaic/tools/coolify/env-set.sh -u <uuid> -k KEY -v VALUE
-```
-
-### Identity — Authentik
-
-```bash
-~/.config/mosaic/tools/authentik/user-list.sh
-~/.config/mosaic/tools/authentik/user-create.sh -u <username> -n <name> -e <email>
-~/.config/mosaic/tools/authentik/group-list.sh
-~/.config/mosaic/tools/authentik/app-list.sh
-~/.config/mosaic/tools/authentik/flow-list.sh
-~/.config/mosaic/tools/authentik/admin-status.sh
-```
-
-### CI/CD — Woodpecker
-
-Multi-instance support: `-a <instance>` selects a named instance. Omit `-a` to use the default from `woodpecker.default` in credentials.json.
-
-| Instance           | URL                | Serves                             |
-| ------------------ | ------------------ | ---------------------------------- |
-| `mosaic` (default) | ci.mosaicstack.dev | Mosaic repos (git.mosaicstack.dev) |
-| `usc`              | ci.uscllc.com      | USC repos (git.uscllc.com)         |
-
-```bash
-# List recent pipelines
-~/.config/mosaic/tools/woodpecker/pipeline-list.sh [-r owner/repo] [-a instance]
-
-# Check latest or specific pipeline status
-~/.config/mosaic/tools/woodpecker/pipeline-status.sh [-r owner/repo] [-n number] [-a instance]
-
-# Trigger a build
-~/.config/mosaic/tools/woodpecker/pipeline-trigger.sh [-r owner/repo] [-b branch] [-a instance]
-```
-
-Instance selection rule: match `-a` to the git remote host of the target repo. If the repo is on `git.uscllc.com`, use `-a usc`. If on `git.mosaicstack.dev`, use `-a mosaic` (or omit, since it's the default).
-
-### DNS — Cloudflare
-
-Multi-instance support: `-a <instance>` selects a named instance (e.g. `personal`, `work`). Omit `-a` to use the default from `cloudflare.default` in credentials.json.
-
-```bash
-# List zones (domains)
-~/.config/mosaic/tools/cloudflare/zone-list.sh [-a instance]
-
-# List DNS records (zone by name or ID)
-~/.config/mosaic/tools/cloudflare/record-list.sh -z <zone> [-a instance] [-t type] [-n name]
-
-# Create DNS record
-~/.config/mosaic/tools/cloudflare/record-create.sh -z <zone> -t <type> -n <name> -c <content> [-a instance] [-p] [-l ttl] [-P priority]
-
-# Update DNS record
-~/.config/mosaic/tools/cloudflare/record-update.sh -z <zone> -r <record-id> -t <type> -n <name> -c <content> [-a instance] [-p] [-l ttl]
-
-# Delete DNS record
-~/.config/mosaic/tools/cloudflare/record-delete.sh -z <zone> -r <record-id> [-a instance]
-```
-
-### IT Service — GLPI
-
-```bash
-~/.config/mosaic/tools/glpi/ticket-list.sh
-~/.config/mosaic/tools/glpi/ticket-create.sh -t <title> -c <content>
-~/.config/mosaic/tools/glpi/computer-list.sh
-~/.config/mosaic/tools/glpi/user-list.sh
-```
-
-### Health Check
-
-```bash
-# Check all configured services
-~/.config/mosaic/tools/health/stack-health.sh
-
-# Check a specific service
-~/.config/mosaic/tools/health/stack-health.sh -s portainer
-
-# JSON output for automation
-~/.config/mosaic/tools/health/stack-health.sh -f json
-```
-
-### Shared Credential Loader
-
-```bash
-# Source in any script to load service credentials
-source ~/.config/mosaic/tools/_lib/credentials.sh
-load_credentials <service-name>
-# Supported: portainer, coolify, authentik, glpi, github, gitea-mosaicstack, gitea-usc, woodpecker, cloudflare, turbo-cache, openbrain
-```
-
-### OpenBrain — Semantic Memory (PRIMARY)
-
-Self-hosted semantic brain backed by pgvector. Primary shared memory layer for all agents across all sessions and harnesses. Stores and retrieves decisions, context, and observations via semantic search.
-
-**MANDATORY jarvis-brain rule:** When working in `~/src/jarvis-brain`, NEVER capture project data, meeting notes, status updates, timeline decisions, or task completions to OpenBrain. The flat files (`data/projects/*.json`, `data/tasks/*.json`) are the SSOT — use `tools/brain.py` and direct JSON edits. OpenBrain is for agent meta-observations ONLY (tooling gotchas, framework learnings, cross-project patterns). Violating this creates duplicate, divergent data.
-
-**Credentials:** `load_credentials openbrain` → exports `OPENBRAIN_URL`, `OPENBRAIN_TOKEN`
-
-Configure in your credentials.json:
-
-```json
-"openbrain": {
-  "url": "https://<your-openbrain-host>",
-  "api_key": "<your-api-key>"
-}
-```
-
-**REST API** (any language, any harness):
-
-```bash
-source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials openbrain
-
-# Search by meaning
-curl -s -X POST -H "Authorization: Bearer $OPENBRAIN_TOKEN" -H "Content-Type: application/json" \
-  -d '{"query": "your search", "limit": 5}' "$OPENBRAIN_URL/v1/search"
-
-# Capture a thought
-curl -s -X POST -H "Authorization: Bearer $OPENBRAIN_TOKEN" -H "Content-Type: application/json" \
-  -d '{"content": "...", "source": "agent-name", "metadata": {}}' "$OPENBRAIN_URL/v1/thoughts"
-
-# Recent activity
-curl -s -H "Authorization: Bearer $OPENBRAIN_TOKEN" "$OPENBRAIN_URL/v1/thoughts/recent?limit=5"
-
-# Stats
-curl -s -H "Authorization: Bearer $OPENBRAIN_TOKEN" "$OPENBRAIN_URL/v1/stats"
-```
-
-**Python client** (if jarvis-brain is available on PYTHONPATH):
-
-```bash
-python tools/openbrain_client.py search "topic"
-python tools/openbrain_client.py capture "decision or observation" --source agent-name
-python tools/openbrain_client.py recent --limit 5
-python tools/openbrain_client.py stats
-```
-
-**MCP (Claude Code sessions):** When connected, `mcp__openbrain__capture/search/recent/stats` tools are available natively — prefer those over CLI when in a Claude session.
-
-**Rule: capture when you LEARN something. Never when you DO something.**
-
-| Trigger                                   | Action                                    | Retention             |
-| ----------------------------------------- | ----------------------------------------- | --------------------- |
-| Session start                             | `search` + `recent` to load prior context | —                     |
-| Architectural or tooling decision made    | Capture with rationale                    | `long` or `permanent` |
-| Gotcha or non-obvious behavior discovered | Capture immediately                       | `medium`              |
-| User preference stated or confirmed       | Capture                                   | `permanent`           |
-| Cross-project pattern identified          | Capture                                   | `permanent`           |
-| Prior decision superseded                 | UPDATE existing thought                   | (keep tier)           |
-
-**Never capture:** task started, commit pushed, PR opened, test results, file edits, CI status.
-
-Full protocol and cleanup tools: `~/.config/mosaic/guides/MEMORY.md`
-Smart capture wrapper (enforces schema + dedup): `~/.config/mosaic/tools/openbrain/capture.sh`
-
-### Excalidraw — Diagram Export (MCP)
-
-Headless `.excalidraw` → SVG export via `@excalidraw/excalidraw`. Available as MCP tools in Claude Code sessions.
-
-**MCP tools (when connected):**
-
-| Tool                                      | Input                                         | Output                                               |
-| ----------------------------------------- | --------------------------------------------- | ---------------------------------------------------- |
-| `mcp__excalidraw__excalidraw_to_svg`      | `elements` JSON string + optional `app_state` | SVG string                                           |
-| `mcp__excalidraw__excalidraw_file_to_svg` | `file_path` to `.excalidraw`                  | SVG string + writes `.svg` alongside                 |
-| `mcp__excalidraw__list_diagrams`          | (none)                                        | Available templates (requires `EXCALIDRAW_GEN_PATH`) |
-| `mcp__excalidraw__generate_diagram`       | `name`, optional `output_path`                | Path to generated `.excalidraw`                      |
-| `mcp__excalidraw__generate_and_export`    | `name`, optional `output_path`                | Paths to `.excalidraw` and `.svg`                    |
-
-**Diagram generation** (`list_diagrams`, `generate_diagram`, `generate_and_export`) requires `EXCALIDRAW_GEN_PATH` env var pointing to `excalidraw_gen.py`. Set in environment or shell profile:
-
-```bash
-export EXCALIDRAW_GEN_PATH="$HOME/src/jarvis-brain/tools/excalidraw_export/excalidraw_gen.py"
-```
-
-**Manual registration:**
-
-```bash
-mosaic-ensure-excalidraw           # install deps + register with Claude
-mosaic-ensure-excalidraw --check   # verify registration
-```
-
-## Git Providers
-
-| Instance                      | URL | CLI | Purpose |
-| ----------------------------- | --- | --- | ------- |
-| (add your git providers here) |     |     |         |
-
-## Credentials
-
-**Location:** (configure your credential file path)
-**Loader:** `source ~/.config/mosaic/tools/_lib/credentials.sh && load_credentials <service>`
-
-**Never expose actual values. Never commit credential files.**
-
-## CLI Gotchas
-
-(Add platform-specific CLI gotchas as you discover them.)
-
-## Safety Defaults
-
-- Prefer `trash` over `rm` when available — recoverable beats gone forever
-- Never run destructive commands without explicit instruction
-- Write it down — "mental notes" don't survive session restarts; files do

packages/mosaic/framework/guides/VAULT-SECRETS.md

@@ -203,374 +203,3 @@ Error: token expired
 3. **Audit logging** - All access is logged; act accordingly
 4. **No local copies** - Don't store secrets in files or env vars long-term
 5. **Rotate on compromise** - Immediately rotate any exposed secrets
-
----
-
-## Secrets Architecture Decision Matrix
-
-Use this table to choose between the ESO bridge (default) and Direct-Vault (opt-in) patterns for every new app or integration.
-
-| Factor                      | ESO Bridge (default)                                                          | Direct-Vault (opt-in)                                                                                                   |
-| --------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| **Use-case**                | All static secrets (DB creds, API keys, signing keys, OAuth secrets)          | Dynamic creds with short TTLs (DB rotation, AWS STS, PKI), per-request audit trails, or lease renewal mid-pod-lifecycle |
-| **App code change**         | None — reads standard env vars via `secretKeyRef`                             | Requires Vault client (`hvac`, `node-vault`, `vault/api`) in application code                                           |
-| **Secret rotation**         | ESO re-syncs on Vault write; pod restart or secret refresh picks up new value | App manages lease renewal or re-auth within the running process                                                         |
-| **Audit granularity**       | Access logged at Vault when ESO syncs; no per-request app audit               | Every app request to Vault is a separate audit log entry                                                                |
-| **Operational burden**      | Low — ESO handles polling, sync, and k8s Secret lifecycle                     | Higher — app must handle auth, lease renewal, error paths, and token rotation                                           |
-| **Justification required?** | No — this is the default                                                      | Yes — document in project README under "Secrets architecture"                                                           |
-| **Example use cases**       | Web app DB password, OAuth client secret, JWT signing key, API token          | HashiCorp DB secrets engine with 15-min TTL leases, AWS STS assume-role, Vault PKI short-lived certs                    |
-
-**Decision rule:** If you are unsure, use ESO. Only justify Direct-Vault when the secret cannot be safely stored in a k8s Secret (too short-lived, per-request TTL required, or mid-lifecycle renewal needed).
-
----
-
-## ESO Bridge Pattern (Default)
-
-This is the required default for all k8s workloads. Follow this exact pattern unless a documented dynamic-secrets requirement justifies Direct-Vault.
-
-### 1. Provision Vault path
-
-```bash
-# Write the secrets for the app (run once; use IaC/Terraform for repeatable provisioning)
-vault kv put secret/k3s/<app> \
-  db_password="..." \
-  api_key="..." \
-  jwt_secret="..."
-```
-
-Use the canonical path structure: `secret/k3s/<app>` for k3s cluster workloads.
-
-### 2. ExternalSecret manifest
-
-Commit this to the repo's `deploy/` or `k8s/` directory:
-
-```yaml
-# deploy/external-secret.yaml
-apiVersion: external-secrets.io/v1beta1
-kind: ExternalSecret
-metadata:
-  name: <app>-secrets
-  namespace: <namespace>
-spec:
-  refreshInterval: 1h
-  secretStoreRef:
-    name: vault-backend # ClusterSecretStore name — verify with cluster admin
-    kind: ClusterSecretStore
-  target:
-    name: <app>-secrets # k8s Secret name that will be created
-    creationPolicy: Owner
-  data:
-    - secretKey: DB_PASSWORD # key in the k8s Secret
-      remoteRef:
-        key: secret/k3s/<app> # Vault path
-        property: db_password # field within the Vault secret
-    - secretKey: API_KEY
-      remoteRef:
-        key: secret/k3s/<app>
-        property: api_key
-    - secretKey: JWT_SECRET
-      remoteRef:
-        key: secret/k3s/<app>
-        property: jwt_secret
-```
-
-### 3. Deployment manifest — reference synced k8s Secret
-
-```yaml
-# deploy/deployment.yaml (env section)
-env:
-  - name: DB_PASSWORD
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets # matches ExternalSecret target.name
-        key: DB_PASSWORD
-  - name: API_KEY
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets
-        key: API_KEY
-  - name: JWT_SECRET
-    valueFrom:
-      secretKeyRef:
-        name: <app>-secrets
-        key: JWT_SECRET
-  - name: PORT
-    value: '3000' # safe-default: non-secret, no Vault needed
-```
-
-### 4. App-side schema validation — TypeScript (zod)
-
-Validate all required env vars at startup. Exit non-zero on missing values.
-
-```typescript
-// src/env.ts
-import { z } from 'zod';
-
-const envSchema = z.object({
-  DB_PASSWORD: z.string().min(1, 'DB_PASSWORD is required'),
-  API_KEY: z.string().min(1, 'API_KEY is required'),
-  JWT_SECRET: z.string().min(32, 'JWT_SECRET must be at least 32 chars'),
-  PORT: z.coerce.number().default(3000),
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('production'),
-});
-
-const result = envSchema.safeParse(process.env);
-if (!result.success) {
-  console.error('Missing or invalid environment variables:');
-  console.error(result.error.flatten().fieldErrors);
-  process.exit(1);
-}
-
-export const env = result.data;
-```
-
-### 4b. App-side schema validation — Python (pydantic)
-
-```python
-# src/config.py
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-class Settings(BaseSettings):
-    db_password: str
-    api_key: str
-    jwt_secret: str
-    port: int = 3000
-    node_env: str = "production"
-
-    model_config = SettingsConfigDict(env_file=None)  # no .env in prod
-
-try:
-    settings = Settings()
-except Exception as e:
-    import sys
-    print(f"Missing or invalid environment variables: {e}", file=sys.stderr)
-    sys.exit(1)
-```
-
-### 4c. App-side schema validation — Go (envconfig)
-
-```go
-// config/config.go
-package config
-
-import (
-    "fmt"
-    "github.com/kelseyhightower/envconfig"
-)
-
-type Config struct {
-    DBPassword string `envconfig:"DB_PASSWORD" required:"true"`
-    APIKey     string `envconfig:"API_KEY" required:"true"`
-    JWTSecret  string `envconfig:"JWT_SECRET" required:"true"`
-    Port       int    `envconfig:"PORT" default:"3000"`
-}
-
-func Load() (*Config, error) {
-    var cfg Config
-    if err := envconfig.Process("", &cfg); err != nil {
-        return nil, fmt.Errorf("invalid environment: %w", err)
-    }
-    return &cfg, nil
-}
-```
-
-In your `main.go`:
-
-```go
-cfg, err := config.Load()
-if err != nil {
-    fmt.Fprintln(os.Stderr, err)
-    os.Exit(1)
-}
-```
-
----
-
-## Direct-Vault Opt-In Pattern
-
-Use this pattern ONLY when a documented dynamic-secrets requirement applies (DB rotation with short TTLs, AWS STS, PKI, per-request audit). Document the justification in the project README under "Secrets architecture" before implementing.
-
-### When it is justified
-
-- Vault DB secrets engine with lease TTLs shorter than a typical pod lifecycle (< 1 hour)
-- AWS STS assume-role tokens generated per-request
-- Vault PKI short-lived certificates (< 24 hours) that must be renewed within a running pod
-- Per-request audit trail requirement (each app call must appear separately in Vault audit log)
-
-### Provision an AppRole for the app
-
-```bash
-# Enable AppRole auth (if not already enabled)
-vault auth enable approle
-
-# Create a Vault policy for the app
-# Note: KV v2 paths require both the exact path (for the top-level secret) and the
-# wildcard (for sub-paths). Always include both to avoid permission denied errors.
-vault policy write <app>-policy - <<EOF
-path "secret/data/k3s/<app>" {
-  capabilities = ["read"]
-}
-path "secret/data/k3s/<app>/*" {
-  capabilities = ["read"]
-}
-path "database/creds/<app>-role" {
-  capabilities = ["read"]
-}
-EOF
-
-# Create the AppRole
-vault write auth/approle/role/<app>-role \
-  token_policies="<app>-policy" \
-  token_ttl=1h \
-  token_max_ttl=4h \
-  secret_id_ttl=0
-
-# Retrieve role-id and secret-id
-vault read auth/approle/role/<app>-role/role-id
-vault write -f auth/approle/role/<app>-role/secret-id
-```
-
-### Bootstrap AppRole credentials via ESO (solving the chicken-and-egg problem)
-
-The AppRole `role-id` and `secret-id` are themselves secrets. Store them in Vault at a bootstrap path, then use ESO to sync them into a k8s Secret. The app reads that k8s Secret at startup to authenticate with Vault directly.
-
-```bash
-# Store the bootstrap credentials in Vault
-vault kv put secret/k3s/<app>-bootstrap \
-  role_id="<role-id>" \
-  secret_id="<secret-id>"
-```
-
-```yaml
-# deploy/external-secret-bootstrap.yaml
-apiVersion: external-secrets.io/v1beta1
-kind: ExternalSecret
-metadata:
-  name: <app>-vault-auth
-  namespace: <namespace>
-spec:
-  refreshInterval: 24h
-  secretStoreRef:
-    name: vault-backend
-    kind: ClusterSecretStore
-  target:
-    name: <app>-vault-auth
-    creationPolicy: Owner
-  data:
-    - secretKey: VAULT_ROLE_ID
-      remoteRef:
-        key: secret/k3s/<app>-bootstrap
-        property: role_id
-    - secretKey: VAULT_SECRET_ID
-      remoteRef:
-        key: secret/k3s/<app>-bootstrap
-        property: secret_id
-```
-
-```yaml
-# deploy/deployment.yaml (env section for Direct-Vault app)
-env:
-  - name: VAULT_ADDR
-    value: 'https://vault.example.com' # safe-default: non-secret cluster address
-  - name: VAULT_ROLE_ID
-    valueFrom:
-      secretKeyRef:
-        name: <app>-vault-auth
-        key: VAULT_ROLE_ID
-  - name: VAULT_SECRET_ID
-    valueFrom:
-      secretKeyRef:
-        name: <app>-vault-auth
-        key: VAULT_SECRET_ID
-```
-
-### App-side Vault client pattern
-
-```typescript
-// src/vault-client.ts — only exists in Direct-Vault apps
-import vault from 'node-vault';
-import { z } from 'zod';
-
-const bootstrapSchema = z.object({
-  VAULT_ADDR: z.string().url(),
-  VAULT_ROLE_ID: z.string().min(1),
-  VAULT_SECRET_ID: z.string().min(1),
-});
-
-const bootstrap = bootstrapSchema.parse(process.env);
-
-const client = vault({ endpoint: bootstrap.VAULT_ADDR });
-
-export async function getVaultClient() {
-  const { auth } = await client.approleLogin({
-    role_id: bootstrap.VAULT_ROLE_ID,
-    secret_id: bootstrap.VAULT_SECRET_ID,
-  });
-  client.token = auth.client_token;
-  return client;
-}
-```
-
-Document in README under "Secrets architecture": the Vault path, why Direct-Vault is required, and the lease/renewal strategy.
-
----
-
-## Forbidden Patterns (CI Lint Targets)
-
-The following patterns are forbidden in all Mosaic projects. CI lint SHOULD catch these automatically (implementation tracked separately). Agents MUST NOT introduce these patterns.
-
-### 1. Untagged fallback defaults for required values
-
-```yaml
-# FORBIDDEN — required secret with silent fallback
-environment:
-  - DB_PASSWORD=${DB_PASSWORD:-changeme}
-  - API_KEY=${API_KEY:-}
-
-# REQUIRED — fast-fail on missing required values
-environment:
-  - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD is required}
-  - API_KEY=${API_KEY:?API_KEY is required}
-
-# ALLOWED — true convenience default, tagged
-environment:
-  - PORT=${PORT:-3000}  # safe-default: non-secret, app works at any port
-```
-
-This applies to: `docker-compose.yml`, k8s manifests, Helm `values.yaml`, any env file committed to git.
-
-### 2. Vault KV calls in application source code (ESO-default projects)
-
-```python
-# FORBIDDEN in ESO-default apps — direct Vault client in app source
-import hvac
-client = hvac.Client(url=os.environ['VAULT_ADDR'])
-secret = client.secrets.kv.v2.read_secret_version(path='myapp/db')
-```
-
-ESO-default apps read env vars only. Direct-Vault clients belong only in apps with a documented dynamic-secrets justification in README.
-
-### 3. Hardcoded secrets or API keys in committed files
-
-```python
-# FORBIDDEN — hardcoded credential
-DB_PASSWORD = "supersecret123"
-API_KEY = "sk-live-abc123"
-```
-
-No exceptions. CI lint must flag any string matching common secret patterns (`password`, `secret`, `api_key`, `token` assigned a literal non-env-var value).
-
-### 4. `.env` files in production deployment paths
-
-```
-# FORBIDDEN — .env file in a production deploy path
-deploy/.env
-k8s/.env
-docker/.env
-
-# ALLOWED — local dev only
-.env.example          # template only, no real values
-.env                  # local dev, must be in .gitignore
-```
-
-`.env` files are acceptable in local-dev contexts only and MUST be in `.gitignore`. They are forbidden in any path that a CI pipeline or production deployment process reads directly.

packages/mosaic/framework/runtime/claude/RUNTIME.md

@@ -1,61 +1,131 @@
 # Claude Runtime Reference
 
-Claude-runtime behavior only. Global rules win if anything here conflicts.
+## Runtime Scope
+
+This file applies only to Claude runtime behavior.
 
 ## Required Actions
 
-1. Follow the Session Start load order in `~/.config/mosaic/AGENTS.md`.
+1. Follow global load order in `~/.config/mosaic/AGENTS.md`.
-2. Runtime config lives in `~/.claude/settings.json` (hooks, model, plugins, permissions) and
+2. Use `~/.claude/settings.json` and `~/.claude/hooks-config.json` as runtime config sources.
-   `~/.claude/hooks-config.json`.
+3. Treat sequential-thinking MCP as required.
-3. sequential-thinking MCP is required.
+4. If runtime config conflicts with global rules, global rules win.
-4. First response MUST declare mode per the global contract.
+5. Documentation rules are inherited from `~/.config/mosaic/AGENTS.md` and `~/.config/mosaic/guides/DOCUMENTATION.md`.
-5. Git wrappers first for issue/PR/milestone ops; runtime-default confirmation prompts do NOT
+6. For issue/PR/milestone actions, run Mosaic git wrappers first (`~/.config/mosaic/tools/git/*.sh`) and do not call raw `gh`/`tea`/`glab` first.
-   override Mosaic hard gates (push/merge/issue-close without routine confirmation).
+7. For orchestration-oriented missions, load `~/.config/mosaic/guides/ORCHESTRATOR.md` before acting.
+8. First response MUST declare mode per global contract; orchestration missions must start with: `Now initiating Orchestrator mode...`
+9. Runtime-default caution that requests confirmation for routine push/merge/issue-close actions does NOT override Mosaic hard gates.
 
-## Subagent Model Selection (Claude Code syntax)
+## Subagent Model Selection (Claude Code Syntax)
 
-The Task tool takes `model`: `"haiku"` | `"sonnet"` | `"opus"`. You MUST set it per the tier rule
+Claude Code's Task tool accepts a `model` parameter: `"haiku"`, `"sonnet"`, or `"opus"`.
-in AGENTS.md — omitting it defaults to the parent (usually opus) and wastes budget.
+
+You MUST set this parameter according to the model selection table in `~/.config/mosaic/AGENTS.md`. Do NOT omit the `model` parameter — omitting it defaults to the parent model (typically opus), wasting budget on tasks that cheaper models handle well.
+
+**Examples:**
 
 ```
+# Codebase exploration — haiku
 Task(subagent_type="Explore", model="haiku", prompt="Find all API route handlers")
-Task(subagent_type="feature-dev:code-reviewer", model="sonnet", prompt="Review src/auth/ changes")
+
+# Code review — sonnet
+Task(subagent_type="feature-dev:code-reviewer", model="sonnet", prompt="Review the changes in src/auth/")
+
+# Standard feature work — sonnet
+Task(subagent_type="general-purpose", model="sonnet", prompt="Add validation to the user input form")
+
+# Complex architecture — opus (only when justified)
 Task(subagent_type="Plan", model="opus", prompt="Design the multi-tenant isolation strategy")
 ```
 
+**Quick reference (from global AGENTS.md):**
+
+| haiku                  | sonnet            | opus                       |
+| ---------------------- | ----------------- | -------------------------- |
+| Search, grep, glob     | Code review       | Complex architecture       |
+| Status/health checks   | Test writing      | Security/auth logic        |
+| Simple one-liner fixes | Standard features | Ambiguous design decisions |
+
 ## Memory Policy (Hard Gate)
 
-OpenBrain is the primary cross-agent memory layer — capture learnings/gotchas/decisions there
+**OpenBrain is the primary cross-agent memory layer.** All agent learnings, gotchas, decisions, and project state MUST be captured to OpenBrain via the `capture` MCP tool or REST API.
-(`capture` MCP tool or REST). `~/.claude/projects/*/memory/MEMORY.md` is **write-blocked** by the
-`prevent-memory-write.sh` PreToolUse hook (the rule alone proved insufficient — the hook is the
-hard gate). At session start, `search(topic)` + `recent()` to load prior context. Full protocol:
-`~/.config/mosaic/guides/MEMORY.md`.
 
-Quick placement: discoveries/decisions → OpenBrain; active task state → `docs/TASKS.md` or
+`~/.claude/projects/*/memory/MEMORY.md` files are **write-blocked by PreToolUse hook** (`prevent-memory-write.sh`). Any attempt to write agent learnings there will be rejected with an error directing you to OpenBrain.
-`docs/scratchpads/`; Mosaic framework notes → `~/.config/mosaic/memory/`.
+
+### What belongs where
+
+| Content                                         | Location                                                               |
+| ----------------------------------------------- | ---------------------------------------------------------------------- |
+| Discoveries, gotchas, decisions, observations   | OpenBrain `capture` — searchable by all agents                         |
+| Active task state                               | `docs/TASKS.md` or `docs/scratchpads/`                                 |
+| Behavioral guardrails that MUST be in load-path | `MEMORY.md` (read-mostly; write only for genuine behavioral overrides) |
+| Mosaic framework technical notes                | `~/.config/mosaic/memory/`                                             |
+
+### Using OpenBrain
+
+At session start, load prior context:
+
+```
+search("topic or project name")   # semantic search
+recent(limit=5)                    # what's been happening
+```
+
+When you discover something:
+
+```
+capture("The thing you learned", source="project/context", metadata={"type": "gotcha", ...})
+```
+
+### Why the hook exists
+
+Instructions in RUNTIME.md, CLAUDE.md, and MEMORY.md are insufficient — agents default to writing local MEMORY.md regardless of written rules. The PreToolUse hook is a hard technical gate that makes the correct behavior the only possible behavior.
 
 ## MCP Configuration
 
-MCP servers are configured in `~/.claude.json` (key `mcpServers`) — NOT `~/.claude/settings.json`,
+**MCPs are configured in `~/.claude.json` — NOT `~/.claude/settings.json`.**
-where that key is ignored. `settings.json` controls hooks/model/plugins/permissions.
+
+`settings.json` controls hooks, model, plugins, and allowed commands.
+`~/.claude.json` is the global Claude Code state file where `mcpServers` lives.
+
+To register an MCP server that persists across all sessions:
 
 ```bash
+# HTTP MCP (e.g. OpenBrain)
 claude mcp add --scope user --transport http <name> <url> --header "Authorization: Bearer <token>"
-claude mcp add --scope user <name> -- npx -y <package>   # stdio
+
+# stdio MCP
+claude mcp add --scope user <name> -- npx -y <package>
 ```
 
-`--scope user` → `~/.claude.json` (global); `project` → `.claude/settings.json`; `local` (default)
+`--scope user` = writes to `~/.claude.json` (global, all projects).
-→ not committed.
+`--scope project` = writes to `.claude/settings.json` in project root.
+`--scope local` = default, local-only (not committed).
 
-## Required Settings (launcher-audited, advisory)
+Do NOT add `mcpServers` to `~/.claude/settings.json` — that key is ignored for MCP loading.
 
-`mosaic claude` warns if `~/.claude/settings.json` is missing these (session still launches):
+## Required Claude Code Settings (Enforced by Launcher)
 
-- **Hooks** — PreToolUse `prevent-memory-write.sh` (Write|Edit|MultiEdit); PostToolUse
+The `mosaic claude` launcher validates that `~/.claude/settings.json` contains the required Mosaic configuration. Missing or outdated settings trigger a warning at launch.
-  `qa-hook-stdin.sh` + `typecheck-hook.sh` (Edit|MultiEdit|Write).
-- **Plugins** — `feature-dev`, `pr-review-toolkit`, `code-review`.
-- **Settings** — `enableAllMcpTools: true`; `model: "opus"` (orchestrator default; workers use
-  tiered models via the Task `model` param).
 
-Note: PostToolUse hook plain stdout on exit 0 goes to the debug log, not model context — only
+**Required hooks:**
-`hookSpecificOutput.additionalContext` (or exit-2 stderr) enters context.
+
+| Event       | Matcher                  | Script                    | Purpose                                        |
+| ----------- | ------------------------ | ------------------------- | ---------------------------------------------- |
+| PreToolUse  | `Write\|Edit\|MultiEdit` | `prevent-memory-write.sh` | Block writes to `~/.claude/projects/*/memory/` |
+| PostToolUse | `Edit\|MultiEdit\|Write` | `qa-hook-stdin.sh`        | QA report generation after code edits          |
+| PostToolUse | `Edit\|MultiEdit\|Write` | `typecheck-hook.sh`       | Inline TypeScript type checking                |
+
+**Required plugins:**
+
+| Plugin              | Purpose                                                                                                  |
+| ------------------- | -------------------------------------------------------------------------------------------------------- |
+| `feature-dev`       | Subagent architecture: code-reviewer, code-architect, code-explorer                                      |
+| `pr-review-toolkit` | PR review: code-simplifier, comment-analyzer, test-analyzer, silent-failure-hunter, type-design-analyzer |
+| `code-review`       | Standalone code review capabilities                                                                      |
+
+**Required settings:**
+
+- `enableAllMcpTools: true` — Allow all configured MCP tools without per-tool approval
+- `model: "opus"` — Default to opus for orchestrator-level sessions (workers use tiered models via Task tool)
+
+If `mosaic claude` detects missing hooks or plugins, it will print a warning with the exact settings to add. The session will still launch — enforcement is advisory, not blocking — but agents operating without these settings are running degraded.

packages/mosaic/framework/runtime/claude/settings.json

@@ -34,17 +34,6 @@
           }
         ]
       }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "~/.config/mosaic/tools/qa/reflect-stop-hook.sh",
-            "timeout": 15
-          }
-        ]
-      }
     ]
   },
   "enabledPlugins": {

packages/mosaic/framework/runtime/pi/RUNTIME.md

@@ -29,21 +29,7 @@ Pi supports `--models` for Ctrl+P model cycling during a session. Use cheaper mo
 
 ### Skills
 
-By default the launcher starts Pi with `--no-skills` to keep startup context small, then
+Mosaic skills are loaded natively via Pi's `--skill` flag. Skills are discovered from:
-force-loads a small set of fleet-critical skills via explicit `--skill` flags (an explicit
-`--skill` overrides `--no-skills` for that path). The default forced set is `mosaic-tools`
-(the must-use `~/.config/mosaic/tools/` cheatsheet: inter-agent messaging + git wrappers).
-
-Tune skill loading with environment variables:
-
-- `MOSAIC_PI_FORCE_SKILLS` — colon-separated skill dir names to force-load (default: `mosaic-tools`;
-  set to an empty string to disable force-loading). Missing skills are skipped silently.
-- `MOSAIC_PI_SKILL_MODE=all` — link every skill found in `~/.config/mosaic/{skills,skills-local}/`
-  (full catalog; larger context).
-- `MOSAIC_PI_SKILL_MODE=discover` — let Pi discover skills natively (no `--no-skills`), still
-  force-loading the fleet set on top.
-
-Skills are discovered from:
 
 - `~/.config/mosaic/skills/` (Mosaic global skills)
 - `~/.pi/agent/skills/` (Pi global skills)

packages/mosaic/framework/templates/agent/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -58,7 +58,7 @@ ${QUALITY_GATES}
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -88,7 +88,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 ## Container Release Strategy (When Applicable)
 
@@ -138,8 +138,8 @@ When completing an orchestrated task:
 ### Post-Coding Review
 After implementing changes, code review is REQUIRED for any source-code modification.
 For orchestrated tasks, the orchestrator will run:
-1. **Codex code review** — `~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted`
+1. **Codex code review** — `~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted`
-2. **Codex security review** — `~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted`
+2. **Codex security review** — `~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted`
 3. If blockers/critical findings: remediation task created
 4. If clean: task marked done
 

packages/mosaic/framework/templates/agent/CLAUDE.md.template

@@ -135,7 +135,7 @@ ${QUALITY_GATES}
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -147,9 +147,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.
@@ -176,10 +176,10 @@ Run independent reviews:
 
 ```bash
 # Code quality review (Codex)
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
 
 # Security review (Codex)
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 **Fallback:** If Codex is unavailable, use Claude's built-in review skills.

packages/mosaic/framework/templates/agent/projects/django/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -68,7 +68,7 @@ ruff check . && mypy . && pytest tests/
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -97,7 +97,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 
 ## Container Release Strategy (When Applicable)
@@ -139,8 +139,8 @@ Use `${TASK_PREFIX}` for orchestrated tasks (e.g., `${TASK_PREFIX}-SEC-001`).
 ### Post-Coding Review
 After implementing changes, code review is REQUIRED for any source-code modification.
 For orchestrated tasks, the orchestrator will run:
-1. **Codex code review** — `~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted`
+1. **Codex code review** — `~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted`
-2. **Codex security review** — `~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted`
+2. **Codex security review** — `~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted`
 3. If blockers/critical findings: remediation task created
 4. If clean: task marked done
 

packages/mosaic/framework/templates/agent/projects/django/CLAUDE.md.template

@@ -159,10 +159,10 @@ Run independent reviews:
 
 ```bash
 # Code quality review (Codex)
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
 
 # Security review (Codex)
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 See `~/.config/mosaic/guides/CODE-REVIEW.md` for the full review checklist.
@@ -186,7 +186,7 @@ See `~/.config/mosaic/guides/DOCUMENTATION.md` for required documentation delive
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -198,9 +198,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.

packages/mosaic/framework/templates/agent/projects/nestjs-nextjs/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -72,7 +72,7 @@ pnpm typecheck && pnpm lint && pnpm test
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -101,7 +101,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 
 ## Container Release Strategy (When Applicable)
@@ -143,8 +143,8 @@ Use `${TASK_PREFIX}` for orchestrated tasks (e.g., `${TASK_PREFIX}-SEC-001`).
 ### Post-Coding Review
 After implementing changes, code review is REQUIRED for any source-code modification.
 For orchestrated tasks, the orchestrator will run:
-1. **Codex code review** — `~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted`
+1. **Codex code review** — `~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted`
-2. **Codex security review** — `~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted`
+2. **Codex security review** — `~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted`
 3. If blockers/critical findings: remediation task created
 4. If clean: task marked done
 

packages/mosaic/framework/templates/agent/projects/nestjs-nextjs/CLAUDE.md.template

@@ -191,10 +191,10 @@ Run independent reviews:
 
 ```bash
 # Code quality review (Codex)
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
 
 # Security review (Codex)
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 See `~/.config/mosaic/guides/CODE-REVIEW.md` for the full review checklist.
@@ -218,7 +218,7 @@ See `~/.config/mosaic/guides/DOCUMENTATION.md` for required documentation delive
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -230,9 +230,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.

packages/mosaic/framework/templates/agent/projects/python-fastapi/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -58,7 +58,7 @@ uv run ruff check src/ tests/ && uv run ruff format --check src/ && uv run mypy
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -87,7 +87,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 ## Container Release Strategy (When Applicable)
 

packages/mosaic/framework/templates/agent/projects/python-fastapi/CLAUDE.md.template

@@ -135,7 +135,7 @@ uv run ruff check src/ tests/ && uv run ruff format --check src/ && uv run mypy
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -146,9 +146,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.
@@ -171,8 +171,8 @@ If you modify source code, independent code review is REQUIRED before completion
 Run independent reviews:
 
 ```bash
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 See `~/.config/mosaic/guides/CODE-REVIEW.md` for the full review checklist.

packages/mosaic/framework/templates/agent/projects/python-library/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -55,7 +55,7 @@ uv run ruff check src/ tests/ && uv run ruff format --check src/ && uv run mypy
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -84,7 +84,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 ## Container Release Strategy (When Applicable)
 

packages/mosaic/framework/templates/agent/projects/python-library/CLAUDE.md.template

@@ -125,7 +125,7 @@ uv run ruff check src/ tests/ && uv run ruff format --check src/ && uv run mypy
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -136,9 +136,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.
@@ -161,8 +161,8 @@ If you modify source code, independent code review is REQUIRED before completion
 Run independent reviews:
 
 ```bash
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 See `~/.config/mosaic/guides/CODE-REVIEW.md` for the full review checklist.

packages/mosaic/framework/templates/agent/projects/typescript/AGENTS.md.template

@@ -9,8 +9,8 @@
 2. Do NOT ask for routine confirmation before required push/merge/issue-close/release/tag actions.
 3. Completion is forbidden at PR-open stage.
 4. Completion requires merged PR to `main` + terminal green CI + linked issue/internal task closed.
-5. Before push or merge, run queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+5. Before push or merge, run queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
-6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/tools/git/*.sh`).
+6. For issue/PR/milestone operations, use Mosaic wrappers first (`~/.config/mosaic/rails/git/*.sh`).
 7. If any required wrapper command fails: report `blocked` with the exact failed wrapper command and stop.
 8. Do NOT stop at "PR created" and do NOT ask "should I merge?" for routine flow.
 
@@ -56,7 +56,7 @@ ${QUALITY_GATES}
 2. If external git provider is available (Gitea/GitHub/GitLab), create/update issue(s) before coding and map them in `docs/TASKS.md`.
 3. If no external provider is available, use internal refs in `docs/TASKS.md` (example: `TASKS:T1`).
 4. Keep `docs/TASKS.md` status in sync with actual progress until completion.
-5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
+5. For issue/PR/milestone actions, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first (no raw `gh`/`tea`/`glab` as first choice).
 6. If wrapper-driven merge/CI/issue-closure fails, report blocker with the exact failed wrapper command and stop (do not claim completion).
 
 ## Documentation Contract
@@ -85,7 +85,7 @@ Reference:
 5. Do not mark implementation complete until PR is merged.
 6. Do not mark implementation complete until CI/pipeline status is terminal green.
 7. Close linked issues/tasks only after merge + green CI.
-8. Before push or merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push|merge -B main`.
+8. Before push or merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push|merge -B main`.
 
 ## Container Release Strategy (When Applicable)
 

packages/mosaic/framework/templates/agent/projects/typescript/CLAUDE.md.template

@@ -122,7 +122,7 @@ ${QUALITY_GATES}
 ## Issue Tracking
 
 Use external git provider issues when available. If no external provider exists, `docs/TASKS.md` is the canonical tracker for tasks, milestones, and issue-equivalent work.
-For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/tools/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
+For issue/PR/milestone operations, detect platform and use `~/.config/mosaic/rails/git/*.sh` wrappers first; do not use raw `gh`/`tea`/`glab` as first choice.
 If wrapper-driven merge/CI/issue-closure fails, report blocker with exact failed wrapper command and stop.
 Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close the issue?" for routine delivery flow.
 
@@ -133,9 +133,9 @@ Do NOT stop at "PR created" and do NOT ask "should I merge?" or "should I close
 5. Ensure `docs/PRD.md` or `docs/PRD.json` exists and is current before coding.
 6. Create scratchpad: `docs/scratchpads/{task-id}-{short-name}.md` and include issue/internal ref.
 7. Update `docs/TASKS.md` status + issue/internal ref before coding.
-8. Before push, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose push -B main`.
+8. Before push, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose push -B main`.
 9. Open PR to `main` for delivery changes (no direct push to `main`).
-10. Before merge, run CI queue guard: `~/.config/mosaic/tools/git/ci-queue-wait.sh --purpose merge -B main`.
+10. Before merge, run CI queue guard: `~/.config/mosaic/rails/git/ci-queue-wait.sh --purpose merge -B main`.
 11. Merge PRs that pass required checks and review gates with squash strategy only.
 12. Reference issues/internal refs in commits (`Fixes #123`, `Refs #123`, or `Refs TASKS:T1`).
 13. Close issue/internal task only after testing and documentation gates pass, PR merge is complete, and CI/pipeline status is terminal green.
@@ -159,10 +159,10 @@ Run independent reviews:
 
 ```bash
 # Code quality review (Codex)
-~/.config/mosaic/tools/codex/codex-code-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-code-review.sh --uncommitted
 
 # Security review (Codex)
-~/.config/mosaic/tools/codex/codex-security-review.sh --uncommitted
+~/.config/mosaic/rails/codex/codex-security-review.sh --uncommitted
 ```
 
 **Fallback:** If Codex is unavailable, use Claude's built-in review skills.

packages/mosaic/framework/tools/_lib/credentials.sh

@@ -52,20 +52,6 @@ _mosaic_sync_woodpecker_env() {
   printf '%s\n' "$expected" > "$env_file"
 }
 
-# Load legacy flat Woodpecker credentials (.woodpecker.url / .woodpecker.token).
-# Some environments export WOODPECKER_INSTANCE=mosaic, but the current
-# credentials.json may still use the legacy flat schema. Treat "mosaic" as the
-# default flat instance when a nested .woodpecker.mosaic object is absent.
-_mosaic_load_woodpecker_legacy() {
-  export WOODPECKER_URL="$(_mosaic_read_cred '.woodpecker.url')"
-  export WOODPECKER_TOKEN="$(_mosaic_read_cred '.woodpecker.token')"
-  export WOODPECKER_INSTANCE="${WOODPECKER_INSTANCE:-mosaic}"
-  WOODPECKER_URL="${WOODPECKER_URL%/}"
-  [[ -n "$WOODPECKER_URL" ]] || { echo "Error: woodpecker.url not found" >&2; return 1; }
-  [[ -n "$WOODPECKER_TOKEN" ]] || { echo "Error: woodpecker.token not found" >&2; return 1; }
-  _mosaic_sync_woodpecker_env "$WOODPECKER_INSTANCE" "$WOODPECKER_URL" "$WOODPECKER_TOKEN"
-}
-
 load_credentials() {
   local service="$1"
 
@@ -169,14 +155,7 @@ EOF
       ;;
     woodpecker-*)
       local wp_instance="${service#woodpecker-}"
-      # credentials.json is authoritative — always read from it, ignore env.
+      # credentials.json is authoritative — always read from it, ignore env
-      # Backward compatibility: the default Mosaic Woodpecker instance may be
-      # stored in the legacy flat schema (.woodpecker.url/.token) instead of
-      # .woodpecker.mosaic.url/.token.
-      if [[ "$wp_instance" == "mosaic" ]] && [[ -z "$(_mosaic_read_cred '.woodpecker.mosaic.url')" ]] && [[ -n "$(_mosaic_read_cred '.woodpecker.url')" ]]; then
-        WOODPECKER_INSTANCE="mosaic" _mosaic_load_woodpecker_legacy
-        return $?
-      fi
       export WOODPECKER_URL="$(_mosaic_read_cred ".woodpecker.${wp_instance}.url")"
       export WOODPECKER_TOKEN="$(_mosaic_read_cred ".woodpecker.${wp_instance}.token")"
       export WOODPECKER_INSTANCE="$wp_instance"
@@ -187,10 +166,7 @@ EOF
       _mosaic_sync_woodpecker_env "$wp_instance" "$WOODPECKER_URL" "$WOODPECKER_TOKEN"
       ;;
     woodpecker)
-      # Resolve default instance, then load it. If WOODPECKER_INSTANCE is set to
+      # Resolve default instance, then load it
-      # "mosaic" by a shell/profile but credentials.json still uses the legacy
-      # flat .woodpecker.url/.token schema, load the flat credentials instead of
-      # failing with "woodpecker.mosaic.url not found".
       local wp_default
       wp_default="${WOODPECKER_INSTANCE:-$(_mosaic_read_cred '.woodpecker.default')}"
       if [[ -z "$wp_default" ]]; then
@@ -198,19 +174,19 @@ EOF
         local legacy_url
         legacy_url="$(_mosaic_read_cred '.woodpecker.url')"
         if [[ -n "$legacy_url" ]]; then
-          _mosaic_load_woodpecker_legacy
+          export WOODPECKER_URL="${WOODPECKER_URL:-$legacy_url}"
+          export WOODPECKER_TOKEN="${WOODPECKER_TOKEN:-$(_mosaic_read_cred '.woodpecker.token')}"
+          WOODPECKER_URL="${WOODPECKER_URL%/}"
+          [[ -n "$WOODPECKER_URL" ]] || { echo "Error: woodpecker.url not found" >&2; return 1; }
+          [[ -n "$WOODPECKER_TOKEN" ]] || { echo "Error: woodpecker.token not found" >&2; return 1; }
         else
           echo "Error: woodpecker.default not set and no WOODPECKER_INSTANCE env var" >&2
           echo "Available instances: $(jq -r '.woodpecker | keys | join(", ")' "$MOSAIC_CREDENTIALS_FILE" 2>/dev/null)" >&2
           return 1
         fi
-      else
-        if [[ "$wp_default" == "mosaic" ]] && [[ -z "$(_mosaic_read_cred '.woodpecker.mosaic.url')" ]] && [[ -n "$(_mosaic_read_cred '.woodpecker.url')" ]]; then
-          WOODPECKER_INSTANCE="mosaic" _mosaic_load_woodpecker_legacy
       else
         load_credentials "woodpecker-${wp_default}"
       fi
-      fi
       ;;
     cloudflare-*)
       local cf_instance="${service#cloudflare-}"

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

@@ -137,7 +137,7 @@ gitea_get_branch_head_sha() {
     local branch="$3"
     local token="$4"
     local url="https://${host}/api/v1/repos/${repo}/branches/${branch}"
-    curl -fsSL -H "User-Agent: curl/8" -H "Authorization: token ${token}" "$url" | python3 -c '
+    curl -fsS -H "Authorization: token ${token}" "$url" | python3 -c '
 import json, sys
 data = json.load(sys.stdin)
 commit = data.get("commit") or {}
@@ -151,7 +151,7 @@ gitea_get_commit_status_json() {
     local sha="$3"
     local token="$4"
     local url="https://${host}/api/v1/repos/${repo}/commits/${sha}/status"
-    curl -fsSL -H "User-Agent: curl/8" -H "Authorization: token ${token}" "$url"
+    curl -fsS -H "Authorization: token ${token}" "$url"
 }
 
 while [[ $# -gt 0 ]]; do

packages/mosaic/framework/tools/git/detect-platform.ps1

@@ -55,154 +55,6 @@ function Get-GitRepoInfo {
     return $repoPath
 }
 
-function Get-GitRemoteHost {
-    [CmdletBinding()]
-    param()
-
-    $remoteUrl = git remote get-url origin 2>$null
-
-    if ([string]::IsNullOrEmpty($remoteUrl)) {
-        Write-Error "Not a git repository or no origin remote"
-        return $null
-    }
-
-    if ($remoteUrl -match "^https?://([^/]+)/") {
-        $remoteHost = $Matches[1]
-        return ($remoteHost -replace "^.*@", "")
-    }
-
-    if ($remoteUrl -match "^git@([^:]+):") {
-        return $Matches[1]
-    }
-
-    return $null
-}
-
-function Get-TeaLoginList {
-    [CmdletBinding()]
-    param()
-
-    $json = tea login list --output json 2>$null
-    if (-not $json) {
-        return @()
-    }
-
-    try {
-        $items = $json | ConvertFrom-Json
-    } catch {
-        return @()
-    }
-
-    if ($null -eq $items) {
-        return @()
-    }
-
-    return @($items)
-}
-
-function Test-GiteaUrlMatchesHost {
-    [CmdletBinding()]
-    param(
-        [string]$Url,
-        [string]$GiteaHost
-    )
-
-    if ([string]::IsNullOrEmpty($Url) -or [string]::IsNullOrEmpty($GiteaHost)) {
-        return $false
-    }
-
-    try {
-        $uri = [Uri]$Url
-        return $uri.Host -eq $GiteaHost
-    } catch {
-        return $false
-    }
-}
-
-function Find-TeaLoginForHost {
-    [CmdletBinding()]
-    param([Parameter(Mandatory=$true)][string]$GiteaHost)
-
-    foreach ($login in Get-TeaLoginList) {
-        $name = if ($login.name) { [string]$login.name } elseif ($login.Name) { [string]$login.Name } else { "" }
-        $url = if ($login.url) { [string]$login.url } elseif ($login.URL) { [string]$login.URL } else { "" }
-        if ([string]::IsNullOrEmpty($name) -or [string]::IsNullOrEmpty($url)) {
-            continue
-        }
-
-        try {
-            $uri = [Uri]$url
-            if ($uri.Host -eq $GiteaHost) {
-                return $name
-            }
-        } catch {
-            continue
-        }
-    }
-
-    return $null
-}
-
-function Test-TeaLoginMatchesHost {
-    [CmdletBinding()]
-    param(
-        [Parameter(Mandatory=$true)][string]$LoginName,
-        [Parameter(Mandatory=$true)][string]$GiteaHost
-    )
-
-    foreach ($login in Get-TeaLoginList) {
-        $name = if ($login.name) { [string]$login.name } elseif ($login.Name) { [string]$login.Name } else { "" }
-        $url = if ($login.url) { [string]$login.url } elseif ($login.URL) { [string]$login.URL } else { "" }
-        if ($name -ne $LoginName -or [string]::IsNullOrEmpty($url)) {
-            continue
-        }
-
-        try {
-            $uri = [Uri]$url
-            return $uri.Host -eq $GiteaHost
-        } catch {
-            return $false
-        }
-    }
-
-    return $false
-}
-
-function Get-GiteaLoginForHost {
-    [CmdletBinding()]
-    param([string]$GiteaHost)
-
-    if ([string]::IsNullOrEmpty($GiteaHost)) {
-        $GiteaHost = Get-GitRemoteHost
-    }
-    if ([string]::IsNullOrEmpty($GiteaHost)) {
-        return $null
-    }
-
-    if ($env:GITEA_LOGIN) {
-        if (Test-TeaLoginMatchesHost -LoginName $env:GITEA_LOGIN -GiteaHost $GiteaHost) {
-            return $env:GITEA_LOGIN
-        }
-    }
-
-    return Find-TeaLoginForHost -GiteaHost $GiteaHost
-}
-
-function Get-GiteaRepoArgs {
-    [CmdletBinding()]
-    param()
-
-    $repo = Get-GitRepoInfo
-    $hostName = Get-GitRemoteHost
-    $login = Get-GiteaLoginForHost -GiteaHost $hostName
-
-    if ([string]::IsNullOrEmpty($repo) -or [string]::IsNullOrEmpty($login)) {
-        return @()
-    }
-
-    return @("--repo", $repo, "--login", $login)
-}
-
 function Get-GitRepoOwner {
     [CmdletBinding()]
     param()

packages/mosaic/framework/tools/git/detect-platform.sh

@@ -74,217 +74,6 @@ get_repo_name() {
     echo "${repo_info##*/}"
 }
 
-get_repo_slug() {
-    get_repo_info
-}
-
-gitea_url_matches_host() {
-    local url="${1:-}" host="${2:-}"
-    [[ -n "$url" && -n "$host" ]] || return 1
-    [[ "${url%/}" == "https://$host" || "${url%/}" == "http://$host" || "${url%/}" == *"//$host" ]]
-}
-
-get_gitea_service_for_host() {
-    local host="$1"
-    local cred_file="${MOSAIC_CREDENTIALS_FILE:-$HOME/src/jarvis-brain/credentials.json}"
-
-    case "$host" in
-        git.mosaicstack.dev)
-            echo "mosaicstack"
-            return 0
-            ;;
-        git.uscllc.com)
-            echo "usc"
-            return 0
-            ;;
-    esac
-
-    [[ -f "$cred_file" ]] || return 1
-    command -v jq >/dev/null 2>&1 || return 1
-
-    jq -r --arg host "$host" '
-        .gitea // {}
-        | to_entries[]
-        | select((.value.url // "" | sub("/+$"; "")) | test("https?://" + $host + "$"))
-        | .key
-    ' "$cred_file" | head -n 1
-}
-
-find_tea_login_for_host() {
-    local host="$1"
-    local logins_json
-
-    command -v tea >/dev/null 2>&1 || return 1
-    logins_json=$(tea login list --output json 2>/dev/null) || return 1
-    TEA_LOGINS_JSON="$logins_json" python3 - "$host" <<'PY'
-import json
-import os
-import sys
-from urllib.parse import urlparse
-
-host = sys.argv[1]
-try:
-    logins = json.loads(os.environ.get("TEA_LOGINS_JSON", "[]"))
-except Exception:
-    raise SystemExit(1)
-
-for login in logins if isinstance(logins, list) else []:
-    url = str(login.get("url") or login.get("URL") or "")
-    name = str(login.get("name") or login.get("Name") or "")
-    parsed = urlparse(url)
-    if parsed.hostname == host and name:
-        print(name)
-        raise SystemExit(0)
-
-raise SystemExit(1)
-PY
-}
-
-tea_login_matches_host() {
-    local login_name="$1" host="$2"
-    local logins_json
-
-    command -v tea >/dev/null 2>&1 || return 1
-    logins_json=$(tea login list --output json 2>/dev/null) || return 1
-    TEA_LOGINS_JSON="$logins_json" python3 - "$login_name" "$host" <<'PY'
-import json
-import os
-import sys
-from urllib.parse import urlparse
-
-login_name, host = sys.argv[1], sys.argv[2]
-try:
-    logins = json.loads(os.environ.get("TEA_LOGINS_JSON", "[]"))
-except Exception:
-    raise SystemExit(1)
-
-for login in logins if isinstance(logins, list) else []:
-    url = str(login.get("url") or login.get("URL") or "")
-    name = str(login.get("name") or login.get("Name") or "")
-    parsed = urlparse(url)
-    if name == login_name and parsed.hostname == host:
-        raise SystemExit(0)
-
-raise SystemExit(1)
-PY
-}
-
-get_gitea_login_for_host() {
-    local host="${1:-}"
-    local login
-
-    if [[ -z "$host" ]]; then
-        host=$(get_remote_host) || return 1
-    fi
-
-    if [[ -n "${GITEA_LOGIN:-}" ]]; then
-        if tea_login_matches_host "$GITEA_LOGIN" "$host"; then
-            echo "$GITEA_LOGIN"
-            return 0
-        fi
-    fi
-
-    login=$(find_tea_login_for_host "$host" || true)
-    if [[ -n "$login" ]]; then
-        echo "$login"
-        return 0
-    fi
-
-    return 1
-}
-
-get_default_tea_login() {
-    local logins_json
-
-    command -v tea >/dev/null 2>&1 || return 1
-    logins_json=$(tea login list --output json 2>/dev/null) || return 1
-    TEA_LOGINS_JSON="$logins_json" python3 - <<'PY'
-import json
-import os
-
-try:
-    logins = json.loads(os.environ.get("TEA_LOGINS_JSON", "[]"))
-except Exception:
-    raise SystemExit(1)
-
-if not isinstance(logins, list) or not logins:
-    raise SystemExit(1)
-
-for login in logins:
-    if not isinstance(login, dict):
-        continue
-    is_default = str(login.get("default") or login.get("Default") or "").lower()
-    name = str(login.get("name") or login.get("Name") or "")
-    if name and is_default == "true":
-        print(name)
-        raise SystemExit(0)
-
-for login in logins:
-    if not isinstance(login, dict):
-        continue
-    name = str(login.get("name") or login.get("Name") or "")
-    if name:
-        print(name)
-        raise SystemExit(0)
-
-raise SystemExit(1)
-PY
-}
-
-get_gitea_login_for_repo_override() {
-    local login
-
-    if [[ -n "${GITEA_LOGIN:-}" ]]; then
-        echo "$GITEA_LOGIN"
-        return 0
-    fi
-
-    login=$(get_default_tea_login || true)
-    if [[ -n "$login" ]]; then
-        echo "$login"
-        return 0
-    fi
-
-    return 1
-}
-
-get_host_from_url() {
-    local url="${1:-}"
-    [[ -n "$url" ]] || return 1
-
-    python3 - "$url" <<'PY'
-import sys
-from urllib.parse import urlparse
-
-parsed = urlparse(sys.argv[1])
-if parsed.hostname:
-    print(parsed.hostname)
-    raise SystemExit(0)
-raise SystemExit(1)
-PY
-}
-
-get_gitea_api_host_for_repo_override() {
-    if [[ -n "${GITEA_HOST:-}" ]]; then
-        echo "$GITEA_HOST"
-        return 0
-    fi
-
-    get_host_from_url "${GITEA_URL:-}"
-}
-
-get_gitea_repo_args() {
-    local repo host login
-    repo=$(get_repo_slug) || return 1
-    host=$(get_remote_host) || return 1
-    login=$(get_gitea_login_for_host "$host") || return 1
-    printf -- '--repo %q --login %q' "$repo" "$login"
-}
-
-get_gitea_login() {
-    get_gitea_login_for_host "$(get_remote_host)"
-}
-
 get_remote_host() {
     local remote_url
     remote_url=$(git remote get-url origin 2>/dev/null || true)
@@ -292,8 +81,7 @@ get_remote_host() {
         return 1
     fi
     if [[ "$remote_url" =~ ^https?://([^/]+)/ ]]; then
-        local host="${BASH_REMATCH[1]}"
+        echo "${BASH_REMATCH[1]}"
-        echo "${host##*@}"
         return 0
     fi
     if [[ "$remote_url" =~ ^git@([^:]+): ]]; then
@@ -315,28 +103,16 @@ get_gitea_token() {
     if [[ -f "$cred_loader" ]]; then
         local token
         token=$(
-            # shellcheck source=/dev/null
             source "$cred_loader"
-            # Host-specific wrapper resolution must not inherit caller/global GITEA_*.
-            # load_credentials intentionally preserves existing env vars for interactive use,
-            # but metadata/merge wrappers need credentials matching the remote host.
-            unset GITEA_TOKEN GITEA_URL
             case "$host" in
                 git.mosaicstack.dev) load_credentials gitea-mosaicstack 2>/dev/null ;;
                 git.uscllc.com)      load_credentials gitea-usc 2>/dev/null ;;
                 *)
-                    local matched=false
                     for svc in gitea-mosaicstack gitea-usc; do
-                        unset GITEA_TOKEN GITEA_URL
                         load_credentials "$svc" 2>/dev/null || continue
-                        if [[ "${GITEA_URL:-}" == "https://$host" || "${GITEA_URL:-}" == "http://$host" || "${GITEA_URL:-}" == *"//$host" ]]; then
+                        [[ "${GITEA_URL:-}" == *"$host"* ]] && break
-                            matched=true
-                            break
-                        fi
-                    done
-                    if [[ "$matched" != true ]]; then
                         unset GITEA_TOKEN GITEA_URL
-                    fi
+                    done
                     ;;
             esac
             echo "${GITEA_TOKEN:-}"
@@ -347,13 +123,11 @@ get_gitea_token() {
         fi
     fi
 
-    # 2. GITEA_TOKEN env var (only when GITEA_URL, if present, matches the remote host)
+    # 2. GITEA_TOKEN env var (may be set by caller)
     if [[ -n "${GITEA_TOKEN:-}" ]]; then
-        if [[ -z "${GITEA_URL:-}" || "${GITEA_URL:-}" == "https://$host" || "${GITEA_URL:-}" == "http://$host" || "${GITEA_URL:-}" == *"//$host" ]]; then
         echo "$GITEA_TOKEN"
         return 0
     fi
-    fi
 
     # 3. ~/.git-credentials file
     local creds="$HOME/.git-credentials"
@@ -369,37 +143,6 @@ get_gitea_token() {
     return 1
 }
 
-# Resolve HTTPS basic auth credentials for a Gitea host from ~/.git-credentials.
-# Prints "username:password" for direct curl -u consumption. Callers must not log it.
-get_gitea_basic_auth() {
-    local host="$1"
-    local creds="$HOME/.git-credentials"
-    if [[ ! -f "$creds" ]]; then
-        return 1
-    fi
-
-    python3 - "$host" "$creds" <<'PY'
-import sys
-from pathlib import Path
-from urllib.parse import unquote, urlparse
-
-host = sys.argv[1]
-creds = Path(sys.argv[2])
-
-for line in creds.read_text(encoding="utf-8").splitlines():
-    parsed = urlparse(line.strip())
-    if parsed.hostname != host:
-        continue
-    username = unquote(parsed.username or "")
-    password = unquote(parsed.password or "")
-    if username and password:
-        print(f"{username}:{password}")
-        raise SystemExit(0)
-
-raise SystemExit(1)
-PY
-}
-
 # If script is run directly (not sourced), output the platform
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
     detect_platform

packages/mosaic/framework/tools/git/issue-assign.ps1

@@ -75,11 +75,6 @@ switch ($platform) {
         Write-Host "Issue #$Issue updated successfully"
     }
     "gitea" {
-        $repoArgs = @(Get-GiteaRepoArgs)
-        if ($repoArgs.Length -eq 0) {
-            Write-Error "Could not resolve Gitea repo/login for remote host"
-            exit 1
-        }
         $needsEdit = $false
         $cmd = @("tea", "issue", "edit", $Issue)
 
@@ -92,7 +87,7 @@ switch ($platform) {
             $needsEdit = $true
         }
         if ($Milestone) {
-            $milestoneList = tea milestones list @repoArgs 2>$null
+            $milestoneList = tea milestones list 2>$null
             $milestoneId = ($milestoneList | Select-String "^\s*(\d+).*$Milestone" | ForEach-Object { $_.Matches.Groups[1].Value } | Select-Object -First 1)
             if ($milestoneId) {
                 $cmd += @("--milestone", $milestoneId)
@@ -103,7 +98,6 @@ switch ($platform) {
         }
 
         if ($needsEdit) {
-            $cmd += $repoArgs
             & $cmd[0] $cmd[1..($cmd.Length-1)]
             Write-Host "Issue #$Issue updated successfully"
         } else {

packages/mosaic/framework/tools/git/issue-assign.sh

@@ -98,32 +98,23 @@ case "$PLATFORM" in
         ;;
     gitea)
         # tea issue edit syntax
-        REPO_SLUG=$(get_repo_slug) || {
+        CMD="tea issue edit $ISSUE"
-            echo "Error: Could not resolve Gitea repo slug from remote" >&2
-            exit 1
-        }
-        REPO_LOGIN=$(get_gitea_login) || {
-            echo "Error: Could not resolve Gitea login for remote host" >&2
-            exit 1
-        }
-        REPO_ARGS=(--repo "$REPO_SLUG" --login "$REPO_LOGIN")
-        CMD=(tea issue edit "$ISSUE" "${REPO_ARGS[@]}")
         NEEDS_EDIT=false
 
         if [[ -n "$ASSIGNEE" ]]; then
             # tea uses --assignees flag
-            CMD+=(--assignees "$ASSIGNEE")
+            CMD="$CMD --assignees \"$ASSIGNEE\""
             NEEDS_EDIT=true
         fi
         if [[ -n "$LABELS" ]]; then
             # tea uses --labels flag (replaces existing)
-            CMD+=(--labels "$LABELS")
+            CMD="$CMD --labels \"$LABELS\""
             NEEDS_EDIT=true
         fi
         if [[ -n "$MILESTONE" ]]; then
-            MILESTONE_ID=$(tea milestones list "${REPO_ARGS[@]}" 2>/dev/null | grep -E "^\s*[0-9]+" | grep "$MILESTONE" | awk '{print $1}' | head -1)
+            MILESTONE_ID=$(tea milestones list 2>/dev/null | grep -E "^\s*[0-9]+" | grep "$MILESTONE" | awk '{print $1}' | head -1)
             if [[ -n "$MILESTONE_ID" ]]; then
-                CMD+=(--milestone "$MILESTONE_ID")
+                CMD="$CMD --milestone $MILESTONE_ID"
                 NEEDS_EDIT=true
             else
                 echo "Warning: Could not find milestone '$MILESTONE'" >&2
@@ -131,7 +122,7 @@ case "$PLATFORM" in
         fi
 
         if [[ "$NEEDS_EDIT" == true ]]; then
-            "${CMD[@]}"
+            eval "$CMD"
             echo "Issue #$ISSUE updated successfully"
         else
             echo "No changes specified"

packages/mosaic/framework/tools/git/issue-close.sh

@@ -44,43 +44,10 @@ if [[ -z "$ISSUE_NUMBER" ]]; then
 fi
 
 # Detect platform and close issue
-detect_platform >/dev/null
+detect_platform
 OWNER=$(get_repo_owner)
 REPO=$(get_repo_name)
 
-gitea_issue_comment_api() {
-    local host token url payload
-    host=$(get_remote_host) || return 1
-    token=$(get_gitea_token "$host") || return 1
-    url="https://${host}/api/v1/repos/${OWNER}/${REPO}/issues/${ISSUE_NUMBER}/comments"
-    payload=$(COMMENT="$COMMENT" python3 - <<'PY'
-import json
-import os
-
-print(json.dumps({"body": os.environ["COMMENT"]}))
-PY
-)
-    curl -fsS -X POST \
-        -H "User-Agent: curl/8" \
-        -H "Authorization: token ${token}" \
-        -H "Content-Type: application/json" \
-        -d "$payload" \
-        "$url" >/dev/null
-}
-
-gitea_issue_close_api() {
-    local host token url
-    host=$(get_remote_host) || return 1
-    token=$(get_gitea_token "$host") || return 1
-    url="https://${host}/api/v1/repos/${OWNER}/${REPO}/issues/${ISSUE_NUMBER}"
-    curl -fsS -X PATCH \
-        -H "User-Agent: curl/8" \
-        -H "Authorization: token ${token}" \
-        -H "Content-Type: application/json" \
-        -d '{"state":"closed"}' \
-        "$url" >/dev/null
-}
-
 if [[ "$PLATFORM" == "github" ]]; then
     if [[ -n "$COMMENT" ]]; then
         gh issue comment "$ISSUE_NUMBER" --body "$COMMENT"
@@ -88,19 +55,10 @@ if [[ "$PLATFORM" == "github" ]]; then
     gh issue close "$ISSUE_NUMBER"
     echo "Closed GitHub issue #$ISSUE_NUMBER"
 elif [[ "$PLATFORM" == "gitea" ]]; then
-    GITEA_LOGIN_NAME=$(get_gitea_login || true)
-    if [[ -n "$GITEA_LOGIN_NAME" ]]; then
     if [[ -n "$COMMENT" ]]; then
-            tea issue comment "$ISSUE_NUMBER" "$COMMENT" --repo "$OWNER/$REPO" --login "$GITEA_LOGIN_NAME"
+        tea issue comment "$ISSUE_NUMBER" "$COMMENT" --repo "$OWNER/$REPO" --login "${GITEA_LOGIN:-mosaicstack}"
-        fi
-        tea issue close "$ISSUE_NUMBER" --repo "$OWNER/$REPO" --login "$GITEA_LOGIN_NAME"
-    else
-        echo "No tea login configured for $(get_remote_host); using authenticated Gitea API fallback." >&2
-        if [[ -n "$COMMENT" ]]; then
-            gitea_issue_comment_api
-        fi
-        gitea_issue_close_api
     fi
+    tea issue close "$ISSUE_NUMBER" --repo "$OWNER/$REPO" --login "${GITEA_LOGIN:-mosaicstack}"
     echo "Closed Gitea issue #$ISSUE_NUMBER"
 else
     echo "Error: Unknown platform"

packages/mosaic/framework/tools/git/issue-comment.sh

@@ -47,13 +47,13 @@ if [[ -z "$COMMENT" ]]; then
     exit 1
 fi
 
-detect_platform >/dev/null
+detect_platform
 
 if [[ "$PLATFORM" == "github" ]]; then
     gh issue comment "$ISSUE_NUMBER" --body "$COMMENT"
     echo "Added comment to GitHub issue #$ISSUE_NUMBER"
 elif [[ "$PLATFORM" == "gitea" ]]; then
-    tea issue comment "$ISSUE_NUMBER" "$COMMENT" $(get_gitea_repo_args)
+    tea issue comment "$ISSUE_NUMBER" "$COMMENT"
     echo "Added comment to Gitea issue #$ISSUE_NUMBER"
 else
     echo "Error: Unknown platform"

packages/mosaic/framework/tools/git/issue-create.ps1

@@ -58,17 +58,12 @@ switch ($platform) {
         & $cmd[0] $cmd[1..($cmd.Length-1)]
     }
     "gitea" {
-        $repoArgs = @(Get-GiteaRepoArgs)
-        if ($repoArgs.Length -eq 0) {
-            Write-Error "Could not resolve Gitea repo/login for remote host"
-            exit 1
-        }
         $cmd = @("tea", "issue", "create", "--title", $Title)
         if ($Body) { $cmd += @("--description", $Body) }
         if ($Labels) { $cmd += @("--labels", $Labels) }
         if ($Milestone) {
             # Try to get milestone ID by name
-            $milestoneList = tea milestones list @repoArgs 2>$null
+            $milestoneList = tea milestones list 2>$null
             $milestoneId = ($milestoneList | Select-String "^\s*(\d+).*$Milestone" | ForEach-Object { $_.Matches.Groups[1].Value } | Select-Object -First 1)
             if ($milestoneId) {
                 $cmd += @("--milestone", $milestoneId)
@@ -76,7 +71,6 @@ switch ($platform) {
                 Write-Warning "Could not find milestone '$Milestone', creating without milestone"
             }
         }
-        $cmd += $repoArgs
         & $cmd[0] $cmd[1..($cmd.Length-1)]
     }
     default {

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

@@ -48,7 +48,6 @@ PY
 
     url="https://${host}/api/v1/repos/${repo}/issues"
     curl -fsS -X POST \
-      -H "User-Agent: curl/8" \
       -H "Authorization: token ${token}" \
       -H "Content-Type: application/json" \
       -d "$payload" \
@@ -113,27 +112,20 @@ PLATFORM=$(detect_platform)
 
 case "$PLATFORM" in
     github)
-        CMD=(gh issue create --title "$TITLE")
+        CMD="gh issue create --title \"$TITLE\""
-        [[ -n "$BODY" ]] && CMD+=(--body "$BODY")
+        [[ -n "$BODY" ]] && CMD="$CMD --body \"$BODY\""
-        [[ -n "$LABELS" ]] && CMD+=(--label "$LABELS")
+        [[ -n "$LABELS" ]] && CMD="$CMD --label \"$LABELS\""
-        [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
+        [[ -n "$MILESTONE" ]] && CMD="$CMD --milestone \"$MILESTONE\""
-        "${CMD[@]}"
+        eval "$CMD"
         ;;
     gitea)
         if command -v tea >/dev/null 2>&1; then
-            REPO_SLUG=$(get_repo_slug)
+            CMD="tea issue create --title \"$TITLE\""
-            GITEA_LOGIN_NAME=$(get_gitea_login) || {
+            [[ -n "$BODY" ]] && CMD="$CMD --description \"$BODY\""
-                echo "Warning: could not resolve Gitea login for tea; trying Gitea API fallback..." >&2
+            [[ -n "$LABELS" ]] && CMD="$CMD --labels \"$LABELS\""
-                gitea_issue_create_api
-                exit $?
-            }
-            REPO_ARGS=(--repo "$REPO_SLUG" --login "$GITEA_LOGIN_NAME")
-            CMD=(tea issue create "${REPO_ARGS[@]}" --title "$TITLE")
-            [[ -n "$BODY" ]] && CMD+=(--description "$BODY")
-            [[ -n "$LABELS" ]] && CMD+=(--labels "$LABELS")
             # tea accepts milestone by name directly (verified 2026-02-05)
-            [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
+            [[ -n "$MILESTONE" ]] && CMD="$CMD --milestone \"$MILESTONE\""
-            if "${CMD[@]}"; then
+            if eval "$CMD"; then
                 exit 0
             fi
             echo "Warning: tea issue create failed, trying Gitea API fallback..." >&2

packages/mosaic/framework/tools/git/issue-edit.sh

@@ -60,31 +60,23 @@ if [[ -z "$ISSUE_NUMBER" ]]; then
     exit 1
 fi
 
-detect_platform >/dev/null
+detect_platform
 
 if [[ "$PLATFORM" == "github" ]]; then
-    CMD=(gh issue edit "$ISSUE_NUMBER")
+    CMD="gh issue edit $ISSUE_NUMBER"
-    [[ -n "$TITLE" ]] && CMD+=(--title "$TITLE")
+    [[ -n "$TITLE" ]] && CMD="$CMD --title \"$TITLE\""
-    [[ -n "$BODY" ]] && CMD+=(--body "$BODY")
+    [[ -n "$BODY" ]] && CMD="$CMD --body \"$BODY\""
-    [[ -n "$LABELS" ]] && CMD+=(--add-label "$LABELS")
+    [[ -n "$LABELS" ]] && CMD="$CMD --add-label \"$LABELS\""
-    [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
+    [[ -n "$MILESTONE" ]] && CMD="$CMD --milestone \"$MILESTONE\""
-    "${CMD[@]}"
+    eval $CMD
     echo "Updated GitHub issue #$ISSUE_NUMBER"
 elif [[ "$PLATFORM" == "gitea" ]]; then
-    REPO_SLUG=$(get_repo_slug) || {
+    CMD="tea issue edit $ISSUE_NUMBER"
-        echo "Error: Could not resolve Gitea repo slug from remote" >&2
+    [[ -n "$TITLE" ]] && CMD="$CMD --title \"$TITLE\""
-        exit 1
+    [[ -n "$BODY" ]] && CMD="$CMD --description \"$BODY\""
-    }
+    [[ -n "$LABELS" ]] && CMD="$CMD --add-labels \"$LABELS\""
-    REPO_LOGIN=$(get_gitea_login) || {
+    [[ -n "$MILESTONE" ]] && CMD="$CMD --milestone \"$MILESTONE\""
-        echo "Error: Could not resolve Gitea login for remote host" >&2
+    eval $CMD
-        exit 1
-    }
-    CMD=(tea issue edit "$ISSUE_NUMBER" --repo "$REPO_SLUG" --login "$REPO_LOGIN")
-    [[ -n "$TITLE" ]] && CMD+=(--title "$TITLE")
-    [[ -n "$BODY" ]] && CMD+=(--description "$BODY")
-    [[ -n "$LABELS" ]] && CMD+=(--add-labels "$LABELS")
-    [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
-    "${CMD[@]}"
     echo "Updated Gitea issue #$ISSUE_NUMBER"
 else
     echo "Error: Unknown platform"

packages/mosaic/framework/tools/git/issue-list.ps1

@@ -63,15 +63,9 @@ switch ($platform) {
         & $cmd[0] $cmd[1..($cmd.Length-1)]
     }
     "gitea" {
-        $repoArgs = @(Get-GiteaRepoArgs)
-        if ($repoArgs.Length -eq 0) {
-            Write-Error "Could not resolve Gitea repo/login for remote host"
-            exit 1
-        }
         $cmd = @("tea", "issues", "list", "--state", $State, "--limit", $Limit)
         if ($Label) { $cmd += @("--labels", $Label) }
         if ($Milestone) { $cmd += @("--milestones", $Milestone) }
-        $cmd += $repoArgs
         & $cmd[0] $cmd[1..($cmd.Length-1)]
         if ($Assignee) {
             Write-Warning "Assignee filtering may require manual review for Gitea"

packages/mosaic/framework/tools/git/issue-list.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # issue-list.sh - List issues on Gitea or GitHub
-# Usage: issue-list.sh [-r owner/repo] [-s state] [-l label] [-m milestone] [-a assignee]
+# Usage: issue-list.sh [-s state] [-l label] [-m milestone] [-a assignee]
 
 set -e
 
@@ -13,7 +13,6 @@ LABEL=""
 MILESTONE=""
 ASSIGNEE=""
 LIMIT=100
-REPO_OVERRIDE=""
 
 usage() {
     cat <<EOF
@@ -27,14 +26,12 @@ Options:
     -m, --milestone NAME    Filter by milestone name
     -a, --assignee USER     Filter by assignee
     -n, --limit N           Maximum issues to show (default: 100)
-    -r, --repo OWNER/REPO   Repository slug (default: infer from git origin)
     -h, --help              Show this help message
 
 Examples:
     $(basename "$0")                          # List open issues
     $(basename "$0") -s all -l bug            # All issues with 'bug' label
     $(basename "$0") -m "0.2.0"               # Issues in milestone 0.2.0
-    $(basename "$0") --repo ddk/ai-bma         # List issues from anywhere
 EOF
     exit 1
 }
@@ -62,10 +59,6 @@ while [[ $# -gt 0 ]]; do
             LIMIT="$2"
             shift 2
             ;;
-        -r|--repo)
-            REPO_OVERRIDE="$2"
-            shift 2
-            ;;
         -h|--help)
             usage
             ;;
@@ -76,45 +69,25 @@ while [[ $# -gt 0 ]]; do
     esac
 done
 
-if [[ -n "$REPO_OVERRIDE" ]]; then
+PLATFORM=$(detect_platform)
-    REPO_INFO="$REPO_OVERRIDE"
-    PLATFORM=$(detect_platform 2>/dev/null || echo gitea)
-else
-    PLATFORM=$(detect_platform)
-    REPO_INFO=$(get_repo_info)
-fi
-
-if [[ -z "$REPO_INFO" || "$REPO_INFO" == error:* ]]; then
-    echo "Error: Could not determine repository from git origin. Run from a repo or pass --repo." >&2
-    exit 1
-fi
 
 case "$PLATFORM" in
     github)
-        CMD=(gh issue list --repo "$REPO_INFO" --state "$STATE" --limit "$LIMIT")
+        CMD="gh issue list --state $STATE --limit $LIMIT"
-        [[ -n "$LABEL" ]] && CMD+=(--label "$LABEL")
+        [[ -n "$LABEL" ]] && CMD="$CMD --label \"$LABEL\""
-        [[ -n "$MILESTONE" ]] && CMD+=(--milestone "$MILESTONE")
+        [[ -n "$MILESTONE" ]] && CMD="$CMD --milestone \"$MILESTONE\""
-        [[ -n "$ASSIGNEE" ]] && CMD+=(--assignee "$ASSIGNEE")
+        [[ -n "$ASSIGNEE" ]] && CMD="$CMD --assignee \"$ASSIGNEE\""
-        "${CMD[@]}"
+        eval "$CMD"
         ;;
     gitea)
-        if [[ -n "$REPO_OVERRIDE" ]]; then
+        CMD="tea issues list --state $STATE --limit $LIMIT"
-            GITEA_LOGIN_NAME=$(get_gitea_login_for_repo_override) || {
+        [[ -n "$LABEL" ]] && CMD="$CMD --labels \"$LABEL\""
-                echo "Error: Could not resolve Gitea login for --repo override. Set GITEA_LOGIN or configure a default tea login." >&2
+        [[ -n "$MILESTONE" ]] && CMD="$CMD --milestones \"$MILESTONE\""
-                exit 1
+        # Note: tea may not support assignee filter directly
-            }
+        eval "$CMD"
-        else
+        if [[ -n "$ASSIGNEE" ]]; then
-            GITEA_LOGIN_NAME=$(get_gitea_login) || {
+            echo "Note: Assignee filtering may require manual review for Gitea" >&2
-                echo "Error: Could not resolve Gitea login for remote host" >&2
-                exit 1
-            }
         fi
-        CMD=(tea issues list --repo "$REPO_INFO" --login "$GITEA_LOGIN_NAME" --state "$STATE" --limit "$LIMIT")
-        [[ -n "$LABEL" ]] && CMD+=(--labels "$LABEL")
-        [[ -n "$MILESTONE" ]] && CMD+=(--milestones "$MILESTONE")
-        # Note: tea may not support assignee filter directly in all versions.
-        [[ -n "$ASSIGNEE" ]] && echo "Note: Assignee filtering may require manual review for Gitea" >&2
-        "${CMD[@]}"
         ;;
     *)
         echo "Error: Could not detect git platform" >&2

packages/mosaic/framework/tools/git/issue-reopen.sh

@@ -42,42 +42,7 @@ if [[ -z "$ISSUE_NUMBER" ]]; then
     exit 1
 fi
 
-detect_platform >/dev/null
+detect_platform
-OWNER=$(get_repo_owner)
-REPO=$(get_repo_name)
-
-gitea_issue_comment_api() {
-    local host token url payload
-    host=$(get_remote_host) || return 1
-    token=$(get_gitea_token "$host") || return 1
-    url="https://${host}/api/v1/repos/${OWNER}/${REPO}/issues/${ISSUE_NUMBER}/comments"
-    payload=$(COMMENT="$COMMENT" python3 - <<'PY'
-import json
-import os
-
-print(json.dumps({"body": os.environ["COMMENT"]}))
-PY
-)
-    curl -fsS -X POST \
-        -H "User-Agent: curl/8" \
-        -H "Authorization: token ${token}" \
-        -H "Content-Type: application/json" \
-        -d "$payload" \
-        "$url" >/dev/null
-}
-
-gitea_issue_reopen_api() {
-    local host token url
-    host=$(get_remote_host) || return 1
-    token=$(get_gitea_token "$host") || return 1
-    url="https://${host}/api/v1/repos/${OWNER}/${REPO}/issues/${ISSUE_NUMBER}"
-    curl -fsS -X PATCH \
-        -H "User-Agent: curl/8" \
-        -H "Authorization: token ${token}" \
-        -H "Content-Type: application/json" \
-        -d '{"state":"open"}' \
-        "$url" >/dev/null
-}
 
 if [[ "$PLATFORM" == "github" ]]; then
     if [[ -n "$COMMENT" ]]; then
@@ -86,19 +51,10 @@ if [[ "$PLATFORM" == "github" ]]; then
     gh issue reopen "$ISSUE_NUMBER"
     echo "Reopened GitHub issue #$ISSUE_NUMBER"
 elif [[ "$PLATFORM" == "gitea" ]]; then
-    REPO_ARGS=$(get_gitea_repo_args || true)
-    if [[ -n "$REPO_ARGS" ]]; then
     if [[ -n "$COMMENT" ]]; then
-            tea issue comment "$ISSUE_NUMBER" "$COMMENT" $REPO_ARGS
+        tea issue comment "$ISSUE_NUMBER" "$COMMENT"
-        fi
-        tea issue reopen "$ISSUE_NUMBER" $REPO_ARGS
-    else
-        echo "No tea login configured for $(get_remote_host); using authenticated Gitea API fallback." >&2
-        if [[ -n "$COMMENT" ]]; then
-            gitea_issue_comment_api
-        fi
-        gitea_issue_reopen_api
     fi
+    tea issue reopen "$ISSUE_NUMBER"
     echo "Reopened Gitea issue #$ISSUE_NUMBER"
 else
     echo "Error: Unknown platform"

packages/mosaic/framework/tools/git/issue-view.sh

@@ -29,9 +29,9 @@ gitea_issue_view_api() {
 
     url="https://${host}/api/v1/repos/${repo}/issues/${ISSUE_NUMBER}"
     if command -v python3 >/dev/null 2>&1; then
-        curl -fsS -H "User-Agent: curl/8" -H "Authorization: token ${token}" "$url" | python3 -m json.tool
+        curl -fsS -H "Authorization: token ${token}" "$url" | python3 -m json.tool
     else
-        curl -fsS -H "User-Agent: curl/8" -H "Authorization: token ${token}" "$url"
+        curl -fsS -H "Authorization: token ${token}" "$url"
     fi
 }
 
@@ -61,13 +61,13 @@ if [[ -z "$ISSUE_NUMBER" ]]; then
     exit 1
 fi
 
-detect_platform >/dev/null
+detect_platform
 
 if [[ "$PLATFORM" == "github" ]]; then
     gh issue view "$ISSUE_NUMBER"
 elif [[ "$PLATFORM" == "gitea" ]]; then
     if command -v tea >/dev/null 2>&1; then
-        if tea issue "$ISSUE_NUMBER" $(get_gitea_repo_args); then
+        if tea issue "$ISSUE_NUMBER"; then
             exit 0
         fi
         echo "Warning: tea issue view failed, trying Gitea API fallback..." >&2

packages/mosaic/framework/tools/git/lane-brief.sh

@@ -1,129 +0,0 @@
-#!/usr/bin/env bash
-#
-# lane-brief.sh — live dispatch brief for a repo "lane" (milestone/label), straight
-# from current Gitea state. Defeats stale worker self-report: workers brief from
-# static notes and routinely report issues "todo" that are already CLOSED, forcing
-# the orchestrator to re-verify each one before dispatch. This returns the CURRENT
-# open set, classified for dispatch, in one call.
-#
-# Usage:
-#   lane-brief.sh -r <owner/repo> [-m <milestone>] [-l <label>] [-L <login>] [-n <limit>]
-#   lane-brief.sh -r usc/uconnect -m "M2M Part Search (0.0.45)"
-#   lane-brief.sh -r usc/uconnect -l domain/6-security
-#
-# Reliable signals (closed issues are excluded by definition — that's the point):
-#   - open-vs-closed : authoritative; this is the stale-intake failure mode.
-#   - PR-linkage     : an open PR referencing the issue = work underway.
-# Assignees/dependencies are intentionally NOT trusted as "available" signals —
-# fleets that track work-state out-of-band (tmux board, issue text) leave them
-# empty in Gitea. Output therefore partitions by PR presence and the OPEN-NO-PR set
-# is "dispatch candidates to cross-check against the live fleet", not a blind list.
-#
-# Login resolution order: -L flag > $GITEA_LOGIN > owner inference (usc->usc,
-# mosaicstack/mosaic->mosaicstack) > detect-platform.sh default-login fallback.
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-# shellcheck source=/dev/null
-source "$SCRIPT_DIR/detect-platform.sh"
-
-REPO="" MILESTONE="" LABEL="" LOGIN="" LIMIT=100
-while getopts "r:m:l:L:n:h" opt; do
-  case "$opt" in
-    r) REPO="$OPTARG" ;;
-    m) MILESTONE="$OPTARG" ;;
-    l) LABEL="$OPTARG" ;;
-    L) LOGIN="$OPTARG" ;;
-    n) LIMIT="$OPTARG" ;;
-    h) grep '^#' "$0" | sed 's/^# \?//'; exit 0 ;;
-    *) echo "see -h" >&2; exit 2 ;;
-  esac
-done
-[[ -n "$REPO" ]] || { echo "FATAL: -r <owner/repo> required" >&2; exit 2; }
-
-# Resolve login: explicit -L, then $GITEA_LOGIN, then owner inference, then the
-# shared default-login resolver. Owner inference comes before the shared fallback
-# because the latter is not owner-aware (picks the default tea login), which is
-# wrong for cross-instance lanes.
-if [[ -z "$LOGIN" ]]; then
-  if [[ -n "${GITEA_LOGIN:-}" ]]; then
-    LOGIN="$GITEA_LOGIN"
-  else
-    case "${REPO%%/*}" in
-      usc|USC) LOGIN=usc ;;
-      mosaicstack|mosaic) LOGIN=mosaicstack ;;
-      *) LOGIN="$(get_gitea_login_for_repo_override 2>/dev/null || true)" ;;
-    esac
-  fi
-fi
-[[ -n "$LOGIN" ]] || { echo "FATAL: could not resolve a Gitea login for $REPO (pass -L or set GITEA_LOGIN)" >&2; exit 2; }
-
-command -v tea >/dev/null || { echo "FATAL: tea not found" >&2; exit 1; }
-command -v jq  >/dev/null || { echo "FATAL: jq not found" >&2; exit 1; }
-
-ISSUES_JSON="$(tea issues list --repo "$REPO" --login "$LOGIN" --state open --limit "$LIMIT" \
-  --fields index,title,assignees,milestone,labels --output json 2>/dev/null)" || {
-  echo "FATAL: tea issues list failed for $REPO (login=$LOGIN)" >&2; exit 1; }
-
-# Open PRs, to cross-ref which issues already have work in flight. An issue is
-# "work underway" if an open PR links to it. Two link signals are honored:
-#   (a) a closing keyword in the PR BODY — Gitea's auto-close set (close/closes/
-#       closed, fix/fixes/fixed, resolve/resolves/resolved), case-insensitive,
-#       directly preceding `#N`. This is the AUTHORITATIVE link Gitea itself uses
-#       to associate a PR with the issue it resolves; a body-only "Closes #546"
-#       is the common case and MUST count. The earlier version inspected only the
-#       PR index/title/head TSV (never the body or Gitea linkage), so a body-only
-#       reference was invisible and the linked OPEN issue was misclassified as a
-#       dispatch candidate — re-dispatchable in-flight work (the #546/#547 defect).
-#   (b) a bare #N in the PR title, or an issue number embedded in the head branch
-#       (feat/546-x, fix-546) — the weaker heuristic preserved from prior behavior.
-# Bare #N mentions in the BODY are deliberately NOT treated as links: PR bodies
-# routinely name unrelated issues in prose ("relevant to the #538 line of work"),
-# and counting those would wrongly mark live, dispatchable issues as in-flight.
-# Only the closing-keyword form is a commitment to resolve that issue. Requiring
-# `#` to directly follow the keyword also keeps cross-repo `owner/repo#N` forms
-# from leaking a foreign issue number into this per-repo lane (cross-repo lanes
-# are run per-repo). JSON (not TSV) is used so multi-line bodies parse cleanly.
-PRS_JSON="$(tea pulls list --repo "$REPO" --login "$LOGIN" --state open \
-  --fields index,title,head,body --output json 2>/dev/null || echo '[]')"
-[[ -n "$PRS_JSON" ]] || PRS_JSON='[]'
-
-# \b anchors the keyword to a word start so embedded substrings do not match
-# (e.g. "prefix #5", "disclosed #7" must NOT be read as "fix #5" / "closed #7").
-GITEA_CLOSE_KW='close[sd]?|fix(e[sd])?|resolve[sd]?'
-PR_BODY_REFS="$(printf '%s' "$PRS_JSON" | jq -r '.[] | .body // ""' 2>/dev/null \
-  | grep -oiE "\\b(${GITEA_CLOSE_KW})[[:space:]:]+#[0-9]+" | grep -oE '[0-9]+' || true)"
-PR_TITLE_HEAD_REFS="$(printf '%s' "$PRS_JSON" \
-  | jq -r '.[] | [ (.title // ""), (.head // "" | if type=="object" then (.ref // "") else . end) ] | join(" ")' 2>/dev/null \
-  | grep -oE '#[0-9]+|[/-][0-9]{3,}' | grep -oE '[0-9]+' || true)"
-PR_ISSUE_REFS="$(printf '%s\n%s\n' "$PR_BODY_REFS" "$PR_TITLE_HEAD_REFS" | grep -E '^[0-9]+$' | sort -u || true)"
-
-ts="$(date -u '+%Y-%m-%d %H:%MZ' 2>/dev/null || echo '?')"
-filt="$REPO"; [[ -n "$MILESTONE" ]] && filt="$filt · milestone:'$MILESTONE'"; [[ -n "$LABEL" ]] && filt="$filt · label:'$LABEL'"
-echo "LANE BRIEF — $filt · $ts (login=$LOGIN)"
-echo "(open issues only; closed are excluded by definition — that's the point)"
-echo
-
-# Label match is exact-token against tea's space-separated labels string (so -l
-# "security" does NOT match label "domain/6-security"). Caveat: label names that
-# themselves contain spaces aren't distinguishable in tea's string form.
-printf '%s' "$ISSUES_JSON" | jq -r --arg ms "$MILESTONE" --arg lb "$LABEL" --arg prs "$PR_ISSUE_REFS" '
-  ($prs | split("\n") | map(select(length>0))) as $prrefs
-  | map(
-      select( ($ms=="" or .milestone==$ms)
-          and ($lb=="" or ((.labels//"") | split(" ") | index($lb) != null)) )
-      | . + { assigned: ((.assignees//"")|length>0),
-              haspr: (.index as $ix | ($prrefs | index($ix)) != null) }
-    )
-  | (map(select(.haspr|not)))  as $candidates
-  | (map(select(.haspr)))      as $inflight
-  | "DISPATCH CANDIDATES (open · no open PR) — \($candidates|length)  [cross-check vs live fleet]:",
-    ( $candidates[] | "  #\(.index)  \(.title[0:90])\(if .assigned then "  (gitea-assignee set)" else "" end)" ),
-    "",
-    "WORK UNDERWAY (open · PR in flight) — \($inflight|length):",
-    ( $inflight[] | "  #\(.index)  \(.title[0:80])  [PR open]" )
-'
-echo
-echo "Closed issues are excluded — do NOT take a worker's self-reported 'todo' on faith."
-echo "Candidates = open + no PR; confirm against the live fleet before dispatch"
-echo "(fleets that don't self-assign in Gitea leave 'unassigned' meaningless)."

packages/mosaic/framework/tools/git/milestone-close.sh

@@ -36,17 +36,13 @@ if [[ -z "$TITLE" ]]; then
     exit 1
 fi
 
-detect_platform >/dev/null
+detect_platform
 
 if [[ "$PLATFORM" == "github" ]]; then
     gh api -X PATCH "/repos/{owner}/{repo}/milestones/$(gh api "/repos/{owner}/{repo}/milestones" --jq ".[] | select(.title==\"$TITLE\") | .number")" -f state=closed
     echo "Closed GitHub milestone: $TITLE"
 elif [[ "$PLATFORM" == "gitea" ]]; then
-    REPO_ARGS=$(get_gitea_repo_args) || {
+    tea milestone close "$TITLE"
-        echo "Error: Could not resolve Gitea repo/login for remote host" >&2
-        exit 1
-    }
-    tea milestone close "$TITLE" $REPO_ARGS
     echo "Closed Gitea milestone: $TITLE"
 else
     echo "Error: Unknown platform"